WIP

dist/index.js

@@ -619,7 +619,7 @@ function setOutput(versionResult) {
     const { major, minor, patch, increment, versionType, formattedVersion, versionTag, changed, isTagged, authors, currentCommit, previousCommit, previousVersion, debugOutput } = versionResult;
     const repository = process.env.GITHUB_REPOSITORY;
     if (!changed) {
-        core.info("VAGOOO")
+        core.info("VAGOOO2")
         core.info('No changes detected for this commit');
     }
     core.info(`Version is ${formattedVersion}`);

lib/action.js

@@ -1,4 +1,27 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
@@ -15,8 +38,10 @@ const VersionType_1 = require("./providers/VersionType");
 const UserInfo_1 = require("./providers/UserInfo");
 const VersionInformation_1 = require("./providers/VersionInformation");
 const DebugManager_1 = require("./DebugManager");
+const core = __importStar(require("@actions/core"));
 function runAction(configurationProvider) {
     return __awaiter(this, void 0, void 0, function* () {
+        core.info("VAGO STARTING runAction");
         const currentCommitResolver = configurationProvider.GetCurrentCommitResolver();
         const lastReleaseResolver = configurationProvider.GetLastReleaseResolver();
         const commitsProvider = configurationProvider.GetCommitsProvider();
@@ -26,13 +51,20 @@ function runAction(configurationProvider) {
         const userFormatter = configurationProvider.GetUserFormatter();
         const debugManager = DebugManager_1.DebugManager.getInstance();
         if (yield currentCommitResolver.IsEmptyRepoAsync()) {
+            core.info("VAGO REPO WAS EMPTY, returning default version information");
             const versionInfo = new VersionInformation_1.VersionInformation(0, 0, 0, 0, VersionType_1.VersionType.None, [], false, false);
             return new VersionResult_1.VersionResult(versionInfo.major, versionInfo.minor, versionInfo.patch, versionInfo.increment, versionInfo.type, versionFormatter.Format(versionInfo), tagFormatter.Format(versionInfo), versionInfo.changed, versionInfo.isTagged, userFormatter.Format('author', []), '', '', tagFormatter.Parse(tagFormatter.Format(versionInfo)).join('.'), debugManager.getDebugOutput(true));
         }
+        core.info("VAGO REPO IS NOT EMPTY, continuing with versioning");
         const currentCommit = yield currentCommitResolver.ResolveAsync();
+        core.info("VAGO CURRENT COMMIT: " + currentCommit);
         const lastRelease = yield lastReleaseResolver.ResolveAsync(currentCommit, tagFormatter);
+        core.info("VAGO LAST RELEASE: " + lastRelease.hash + " " + lastRelease.major + "." + lastRelease.minor + "." + lastRelease.patch);
         const commitSet = yield commitsProvider.GetCommitsAsync(lastRelease.hash, currentCommit);
+        core.info("VAGO commit set le:" + commitSet.commits.length);
+        core.info("VAGO commit set changed: " + commitSet.changed.toString());
         const classification = yield versionClassifier.ClassifyAsync(lastRelease, commitSet);
+        core.info("VAGO classification: " + JSON.stringify(classification));
         const { isTagged } = lastRelease;
         const { major, minor, patch, increment, type, changed } = classification;
         // At this point all necessary data has been pulled from the database, create

lib/main.js

@@ -41,6 +41,7 @@ function setOutput(versionResult) {
     const { major, minor, patch, increment, versionType, formattedVersion, versionTag, changed, isTagged, authors, currentCommit, previousCommit, previousVersion, debugOutput } = versionResult;
     const repository = process.env.GITHUB_REPOSITORY;
     if (!changed) {
+        core.info("VAGOOO1");
         core.info('No changes detected for this commit');
     }
     core.info(`Version is ${formattedVersion}`);
@@ -64,6 +65,7 @@ function setOutput(versionResult) {
 }
 function run() {
     return __awaiter(this, void 0, void 0, function* () {
+        core.info("VAGO Starting run action...");
         function toBool(value) {
             if (!value || value.toLowerCase() === 'false') {
                 return false;
@@ -113,7 +115,9 @@ function run() {
             core.warning(`The 'short_tags' input option is no longer supported`);
         }
         const configurationProvider = new ConfigurationProvider_1.ConfigurationProvider(config);
+        core.info("VAGO start await runAction(configurationProvider)");
         const result = yield (0, action_1.runAction)(configurationProvider);
+        core.info("VAGO before setOutput(result)");
         setOutput(result);
     });
 }

lib/providers/DefaultVersionClassifier.js

@@ -1,4 +1,27 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
@@ -12,6 +35,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.DefaultVersionClassifier = void 0;
 const VersionClassification_1 = require("./VersionClassification");
 const VersionType_1 = require("./VersionType");
+const core = __importStar(require("@actions/core"));
 class DefaultVersionClassifier {
     constructor(config) {
         const searchBody = config.searchCommitBody;
@@ -85,9 +109,13 @@ class DefaultVersionClassifier {
     }
     ClassifyAsync(lastRelease, commitSet) {
         return __awaiter(this, void 0, void 0, function* () {
+            core.info("VAGO DefaultVersionClassifier.ClassifyAsync called");
             const { type, increment, changed } = this.resolveCommitType(commitSet);
+            core.info("VAGO DefaultVersionClassifier.ClassifyAsync: type: " + VersionType_1.VersionType[type] + ", increment: " + increment + ", changed: " + changed);
             const { major, minor, patch } = this.getNextVersion(lastRelease, type);
+            core.info("VAGOO DefaultVersionClassifier.ClassifyAsync: major: " + major + ", minor: " + minor + ", patch: " + patch);
             if (lastRelease.currentPatch !== null) {
+                core.info("VAGO DefaultVersionClassifier.ClassifyAsync: lastRelease.currentPatch is not null, using it to determine version classification");
                 // If the current commit is tagged, we must use that version. Here we check if the version we have resolved from the
                 // previous commits is the same as the current version. If it is, we will use the increment value, otherwise we reset
                 // to zero. For example:
@@ -97,6 +125,10 @@ class DefaultVersionClassifier {
                 // - commit 4 - v2.0.1+0
                 const versionsMatch = lastRelease.currentMajor === major && lastRelease.currentMinor === minor && lastRelease.currentPatch === patch;
                 const currentIncrement = versionsMatch ? increment : 0;
+                core.info("VAGO DefaultVersionClassifier.ClassifyAsync: versionsMatch: " + versionsMatch + ", currentIncrement: " + currentIncrement);
+                core.info("VAGO DefaultVersionClassifier.ClassifyAsync: lastRelease.currentMajor: " + lastRelease.currentMajor);
+                core.info("VAGO DefaultVersionClassifier.ClassifyAsync: lastRelease.currentMinor: " + lastRelease.currentMinor);
+                core.info("VAGO DefaultVersionClassifier.ClassifyAsync: lastRelease.currentPatch: " + lastRelease.currentPatch);
                 return new VersionClassification_1.VersionClassification(VersionType_1.VersionType.None, currentIncrement, false, lastRelease.currentMajor, lastRelease.currentMinor, lastRelease.currentPatch);
             }
             return new VersionClassification_1.VersionClassification(type, increment, changed, major, minor, patch);

src/ActionConfig.ts

@@ -1,39 +1,39 @@
 /** Represents the input configuration for the semantic-version action */
 export class ActionConfig {
-    /** Set to specify a specific branch, default is the current HEAD */
+  /** Set to specify a specific branch, default is the current HEAD */
-    public branch: string = "HEAD";
+  public branch: string = "HEAD";
-    /** The prefix to use to identify tags */
+  /** The prefix to use to identify tags */
-    public tagPrefix: string = "v";
+  public tagPrefix: string = "v";
-    /** (Deprecated) Use branches instead of tags */
+  /** (Deprecated) Use branches instead of tags */
-    public useBranches: boolean = false;
+  public useBranches: boolean = false;
-    /** If true, the branch will be used to select the maximum version. */
+  /** If true, the branch will be used to select the maximum version. */
-    public versionFromBranch: string | boolean = false;
+  public versionFromBranch: string | boolean = false;
-    /** A string which, if present in a git commit, indicates that a change represents a major (breaking) change. Wrap with '/' to match using a regular expression. */
+  /** A string which, if present in a git commit, indicates that a change represents a major (breaking) change. Wrap with '/' to match using a regular expression. */
-    public majorPattern: string = "(MAJOR)";
+  public majorPattern: string = "(MAJOR)";
-    /** A string which indicates the flags used by the `majorPattern` regular expression. */
+  /** A string which indicates the flags used by the `majorPattern` regular expression. */
-    public majorFlags: string = "";
+  public majorFlags: string = "";
-    /** A string which, if present in a git commit, indicates that a change represents a minor (feature) change. Wrap with '/' to match using a regular expression. */
+  /** A string which, if present in a git commit, indicates that a change represents a minor (feature) change. Wrap with '/' to match using a regular expression. */
-    public minorPattern: string = "(MINOR)";
+  public minorPattern: string = "(MINOR)";
-    /** A string which indicates the flags used by the `minorPattern` regular expression. */
+  /** A string which indicates the flags used by the `minorPattern` regular expression. */
-    public minorFlags: string = "";
+  public minorFlags: string = "";
-    /** Pattern to use when formatting output version */
+  /** Pattern to use when formatting output version */
-    public versionFormat: string = '${major}.${minor}.${patch}';
+  public versionFormat: string = "${major}.${minor}.${patch}";
-    /** Path to check for changes. If any changes are detected in the path the 'changed' output will true. Enter multiple paths separated by spaces. */
+  /** Path to check for changes. If any changes are detected in the path the 'changed' output will true. Enter multiple paths separated by spaces. */
-    public changePath: string = '';
+  public changePath: string = "";
-    /** Use to create a named sub-version. This value will be appended to tags created for this version. */
+  /** Use to create a named sub-version. This value will be appended to tags created for this version. */
-    public namespace: string = "";
+  public namespace: string = "";
-    /** If true, every commit will be treated as a bump to the version. */
+  /** If true, every commit will be treated as a bump to the version. */
-    public bumpEachCommit: boolean = false;
+  public bumpEachCommit: boolean = false;
-    /** If true, the body of commits will also be searched for major/minor patterns to determine the version type */
+  /** If true, the body of commits will also be searched for major/minor patterns to determine the version type */
-    public searchCommitBody: boolean = false;
+  public searchCommitBody: boolean = false;
-    /** The output method used to generate list of users, 'csv' or 'json'. Default is 'csv'. */
+  /** The output method used to generate list of users, 'csv' or 'json'. Default is 'csv'. */
-    public userFormatType: string = "csv";
+  public userFormatType: string = "csv";
-    /** Prevents pre-v1.0.0 version from automatically incrementing the major version. If enabled, when the major version is 0, major releases will be treated as minor and minor as patch. Note that the versionType output is unchanged.  */
+  /** Prevents pre-v1.0.0 version from automatically incrementing the major version. If enabled, when the major version is 0, major releases will be treated as minor and minor as patch. Note that the versionType output is unchanged.  */
-    public enablePrereleaseMode: boolean = false;
+  public enablePrereleaseMode: boolean = false;
-    /** If bump_each_commit is also set to true, setting this value will cause the version to increment only if the pattern specified is matched. */
+  /** If bump_each_commit is also set to true, setting this value will cause the version to increment only if the pattern specified is matched. */
-    public bumpEachCommitPatchPattern: string = "";
+  public bumpEachCommitPatchPattern: string = "";
-    /** If enabled, diagnostic information will be added to the action output. */
+  /** If enabled, diagnostic information will be added to the action output. */
-    public debug: boolean = false;
+  public debug: boolean = false;
-    /** Diagnostics to replay */
+  /** Diagnostics to replay */
-    public replay: string = '';
+  public replay: string = "";
-}
+}

src/CommandRunner.ts

@@ -1,34 +1,38 @@
 // Using require instead of import to support integration testing
-import * as exec from '@actions/exec';
+import * as exec from "@actions/exec";
-import { DebugManager } from './DebugManager';
+import { DebugManager } from "./DebugManager";
 
 export const cmd = async (command: string, ...args: any): Promise<string> => {
+  const debugManager = DebugManager.getInstance();
 
-    const debugManager = DebugManager.getInstance();
+  if (debugManager.isReplayMode()) {
+    return debugManager.replayCommand(command, args);
+  }
 
-    if (debugManager.isReplayMode()) {
+  let output = "",
-        return debugManager.replayCommand(command, args);
+    errors = "";
-    }
+  const options = {
+    silent: true,
+    listeners: {
+      stdout: (data: any) => {
+        output += data.toString();
+      },
+      stderr: (data: any) => {
+        errors += data.toString();
+      },
+      ignoreReturnCode: true,
+      silent: true,
+    },
+  };
 
-    let output = '', errors = '';
+  let caughtError: any = null;
-    const options = {
+  try {
-        silent: true,
+    await exec.exec(command, args, options);
-        listeners: {
+  } catch (err) {
-            stdout: (data: any) => { output += data.toString(); },
+    caughtError = err;
-            stderr: (data: any) => { errors += data.toString(); },
+  }
-            ignoreReturnCode: true,
-            silent: true
-        }
-    };
 
-    let caughtError: any = null;
+  debugManager.recordCommand(command, args, output, errors, caughtError);
-    try {
-        await exec.exec(command, args, options);
-    } catch (err) {
-        caughtError = err;
-    }
 
-    debugManager.recordCommand(command, args, output, errors, caughtError);
+  return output;
-
+};
-    return output;
-};

src/ConfigurationProvider.ts

@@ -1,25 +1,24 @@
-import { CsvUserFormatter } from './formatting/CsvUserFormatter'
+import { CsvUserFormatter } from "./formatting/CsvUserFormatter";
-import { BranchVersioningTagFormatter } from './formatting/BranchVersioningTagFormatter'
+import { BranchVersioningTagFormatter } from "./formatting/BranchVersioningTagFormatter";
-import { DefaultTagFormatter } from './formatting/DefaultTagFormatter'
+import { DefaultTagFormatter } from "./formatting/DefaultTagFormatter";
-import { DefaultVersionFormatter } from './formatting/DefaultVersionFormatter'
+import { DefaultVersionFormatter } from "./formatting/DefaultVersionFormatter";
-import { JsonUserFormatter } from './formatting/JsonUserFormatter'
+import { JsonUserFormatter } from "./formatting/JsonUserFormatter";
-import { TagFormatter } from './formatting/TagFormatter'
+import { TagFormatter } from "./formatting/TagFormatter";
-import { UserFormatter } from './formatting/UserFormatter'
+import { UserFormatter } from "./formatting/UserFormatter";
-import { VersionFormatter } from './formatting/VersionFormatter'
+import { VersionFormatter } from "./formatting/VersionFormatter";
-import { CommitsProvider } from './providers/CommitsProvider'
+import { CommitsProvider } from "./providers/CommitsProvider";
-import { CurrentCommitResolver } from './providers/CurrentCommitResolver'
+import { CurrentCommitResolver } from "./providers/CurrentCommitResolver";
-import { DefaultCommitsProvider } from './providers/DefaultCommitsProvider'
+import { DefaultCommitsProvider } from "./providers/DefaultCommitsProvider";
-import { DefaultCurrentCommitResolver } from './providers/DefaultCurrentCommitResolver'
+import { DefaultCurrentCommitResolver } from "./providers/DefaultCurrentCommitResolver";
-import { DefaultVersionClassifier } from './providers/DefaultVersionClassifier'
+import { DefaultVersionClassifier } from "./providers/DefaultVersionClassifier";
-import { LastReleaseResolver } from './providers/LastReleaseResolver'
+import { LastReleaseResolver } from "./providers/LastReleaseResolver";
-import { DefaultLastReleaseResolver } from './providers/DefaultLastReleaseResolver'
+import { DefaultLastReleaseResolver } from "./providers/DefaultLastReleaseResolver";
-import { VersionClassifier } from './providers/VersionClassifier'
+import { VersionClassifier } from "./providers/VersionClassifier";
-import { BumpAlwaysVersionClassifier } from './providers/BumpAlwaysVersionClassifier'
+import { BumpAlwaysVersionClassifier } from "./providers/BumpAlwaysVersionClassifier";
-import { ActionConfig } from './ActionConfig';
+import { ActionConfig } from "./ActionConfig";
-import { DebugManager } from './DebugManager';
+import { DebugManager } from "./DebugManager";
 
 export class ConfigurationProvider {
-
   constructor(config: ActionConfig) {
     this.config = config;
     DebugManager.getInstance().initializeConfig(config);
@@ -27,11 +26,17 @@ export class ConfigurationProvider {
 
   private config: ActionConfig;
 
-  public GetCurrentCommitResolver(): CurrentCommitResolver { return new DefaultCurrentCommitResolver(this.config); }
+  public GetCurrentCommitResolver(): CurrentCommitResolver {
+    return new DefaultCurrentCommitResolver(this.config);
+  }
 
-  public GetLastReleaseResolver(): LastReleaseResolver { return new DefaultLastReleaseResolver(this.config); }
+  public GetLastReleaseResolver(): LastReleaseResolver {
+    return new DefaultLastReleaseResolver(this.config);
+  }
 
-  public GetCommitsProvider(): CommitsProvider { return new DefaultCommitsProvider(this.config); }
+  public GetCommitsProvider(): CommitsProvider {
+    return new DefaultCommitsProvider(this.config);
+  }
 
   public GetVersionClassifier(): VersionClassifier {
     if (this.config.bumpEachCommit) {
@@ -40,7 +45,9 @@ export class ConfigurationProvider {
     return new DefaultVersionClassifier(this.config);
   }
 
-  public GetVersionFormatter(): VersionFormatter { return new DefaultVersionFormatter(this.config); }
+  public GetVersionFormatter(): VersionFormatter {
+    return new DefaultVersionFormatter(this.config);
+  }
 
   public GetTagFormatter(branchName: string): TagFormatter {
     if (this.config.versionFromBranch) {
@@ -51,10 +58,14 @@ export class ConfigurationProvider {
 
   public GetUserFormatter(): UserFormatter {
     switch (this.config.userFormatType) {
-      case 'json': return new JsonUserFormatter(this.config);
+      case "json":
-      case 'csv': return new CsvUserFormatter(this.config);
+        return new JsonUserFormatter(this.config);
+      case "csv":
+        return new CsvUserFormatter(this.config);
       default:
-        throw new Error(`Unknown user format type: ${this.config.userFormatType}, supported types: json, csv`);
+        throw new Error(
+          `Unknown user format type: ${this.config.userFormatType}, supported types: json, csv`,
+        );
     }
   }
 }

src/DebugManager.ts

@@ -1,115 +1,134 @@
 import { ActionConfig } from "./ActionConfig";
 
-
 /** Utility class for managing debug mode and diagnostic information */
 export class DebugManager {
-    private constructor() { }
+  private constructor() {}
 
-    private static instance: DebugManager;
+  private static instance: DebugManager;
-    /** Returns the singleton instance of the DebugManager */
+  /** Returns the singleton instance of the DebugManager */
-    public static getInstance(): DebugManager {
+  public static getInstance(): DebugManager {
-        if (!DebugManager.instance) {
+    if (!DebugManager.instance) {
-            DebugManager.instance = new DebugManager();
+      DebugManager.instance = new DebugManager();
-        }
+    }
-        return DebugManager.instance;
+    return DebugManager.instance;
+  }
+
+  /** Clears the singleton instance of the DebugManager (used for testing) */
+  public static clearState() {
+    DebugManager.instance = new DebugManager();
+  }
+
+  private debugEnabled: boolean = false;
+  private replayMode: boolean = false;
+  private diagnosticInfo: DiagnosticInfo | null = null;
+
+  /** Returns true if debug mode is enabled */
+  public isDebugEnabled(): boolean {
+    return this.debugEnabled;
+  }
+
+  /** Returns true if replay mode is enabled */
+  public isReplayMode(): boolean {
+    return this.replayMode;
+  }
+
+  initializeConfig(config: ActionConfig) {
+    if (config.debug) {
+      this.setDebugEnabled(true);
+    } else if (config.replay.length > 0) {
+      this.replayFromDiagnostics(config.replay);
+    }
+  }
+
+  /** Enables or disables debug mode, also clears any existing diagnostics info */
+  public setDebugEnabled(enableDebug: boolean = true): void {
+    this.debugEnabled = enableDebug;
+    this.replayMode = false;
+    this.diagnosticInfo = new DiagnosticInfo();
+  }
+
+  /** Enables replay mode and loads the diagnostic information from the specified string */
+  public replayFromDiagnostics(diagnostics: string): void {
+    this.debugEnabled = false;
+    this.replayMode = true;
+    this.diagnosticInfo = JSON.parse(diagnostics);
+  }
+
+  /** Returns a JSON string containing the diagnostic information for this run */
+  public getDebugOutput(emptyRepo: boolean = false): string {
+    return this.isDebugEnabled() ? JSON.stringify(this.diagnosticInfo) : "";
+  }
+
+  /** Records a command and its output for diagnostic purposes */
+  public recordCommand(
+    command: string,
+    args: any[],
+    output: string,
+    stderr: string,
+    error: any,
+  ): void {
+    if (this.isDebugEnabled()) {
+      this.diagnosticInfo?.recordCommand(command, args, output, stderr, error);
+    }
+  }
+
+  /** Replays the specified command and returns the output */
+  public replayCommand(command: string, args: any[]): string {
+    if (this.diagnosticInfo === null) {
+      throw new Error("No diagnostic information available for replay");
     }
 
-    /** Clears the singleton instance of the DebugManager (used for testing) */
+    const commandResult = this.diagnosticInfo.commands.find(
-    public static clearState() {
+      (c) =>
-        DebugManager.instance = new DebugManager();
+        c.command === command &&
+        JSON.stringify(c.args) === JSON.stringify(args),
+    );
+    if (!commandResult) {
+      throw new Error(`No result found in diagnostic for command "${command}"`);
     }
-
+    if (commandResult.error) {
-
+      throw commandResult.error;
-    private debugEnabled: boolean = false;
-    private replayMode: boolean = false;
-    private diagnosticInfo: DiagnosticInfo | null = null;
-
-    /** Returns true if debug mode is enabled */
-    public isDebugEnabled(): boolean {
-        return this.debugEnabled;
     }
-
+    if (commandResult.stderr) {
-    /** Returns true if replay mode is enabled */
+      console.error(commandResult.stderr);
-    public isReplayMode(): boolean {
-        return this.replayMode;
-    }
-
-    initializeConfig(config: ActionConfig) {
-        if (config.debug) {
-            this.setDebugEnabled(true);
-        } else if (config.replay.length > 0) {
-            this.replayFromDiagnostics(config.replay);
-        }
-    }
-
-
-    /** Enables or disables debug mode, also clears any existing diagnostics info */
-    public setDebugEnabled(enableDebug: boolean = true): void {
-        this.debugEnabled = enableDebug;
-        this.replayMode = false;
-        this.diagnosticInfo = new DiagnosticInfo();
-    };
-
-    /** Enables replay mode and loads the diagnostic information from the specified string */
-    public replayFromDiagnostics(diagnostics: string): void {
-        this.debugEnabled = false
-        this.replayMode = true;
-        this.diagnosticInfo = JSON.parse(diagnostics);
-    }
-
-    /** Returns a JSON string containing the diagnostic information for this run */
-    public getDebugOutput(emptyRepo: boolean = false): string {
-        return this.isDebugEnabled() ? JSON.stringify(this.diagnosticInfo) : '';
-    }
-
-    /** Records a command and its output for diagnostic purposes */
-    public recordCommand(command: string, args: any[], output: string, stderr: string, error: any): void {
-        if (this.isDebugEnabled()) {
-            this.diagnosticInfo?.recordCommand(command, args, output, stderr, error);
-        }
-    }
-
-    /** Replays the specified command and returns the output */
-    public replayCommand(command: string, args: any[]): string {
-        if (this.diagnosticInfo === null) {
-            throw new Error('No diagnostic information available for replay');
-        }
-
-        const commandResult = this.diagnosticInfo.commands.find(c => c.command === command && JSON.stringify(c.args) === JSON.stringify(args));
-        if (!commandResult) {
-            throw new Error(`No result found in diagnostic for command "${command}"`);
-        }
-        if (commandResult.error) {
-            throw commandResult.error;
-        }
-        if (commandResult.stderr) {
-            console.error(commandResult.stderr);
-        }
-        return commandResult.output;
     }
+    return commandResult.output;
+  }
 }
 
 /** Represents a CLI command result */
 class CommandResult {
-    public command: string;
+  public command: string;
-    public args: any[];
+  public args: any[];
-    public output: string;
+  public output: string;
-    public stderr: string;
+  public stderr: string;
-    public error: any;
+  public error: any;
-    public constructor(command: string, args: any[], output: string, stderr: string, error: any) {
+  public constructor(
-        this.command = command;
+    command: string,
-        this.args = args;
+    args: any[],
-        this.output = output;
+    output: string,
-        this.stderr = stderr;
+    stderr: string,
-        this.error = error;
+    error: any,
-    }
+  ) {
+    this.command = command;
+    this.args = args;
+    this.output = output;
+    this.stderr = stderr;
+    this.error = error;
+  }
 }
 
 /** Represents the result of the commands executed for a run */
 class DiagnosticInfo {
-    public commands: CommandResult[] = [];
+  public commands: CommandResult[] = [];
-    public empty: boolean = false;
+  public empty: boolean = false;
-    public recordCommand(command: string, args: any[], output: string, stderr: string, error: any): void {
+  public recordCommand(
-        this.commands.push(new CommandResult(command, args, output, stderr, error));
+    command: string,
-    }
+    args: any[],
-}
+    output: string,
+    stderr: string,
+    error: any,
+  ): void {
+    this.commands.push(new CommandResult(command, args, output, stderr, error));
+  }
+}

src/VersionResult.ts

@@ -15,7 +15,7 @@ export class VersionResult {
    * @param changed - True if the version was changed, otherwise false
    * @param isTagged - True if the commit had a tag that matched the `versionTag` format
    * @param authors - Authors formatted according to the format mode (e.g. JSON, CSV, YAML, etc.)
-   * @param currentCommit - The current commit hash 
+   * @param currentCommit - The current commit hash
    * @param previousCommit - The previous commit hash
    * @param previousVersion - The previous version
    * @param debugOutput - Diagnostic information, if debug is enabled
@@ -34,5 +34,6 @@ export class VersionResult {
     public currentCommit: string,
     public previousCommit: string,
     public previousVersion: string,
-    public debugOutput: string) { }
+    public debugOutput: string,
+  ) {}
 }

src/action.ts

@@ -1,27 +1,39 @@
-import { ConfigurationProvider } from './ConfigurationProvider';
+import { ConfigurationProvider } from "./ConfigurationProvider";
-import { VersionResult } from './VersionResult';
+import { VersionResult } from "./VersionResult";
-import { VersionType } from './providers/VersionType';
+import { VersionType } from "./providers/VersionType";
-import { UserInfo } from './providers/UserInfo';
+import { UserInfo } from "./providers/UserInfo";
-import { VersionInformation } from './providers/VersionInformation';
+import { VersionInformation } from "./providers/VersionInformation";
-import { DebugManager } from './DebugManager';
+import { DebugManager } from "./DebugManager";
-import * as core from '@actions/core';
+import * as core from "@actions/core";
-export async function runAction(configurationProvider: ConfigurationProvider): Promise<VersionResult> {
+export async function runAction(
-
+  configurationProvider: ConfigurationProvider,
+): Promise<VersionResult> {
   core.info("VAGO STARTING runAction");
-  const currentCommitResolver = configurationProvider.GetCurrentCommitResolver();
+  const currentCommitResolver =
+    configurationProvider.GetCurrentCommitResolver();
   const lastReleaseResolver = configurationProvider.GetLastReleaseResolver();
   const commitsProvider = configurationProvider.GetCommitsProvider();
   const versionClassifier = configurationProvider.GetVersionClassifier();
   const versionFormatter = configurationProvider.GetVersionFormatter();
-  const tagFormatter = configurationProvider.GetTagFormatter(await currentCommitResolver.ResolveBranchNameAsync());
+  const tagFormatter = configurationProvider.GetTagFormatter(
+    await currentCommitResolver.ResolveBranchNameAsync(),
+  );
   const userFormatter = configurationProvider.GetUserFormatter();
 
   const debugManager = DebugManager.getInstance();
 
   if (await currentCommitResolver.IsEmptyRepoAsync()) {
-
     core.info("VAGO REPO WAS EMPTY, returning default version information");
-    const versionInfo = new VersionInformation(0, 0, 0, 0, VersionType.None, [], false, false);
+    const versionInfo = new VersionInformation(
+      0,
+      0,
+      0,
+      0,
+      VersionType.None,
+      [],
+      false,
+      false,
+    );
     return new VersionResult(
       versionInfo.major,
       versionInfo.minor,
@@ -32,23 +44,41 @@ export async function runAction(configurationProvider: ConfigurationProvider): P
       tagFormatter.Format(versionInfo),
       versionInfo.changed,
       versionInfo.isTagged,
-      userFormatter.Format('author', []),
+      userFormatter.Format("author", []),
-      '',
+      "",
-      '',
+      "",
-      tagFormatter.Parse(tagFormatter.Format(versionInfo)).join('.'),
+      tagFormatter.Parse(tagFormatter.Format(versionInfo)).join("."),
-      debugManager.getDebugOutput(true)
+      debugManager.getDebugOutput(true),
     );
   }
 
   core.info("VAGO REPO IS NOT EMPTY, continuing with versioning");
   const currentCommit = await currentCommitResolver.ResolveAsync();
   core.info("VAGO CURRENT COMMIT: " + currentCommit);
-  const lastRelease = await lastReleaseResolver.ResolveAsync(currentCommit, tagFormatter);
+  const lastRelease = await lastReleaseResolver.ResolveAsync(
-  core.info("VAGO LAST RELEASE: " + lastRelease.hash + " " + lastRelease.major + "." + lastRelease.minor + "." + lastRelease.patch);
+    currentCommit,
-  const commitSet = await commitsProvider.GetCommitsAsync(lastRelease.hash, currentCommit);
+    tagFormatter,
-  core.info("VAGO commit set le:" + commitSet.commits.length)
+  );
+  core.info(
+    "VAGO LAST RELEASE: " +
+      lastRelease.hash +
+      " " +
+      lastRelease.major +
+      "." +
+      lastRelease.minor +
+      "." +
+      lastRelease.patch,
+  );
+  const commitSet = await commitsProvider.GetCommitsAsync(
+    lastRelease.hash,
+    currentCommit,
+  );
+  core.info("VAGO commit set le:" + commitSet.commits.length);
   core.info("VAGO commit set changed: " + commitSet.changed.toString());
-  const classification = await versionClassifier.ClassifyAsync(lastRelease, commitSet);
+  const classification = await versionClassifier.ClassifyAsync(
+    lastRelease,
+    commitSet,
+  );
   core.info("VAGO classification: " + JSON.stringify(classification));
 
   const { isTagged } = lastRelease;
@@ -56,16 +86,24 @@ export async function runAction(configurationProvider: ConfigurationProvider): P
 
   // At this point all necessary data has been pulled from the database, create
   // version information to be used by the formatters
-  let versionInfo = new VersionInformation(major, minor, patch, increment, type, commitSet.commits, changed, isTagged);
+  let versionInfo = new VersionInformation(
+    major,
+    minor,
+    patch,
+    increment,
+    type,
+    commitSet.commits,
+    changed,
+    isTagged,
+  );
 
   // Group all the authors together, count the number of commits per author
-  const allAuthors = versionInfo.commits
+  const allAuthors = versionInfo.commits.reduce((acc: any, commit) => {
-    .reduce((acc: any, commit) => {
+    const key = `${commit.author} <${commit.authorEmail}>`;
-      const key = `${commit.author} <${commit.authorEmail}>`;
+    acc[key] = acc[key] || { n: commit.author, e: commit.authorEmail, c: 0 };
-      acc[key] = acc[key] || { n: commit.author, e: commit.authorEmail, c: 0 };
+    acc[key].c++;
-      acc[key].c++;
+    return acc;
-      return acc;
+  }, {});
-    }, {});
 
   const authors = Object.values(allAuthors)
     .map((u: any) => new UserInfo(u.n, u.e, u.c))
@@ -81,10 +119,10 @@ export async function runAction(configurationProvider: ConfigurationProvider): P
     tagFormatter.Format(versionInfo),
     versionInfo.changed,
     versionInfo.isTagged,
-    userFormatter.Format('author', authors),
+    userFormatter.Format("author", authors),
     currentCommit,
     lastRelease.hash,
     `${lastRelease.major}.${lastRelease.minor}.${lastRelease.patch}`,
-    debugManager.getDebugOutput()
+    debugManager.getDebugOutput(),
   );
 }

src/main.ts

@@ -1,23 +1,40 @@
-import { runAction } from './action';
+import { runAction } from "./action";
-import { ActionConfig } from './ActionConfig';
+import { ActionConfig } from "./ActionConfig";
-import { ConfigurationProvider } from './ConfigurationProvider';
+import { ConfigurationProvider } from "./ConfigurationProvider";
-import { VersionResult } from './VersionResult';
+import { VersionResult } from "./VersionResult";
-import * as core from '@actions/core';
+import * as core from "@actions/core";
-import { VersionType } from './providers/VersionType';
+import { VersionType } from "./providers/VersionType";
 
 function setOutput(versionResult: VersionResult) {
-  const { major, minor, patch, increment, versionType, formattedVersion, versionTag, changed, isTagged, authors, currentCommit, previousCommit, previousVersion, debugOutput } = versionResult;
+  const {
+    major,
+    minor,
+    patch,
+    increment,
+    versionType,
+    formattedVersion,
+    versionTag,
+    changed,
+    isTagged,
+    authors,
+    currentCommit,
+    previousCommit,
+    previousVersion,
+    debugOutput,
+  } = versionResult;
 
   const repository = process.env.GITHUB_REPOSITORY;
 
   if (!changed) {
-    core.info("VAGOOO1")
+    core.info("VAGOOO1");
-    core.info('No changes detected for this commit');
+    core.info("No changes detected for this commit");
   }
 
   core.info(`Version is ${formattedVersion}`);
   if (repository !== undefined) {
-    core.info(`To create a release for this version, go to https://github.com/${repository}/releases/new?tag=${versionTag}&target=${currentCommit.split('/').slice(-1)[0]}`);
+    core.info(
+      `To create a release for this version, go to https://github.com/${repository}/releases/new?tag=${versionTag}&target=${currentCommit.split("/").slice(-1)[0]}`,
+    );
   }
 
   core.setOutput("version", formattedVersion);
@@ -37,57 +54,60 @@ function setOutput(versionResult: VersionResult) {
 }
 
 export async function run() {
-
   core.info("VAGO Starting run action...");
   function toBool(value: string): boolean {
-    if (!value || value.toLowerCase() === 'false') {
+    if (!value || value.toLowerCase() === "false") {
       return false;
-    } else if (value.toLowerCase() === 'true') {
+    } else if (value.toLowerCase() === "true") {
       return true;
     }
     return false;
   }
-  
+
   function toStringOrBool(value: string): string | boolean {
-    if (!value || value === 'false') {
+    if (!value || value === "false") {
       return false;
     }
-    if (value === 'true') {
+    if (value === "true") {
       return true;
     }
     return value;
-  }  
+  }
 
   const config: ActionConfig = {
-    branch: core.getInput('branch'),
+    branch: core.getInput("branch"),
-    tagPrefix: core.getInput('tag_prefix'),
+    tagPrefix: core.getInput("tag_prefix"),
-    useBranches: toBool(core.getInput('use_branches')),
+    useBranches: toBool(core.getInput("use_branches")),
-    versionFromBranch: toStringOrBool(core.getInput('version_from_branch')),
+    versionFromBranch: toStringOrBool(core.getInput("version_from_branch")),
-    majorPattern: core.getInput('major_pattern'),
+    majorPattern: core.getInput("major_pattern"),
-    minorPattern: core.getInput('minor_pattern'),
+    minorPattern: core.getInput("minor_pattern"),
-    majorFlags: core.getInput('major_regexp_flags'),
+    majorFlags: core.getInput("major_regexp_flags"),
-    minorFlags: core.getInput('minor_regexp_flags'),
+    minorFlags: core.getInput("minor_regexp_flags"),
-    versionFormat: core.getInput('version_format'),
+    versionFormat: core.getInput("version_format"),
-    changePath: core.getInput('change_path'),
+    changePath: core.getInput("change_path"),
-    namespace: core.getInput('namespace'),
+    namespace: core.getInput("namespace"),
-    bumpEachCommit: toBool(core.getInput('bump_each_commit')),
+    bumpEachCommit: toBool(core.getInput("bump_each_commit")),
-    searchCommitBody: toBool(core.getInput('search_commit_body')),
+    searchCommitBody: toBool(core.getInput("search_commit_body")),
-    userFormatType: core.getInput('user_format_type'),
+    userFormatType: core.getInput("user_format_type"),
-    enablePrereleaseMode: toBool(core.getInput('enable_prerelease_mode')),
+    enablePrereleaseMode: toBool(core.getInput("enable_prerelease_mode")),
-    bumpEachCommitPatchPattern: core.getInput('bump_each_commit_patch_pattern'),
+    bumpEachCommitPatchPattern: core.getInput("bump_each_commit_patch_pattern"),
-    debug: toBool(core.getInput('debug')),
+    debug: toBool(core.getInput("debug")),
-    replay: ''
+    replay: "",
   };
 
   if (config.useBranches) {
-    core.warning(`The 'use_branches' input option is deprecated, please see the documentation for more information on how to use branches`);
+    core.warning(
+      `The 'use_branches' input option is deprecated, please see the documentation for more information on how to use branches`,
+    );
   }
 
-  if (config.versionFormat === '' && core.getInput('format') !== '') {
+  if (config.versionFormat === "" && core.getInput("format") !== "") {
-    core.warning(`The 'format' input is deprecated, use 'versionFormat' instead`);
+    core.warning(
-    config.versionFormat = core.getInput('format');
+      `The 'format' input is deprecated, use 'versionFormat' instead`,
+    );
+    config.versionFormat = core.getInput("format");
   }
-  if (core.getInput('short_tags') !== '') {
+  if (core.getInput("short_tags") !== "") {
     core.warning(`The 'short_tags' input option is no longer supported`);
   }
 
@@ -98,4 +118,4 @@ export async function run() {
   setOutput(result);
 }
 
-run();
+run();