fork-version 1.8.0 → 2.0.2

package/dist/{chunk-RLGF46N7.js → chunk-D2PQT6ZM.js}

@@ -1,16 +1,15 @@
 import { z } from 'zod';
-import { resolve, parse } from 'node:path';
+import { execFile } from 'child_process';
+import semver from 'semver';
+import { resolve, parse } from 'path';
 import { glob } from 'glob';
 import conventionalChangelogConfigSpec from 'conventional-changelog-config-spec';
-import { execFile } from 'node:child_process';
-import { writeFileSync, readFileSync, lstatSync } from 'node:fs';
+import { writeFileSync, readFileSync, lstatSync } from 'fs';
 import JoyCon from 'joycon';
 import { bundleRequire } from 'bundle-require';
 import { modify, applyEdits, parse as parse$1 } from 'jsonc-parser';
 import { parse as parse$2, parseDocument } from 'yaml';
 import * as cheerio from 'cheerio/slim';
-import semver from 'semver';
-import conventionalRecommendedBump from 'conventional-recommended-bump';
 import conventionalChangelog from 'conventional-changelog';
 
 // src/config/schema.js
@@ -267,6 +266,303 @@ var ForkConfigSchema = z.object({
    */
   releaseMessageSuffix: z.string().optional().describe("Add a suffix to the release commit message.")
 });
+var Git = class {
+  constructor(config) {
+    this.config = config;
+    this.add = this.add.bind(this);
+    this.commit = this.commit.bind(this);
+    this.tag = this.tag.bind(this);
+    this.log = this.log.bind(this);
+    this.isIgnored = this.isIgnored.bind(this);
+    this.getBranchName = this.getBranchName.bind(this);
+    this.getRemoteUrl = this.getRemoteUrl.bind(this);
+    this.getTags = this.getTags.bind(this);
+    this.getMostRecentTag = this.getMostRecentTag.bind(this);
+    this.getCleanedTags = this.getCleanedTags.bind(this);
+    this.getHighestSemverVersionFromTags = this.getHighestSemverVersionFromTags.bind(this);
+    this.getCommits = this.getCommits.bind(this);
+  }
+  async #execGit(command, args) {
+    return new Promise((onResolve, onReject) => {
+      execFile(
+        "git",
+        [command, ...args],
+        {
+          cwd: this.config.path,
+          maxBuffer: Infinity
+        },
+        (error, stdout, stderr) => {
+          if (error) {
+            onReject(error);
+          } else {
+            onResolve(stdout ? stdout : stderr);
+          }
+        }
+      );
+    });
+  }
+  /**
+   * Add file contents to the index
+   *
+   * [git-add Documentation](https://git-scm.com/docs/git-add)
+   *
+   * @example
+   * ```ts
+   * await git.add("CHANGELOG.md");
+   * ```
+   */
+  async add(...args) {
+    if (this.config.dryRun) {
+      return "";
+    }
+    return this.#execGit("add", args.filter(Boolean));
+  }
+  /**
+   * Record changes to the repository
+   *
+   * [git-commit Documentation](https://git-scm.com/docs/git-commit)
+   *
+   * @example
+   * ```ts
+   * await git.commit("--message", "chore(release): 1.2.3");
+   * ```
+   */
+  async commit(...args) {
+    if (this.config.dryRun) {
+      return "";
+    }
+    return this.#execGit("commit", args.filter(Boolean));
+  }
+  /**
+   * Create, list, delete or verify a tag object
+   *
+   * [git-tag Documentation](https://git-scm.com/docs/git-tag)
+   *
+   * @example
+   * ```ts
+   * await git.tag("--annotate", "v1.2.3", "--message", "chore(release): 1.2.3");
+   * ```
+   */
+  async tag(...args) {
+    if (this.config.dryRun) {
+      return "";
+    }
+    return this.#execGit("tag", args.filter(Boolean));
+  }
+  /**
+   * Show commit logs
+   *
+   * - [git-log Documentation](https://git-scm.com/docs/git-log)
+   * - [pretty-formats Documentation](https://git-scm.com/docs/pretty-formats)
+   *
+   * @example
+   * ```ts
+   * await git.log("--oneline");
+   * ```
+   */
+  async log(...args) {
+    try {
+      return await this.#execGit("log", args.filter(Boolean));
+    } catch {
+      return "";
+    }
+  }
+  /**
+   * Check if a file is ignored by git
+   *
+   * [git-check-ignore Documentation](https://git-scm.com/docs/git-check-ignore)
+   *
+   * @example
+   * ```ts
+   * await git.isIgnored("src/my-file.txt");
+   * ```
+   */
+  async isIgnored(file) {
+    try {
+      await this.#execGit("check-ignore", ["--no-index", file]);
+      return true;
+    } catch (_error) {
+      return false;
+    }
+  }
+  /**
+   * Get the name of the current branch
+   *
+   * [git-rev-parse Documentation](https://git-scm.com/docs/git-rev-parse)
+   *
+   * @example
+   * ```ts
+   * await git.getBranchName(); // "main"
+   * ```
+   */
+  async getBranchName() {
+    try {
+      const branchName = await this.#execGit("rev-parse", ["--abbrev-ref", "HEAD"]);
+      return branchName.trim();
+    } catch {
+      return "";
+    }
+  }
+  /**
+   * Get the URL of the remote repository
+   *
+   * [git-config Documentation](https://git-scm.com/docs/git-config)
+   *
+   * @example
+   * ```ts
+   * await git.getRemoteUrl(); // "https://github.com/eglavin/fork-version"
+   * ```
+   */
+  async getRemoteUrl() {
+    try {
+      const remoteUrl = await this.#execGit("config", ["--get", "remote.origin.url"]);
+      return remoteUrl.trim();
+    } catch (_error) {
+      return "";
+    }
+  }
+  /**
+   * `getTags` returns valid semver version tags in order of the commit history
+   *
+   * Using `git log` to get the commit history, we then parse the tags from the
+   * commit details which is expected to be in the following format:
+   * ```txt
+   * commit 3841b1d05750d42197fe958e3d8e06df378a842d (HEAD -> main, tag: v1.0.2, tag: v1.0.1, tag: v1.0.0)
+   * Author: Username <username@example.com>
+   * Date:   Sat Nov 9 15:00:00 2024 +0000
+   *
+   *     chore(release): v1.0.0
+   * ```
+   *
+   * - [Functionality extracted from the conventional-changelog - git-semver-tags project](https://github.com/conventional-changelog/conventional-changelog/blob/fac8045242099c016f5f3905e54e02b7d466bd7b/packages/git-semver-tags/index.js)
+   * - [conventional-changelog git-semver-tags MIT Licence](https://github.com/conventional-changelog/conventional-changelog/blob/fac8045242099c016f5f3905e54e02b7d466bd7b/packages/git-semver-tags/LICENSE.md)
+   *
+   * @example
+   * ```ts
+   * await git.getTags("v"); // ["v1.0.2", "v1.0.1", "v1.0.0"]
+   * ```
+   */
+  async getTags(tagPrefix) {
+    const logOutput = await this.log("--decorate", "--no-color", "--date-order");
+    const TAG_REGEX = /tag:\s*(?<tag>.+?)[,)]/gi;
+    const tags = [];
+    let tagMatch = null;
+    while (tagMatch = TAG_REGEX.exec(logOutput)) {
+      const { tag = "" } = tagMatch.groups ?? {};
+      if (tagPrefix) {
+        if (tag.startsWith(tagPrefix)) {
+          const tagWithoutPrefix = tag.replace(new RegExp(`^${tagPrefix}`), "");
+          if (semver.valid(tagWithoutPrefix)) {
+            tags.push(tag);
+          }
+        }
+      } else if (/^\d/.test(tag) && semver.valid(tag)) {
+        tags.push(tag);
+      }
+    }
+    return tags;
+  }
+  /**
+   * Returns the latest git tag based on commit date
+   *
+   * @example
+   * ```ts
+   * await git.getMostRecentTag("v"); // "1.2.3"
+   * ```
+   */
+  async getMostRecentTag(tagPrefix) {
+    const tags = await this.getTags(tagPrefix);
+    return tags[0] || void 0;
+  }
+  /**
+   * Get cleaned semver tags, with any tag prefix's removed
+   *
+   * @example
+   * ```ts
+   * await git.getCleanedTags("v"); // ["1.2.3", "1.2.2", "1.2.1"]
+   * ```
+   */
+  async getCleanedTags(tagPrefix) {
+    const tags = await this.getTags(tagPrefix);
+    const cleanedTags = [];
+    for (const tag of tags) {
+      const tagWithoutPrefix = tag.replace(new RegExp(`^${tagPrefix}`), "");
+      const cleanedTag = semver.clean(tagWithoutPrefix);
+      if (cleanedTag) {
+        cleanedTags.push(cleanedTag);
+      }
+    }
+    return cleanedTags;
+  }
+  /**
+   * Get the highest semver version from git tags. This will return the highest
+   * semver version found for the given tag prefix, regardless of the commit date.
+   *
+   * @example
+   * ```ts
+   * await git.getHighestSemverVersionFromTags("v"); // "1.2.3"
+   * ```
+   */
+  async getHighestSemverVersionFromTags(tagPrefix) {
+    const cleanedTags = await this.getCleanedTags(tagPrefix);
+    return cleanedTags.sort(semver.rcompare)[0] || void 0;
+  }
+  /**
+   * Get commit history in a parsable format
+   *
+   * An array of strings with commit details is returned in the following format:
+   * ```txt
+   * subject
+   * body
+   * hash
+   * committer date
+   * committer name
+   * committer email
+   * ```
+   *
+   * @example
+   * ```ts
+   * await git.getCommits("v1.0.0", "HEAD", "src/utils");
+   * ```
+   */
+  async getCommits(from = "", to = "HEAD", ...paths) {
+    const SCISSOR = "^----------- FORK VERSION -----------^";
+    const LOG_FORMAT = [
+      "%s",
+      // subject
+      "%b",
+      // body
+      "%H",
+      // hash
+      "%cI",
+      // committer date
+      "%cN",
+      // committer name
+      "%cE",
+      // committer email
+      SCISSOR
+    ].join("%n");
+    const commits = await this.log(
+      `--format=${LOG_FORMAT}`,
+      [from, to].filter(Boolean).join(".."),
+      paths.length ? "--" : "",
+      ...paths
+    );
+    const splitCommits = commits.split(`
+${SCISSOR}
+`);
+    if (splitCommits.length === 0) {
+      return splitCommits;
+    }
+    if (splitCommits[0] === SCISSOR) {
+      splitCommits.shift();
+    }
+    if (splitCommits[splitCommits.length - 1] === "") {
+      splitCommits.pop();
+    }
+    return splitCommits;
+  }
+};
 function getChangelogPresetConfig(mergedConfig, cliArguments, detectedGitHost) {
   const preset = {
     name: "conventionalcommits"
@@ -370,12 +666,13 @@ All notable changes to this project will be documented in this file. See [fork-v
   skipTag: false,
   changelogPresetConfig: {}
 };
+
+// src/config/detect-git-host.ts
 async function detectGitHost(cwd) {
-  const remoteUrl = await new Promise((onResolve) => {
-    execFile("git", ["config", "--get", "remote.origin.url"], { cwd }, (_error, stdout) => {
-      onResolve(stdout ? stdout.trim() : "");
-    });
-  });
+  const remoteUrl = await new Git({
+    path: cwd,
+    dryRun: false
+  }).getRemoteUrl();
   if (remoteUrl.startsWith("https://") && remoteUrl.includes("@dev.azure.com/")) {
     const match = /^https:\/\/(?<atorganisation>.*?)@dev.azure.com\/(?<organisation>.*?)\/(?<project>.*?)\/_git\/(?<repository>.*?)(?:\.git)?$/.exec(
       remoteUrl
@@ -844,131 +1141,481 @@ var FileManager = class {
     this.logger.error(`[File Manager] Unsupported file: ${fileState.path}`);
   }
 };
-var Git = class {
-  constructor(config) {
-    this.config = config;
-    this.add = this.add.bind(this);
-    this.commit = this.commit.bind(this);
-    this.tag = this.tag.bind(this);
-    this.isIgnored = this.isIgnored.bind(this);
-    this.getCurrentBranchName = this.getCurrentBranchName.bind(this);
-    this.getTags = this.getTags.bind(this);
-    this.getLatestTag = this.getLatestTag.bind(this);
+
+// src/utils/trim-string-array.ts
+function trimStringArray(array) {
+  const items = [];
+  if (Array.isArray(array)) {
+    for (const item of array) {
+      const _item = item.trim();
+      if (_item) {
+        items.push(_item);
+      }
+    }
   }
-  async execGit(command, args) {
-    return new Promise((onResolve, onReject) => {
-      execFile(
-        "git",
-        [command, ...args],
-        {
-          cwd: this.config.path,
-          maxBuffer: Infinity
-        },
-        (error, stdout, stderr) => {
-          if (error) {
-            onReject(error);
-          } else {
-            onResolve(stdout ? stdout : stderr);
-          }
-        }
-      );
-    });
+  if (items.length === 0) {
+    return void 0;
+  }
+  return items;
+}
+
+// src/commit-parser/options.ts
+function createParserOptions(userOptions) {
+  const referenceActions = trimStringArray(userOptions?.referenceActions) ?? [
+    "close",
+    "closes",
+    "closed",
+    "fix",
+    "fixes",
+    "fixed",
+    "resolve",
+    "resolves",
+    "resolved"
+  ];
+  const joinedReferenceActions = referenceActions.join("|");
+  const issuePrefixes = trimStringArray(userOptions?.issuePrefixes) ?? ["#"];
+  const joinedIssuePrefixes = issuePrefixes.join("|");
+  const noteKeywords = trimStringArray(userOptions?.noteKeywords) ?? [
+    "BREAKING CHANGE",
+    "BREAKING-CHANGE"
+  ];
+  const joinedNoteKeywords = noteKeywords.join("|");
+  return {
+    subjectPattern: /^(?<type>\w+)(?:\((?<scope>.*)\))?(?<breakingChange>!)?:\s+(?<title>.*)/,
+    mergePattern: /^Merge pull request #(?<id>\d*) from (?<source>.*)/,
+    revertPattern: /^[Rr]evert "(?<subject>.*)"(\s*This reverts commit (?<hash>[a-zA-Z0-9]*)\.)?/,
+    commentPattern: /^#(?!\d+\s)/,
+    mentionPattern: /(?<!\w)@(?<username>[\w-]+)/,
+    referenceActions,
+    referenceActionPattern: joinedReferenceActions ? new RegExp(
+      `(?<action>${joinedReferenceActions})(?:\\s+(?<reference>.*?))(?=(?:${joinedReferenceActions})|$)`
+    ) : void 0,
+    issuePrefixes,
+    issuePattern: joinedIssuePrefixes ? new RegExp(
+      `(?:.*?)??\\s*(?<repository>[\\w-\\.\\/]*?)??(?<prefix>${joinedIssuePrefixes})(?<issue>[\\w-]*\\d+)`
+    ) : void 0,
+    noteKeywords,
+    notePattern: joinedNoteKeywords ? new RegExp(`^(?<title>${joinedNoteKeywords}):(\\s*(?<text>.*))`) : void 0,
+    // Override defaults with user options
+    ...userOptions
+  };
+}
+
+// src/commit-parser/parser-error.ts
+var ParserError = class extends Error {
+  detail;
+  constructor(message, detail) {
+    super(message);
+    this.name = "ParserError";
+    this.detail = detail;
+  }
+};
+
+// src/commit-parser/commit-parser.ts
+var CommitParser = class {
+  #options;
+  #logger;
+  constructor(userOptions) {
+    this.#options = createParserOptions(userOptions);
+    this.setLogger = this.setLogger.bind(this);
+    this.createCommit = this.createCommit.bind(this);
+    this.parseRawCommit = this.parseRawCommit.bind(this);
+    this.parseSubject = this.parseSubject.bind(this);
+    this.parseMerge = this.parseMerge.bind(this);
+    this.parseRevert = this.parseRevert.bind(this);
+    this.parseMentions = this.parseMentions.bind(this);
+    this.parseReferenceParts = this.parseReferenceParts.bind(this);
+    this.parseReferences = this.parseReferences.bind(this);
+    this.parseNotes = this.parseNotes.bind(this);
+    this.parseRawLines = this.parseRawLines.bind(this);
+    this.parse = this.parse.bind(this);
+  }
+  setLogger(logger) {
+    this.#logger = logger;
+    return this;
+  }
+  createCommit() {
+    return {
+      raw: "",
+      subject: "",
+      body: "",
+      hash: "",
+      date: "",
+      name: "",
+      email: "",
+      type: "",
+      scope: "",
+      breakingChange: "",
+      title: "",
+      merge: null,
+      revert: null,
+      notes: [],
+      mentions: [],
+      references: []
+    };
   }
   /**
-   * - [git-add Documentation](https://git-scm.com/docs/git-add)
+   * Parse the raw commit message into its expected parts
+   * - subject
+   * - body
+   * - hash
+   * - date
+   * - name
+   * - email
+   *
+   * @throws {ParserError}
    */
-  async add(...args) {
-    if (this.config.dryRun) {
-      return "";
+  parseRawCommit(rawCommit) {
+    const parsedCommit = this.createCommit();
+    const parts = rawCommit.split(/\r?\n/);
+    if (parts.length < 6) {
+      throw new ParserError("Commit doesn't contain enough parts", rawCommit);
+    }
+    const email = parts.pop();
+    const name = parts.pop();
+    const date = parts.pop();
+    const hash = parts.pop();
+    if (email) parsedCommit.email = email.trim();
+    if (name) parsedCommit.name = name.trim();
+    if (date) {
+      parsedCommit.date = date.trim();
+      if (Number.isNaN(Date.parse(parsedCommit.date))) {
+        throw new ParserError("Unable to parse commit date", rawCommit);
+      }
+    }
+    if (hash) parsedCommit.hash = hash.trim();
+    const subject = parts.shift()?.trimStart();
+    if (subject) {
+      parsedCommit.subject = subject;
+      parsedCommit.raw = subject;
     }
-    return this.execGit("add", args.filter(Boolean));
+    parsedCommit.body = parts.filter((line) => {
+      if (this.#options.commentPattern) {
+        return !this.#options.commentPattern.test(line.trim());
+      }
+      return true;
+    }).join("\n").trim();
+    const raw = parts.join("\n").trim();
+    if (raw) parsedCommit.raw += "\n" + raw;
+    return parsedCommit;
   }
   /**
-   * - [git-commit Documentation](https://git-scm.com/docs/git-commit)
+   * Parse the commit subject into its expected parts
+   * - type
+   * - scope (optional)
+   * - breaking change (optional)
+   * - title
+   *
+   * @throws {ParserError}
    */
-  async commit(...args) {
-    if (this.config.dryRun) {
-      return "";
+  parseSubject(commit) {
+    if (!this.#options.subjectPattern) return false;
+    const subjectMatch = new RegExp(this.#options.subjectPattern, "i").exec(commit.subject);
+    if (subjectMatch?.groups) {
+      const { type = "", scope = "", breakingChange = "", title = "" } = subjectMatch.groups;
+      if (!type || !title) {
+        throw new ParserError("Unable to parse commit subject", commit);
+      }
+      commit.type = type;
+      commit.scope = scope;
+      if (breakingChange) commit.breakingChange = breakingChange;
+      commit.title = title;
+      return true;
     }
-    return this.execGit("commit", args.filter(Boolean));
+    return false;
   }
   /**
-   * - [git-tag Documentation](https://git-scm.com/docs/git-tag)
+   * Parse merge information from the commit subject
+   * @example
+   * ```txt
+   * "Merge pull request #123 from fork-version/feature"
+   * ```
    */
-  async tag(...args) {
-    if (this.config.dryRun) {
-      return "";
+  parseMerge(commit) {
+    if (!this.#options.mergePattern) return false;
+    const mergeMatch = new RegExp(this.#options.mergePattern).exec(commit.subject);
+    if (mergeMatch?.groups) {
+      const { id = "", source = "" } = mergeMatch.groups;
+      commit.merge = {
+        id,
+        source
+      };
+      return true;
     }
-    return this.execGit("tag", args.filter(Boolean));
+    return false;
   }
   /**
-   * - [git-check-ignore Documentation](https://git-scm.com/docs/git-check-ignore)
+   * Parse revert information from the commit body
+   * @example
+   * ```txt
+   * "Revert "feat: initial commit"
+   *
+   * This reverts commit 4a79e9e546b4020d2882b7810dc549fa71960f4f."
+   * ```
    */
-  async isIgnored(file) {
-    try {
-      await this.execGit("check-ignore", ["--no-index", file]);
+  parseRevert(commit) {
+    if (!this.#options.revertPattern) return false;
+    const revertMatch = new RegExp(this.#options.revertPattern).exec(commit.raw);
+    if (revertMatch?.groups) {
+      const { hash = "", subject = "" } = revertMatch.groups;
+      commit.revert = {
+        hash,
+        subject
+      };
       return true;
-    } catch (_error) {
-      return false;
     }
+    return false;
   }
-  async getCurrentBranchName() {
-    return (await this.execGit("rev-parse", ["--abbrev-ref", "HEAD"])).trim();
+  /**
+   * Search for mentions from the commit line
+   * @example
+   * ```txt
+   * "@fork-version"
+   * ```
+   */
+  parseMentions(line, outMentions) {
+    if (!this.#options.mentionPattern) return false;
+    const mentionRegex = new RegExp(this.#options.mentionPattern, "g");
+    let foundMention = false;
+    let mentionMatch;
+    while (mentionMatch = mentionRegex.exec(line)) {
+      if (!mentionMatch) {
+        break;
+      }
+      const { username = "" } = mentionMatch.groups ?? {};
+      outMentions.add(username);
+      foundMention = true;
+    }
+    return foundMention;
   }
   /**
-   * `getTags` returns valid semver version tags in order of the commit history.
-   *
-   * Using `git log` to get the commit history, we then parse the tags from the
-   * commit details which is expected to be in the following format:
+   * Search for references from the commit line
    * @example
    * ```txt
-   * commit 3841b1d05750d42197fe958e3d8e06df378a842d (HEAD -> main, tag: 1.0.2)
-   * Author: Username <username@example.com>
-   * Date:   Sat Nov 9 15:00:00 2024 +0000
-   *
-   *     chore(release): 1.2.3
+   * "#1234"
+   * "owner/repo#1234"
    * ```
-   *
-   * - [Functionality extracted from the conventional-changelog - git-semver-tags project](https://github.com/conventional-changelog/conventional-changelog/blob/fac8045242099c016f5f3905e54e02b7d466bd7b/packages/git-semver-tags/index.js)
-   * - [conventional-changelog git-semver-tags MIT Licence](https://github.com/conventional-changelog/conventional-changelog/blob/fac8045242099c016f5f3905e54e02b7d466bd7b/packages/git-semver-tags/LICENSE.md)
    */
-  async getTags(tagPrefix) {
-    const logOutput = await this.execGit("log", ["--decorate", "--no-color", "--date-order"]);
-    const TAG_REGEX = /tag:\s*(.+?)[,)]/gi;
-    const tags = [];
-    let match = null;
-    let tag;
-    let tagWithoutPrefix;
-    for (const logOutputLine of logOutput.split("\n")) {
-      while (match = TAG_REGEX.exec(logOutputLine)) {
-        tag = match[1];
-        if (tagPrefix) {
-          if (tag.startsWith(tagPrefix)) {
-            tagWithoutPrefix = tag.replace(tagPrefix, "");
-            if (semver.valid(tagWithoutPrefix)) {
-              tags.push(tag);
-            }
-          }
-        } else if (semver.valid(tag)) {
-          tags.push(tag);
+  parseReferenceParts(referenceText, action) {
+    if (!this.#options.issuePattern) return void 0;
+    const references = [];
+    const issueRegex = new RegExp(this.#options.issuePattern, "gi");
+    let issueMatch;
+    while (issueMatch = issueRegex.exec(referenceText)) {
+      if (!issueMatch) {
+        break;
+      }
+      const { repository = "", prefix = "", issue = "" } = issueMatch.groups ?? {};
+      const reference = {
+        prefix,
+        issue,
+        action,
+        owner: null,
+        repository: null
+      };
+      if (repository) {
+        const slashIndex = repository.indexOf("/");
+        if (slashIndex !== -1) {
+          reference.owner = repository.slice(0, slashIndex);
+          reference.repository = repository.slice(slashIndex + 1);
+        } else {
+          reference.repository = repository;
         }
       }
+      references.push(reference);
     }
-    return tags;
+    if (references.length > 0) {
+      return references;
+    }
+    return void 0;
   }
-  async getLatestTag(tagPrefix) {
-    const tags = await this.getTags(tagPrefix);
-    if (!tags.length) return "";
-    const cleanedTags = [];
-    for (const tag of tags) {
-      const cleanedTag = semver.clean(tag.replace(new RegExp(`^${tagPrefix}`), ""));
-      if (cleanedTag) {
-        cleanedTags.push(cleanedTag);
+  /**
+   * Search for actions and references from the commit line
+   * @example
+   * ```txt
+   * "Closes #1234"
+   * "fixes owner/repo#1234"
+   * ```
+   */
+  parseReferences(line, outReferences) {
+    if (!this.#options.referenceActionPattern || !this.#options.issuePattern) return false;
+    const referenceActionRegex = new RegExp(this.#options.referenceActionPattern, "gi").test(line) ? new RegExp(this.#options.referenceActionPattern, "gi") : /(?<reference>.*)/g;
+    let foundReference = false;
+    let referenceActionMatch;
+    while (referenceActionMatch = referenceActionRegex.exec(line)) {
+      if (!referenceActionMatch) {
+        break;
+      }
+      const { action = "", reference = "" } = referenceActionMatch.groups ?? {};
+      const parsedReferences = this.parseReferenceParts(reference, action || null);
+      if (!parsedReferences) {
+        break;
+      }
+      for (const ref of parsedReferences) {
+        if (!outReferences.some((r) => r.prefix === ref.prefix && r.issue === ref.issue)) {
+          outReferences.push(ref);
+        }
       }
+      foundReference = true;
+    }
+    return foundReference;
+  }
+  /**
+   * Search for notes from the commit line
+   * @example
+   * ```txt
+   * "BREAKING CHANGE: this is a breaking change"
+   * ```
+   */
+  parseNotes(line, outNotes) {
+    if (!this.#options.notePattern) return false;
+    const noteMatch = new RegExp(this.#options.notePattern, "ig").exec(line);
+    if (noteMatch?.groups) {
+      const { title = "", text = "" } = noteMatch.groups;
+      outNotes.push({
+        title,
+        text
+      });
+      return true;
+    }
+    return false;
+  }
+  /**
+   * Parse the raw commit for mentions, references and notes
+   */
+  parseRawLines(commit) {
+    const mentions = /* @__PURE__ */ new Set();
+    const references = [];
+    const notes = [];
+    let lastNoteLine = -1;
+    const splitMessage = commit.raw.split("\n");
+    for (let index = 0; index < splitMessage.length; index++) {
+      const line = splitMessage[index];
+      const trimmedLine = line.trim();
+      if (this.#options.commentPattern?.test(trimmedLine)) {
+        continue;
+      }
+      this.parseMentions(trimmedLine, mentions);
+      const foundReference = this.parseReferences(trimmedLine, references);
+      if (foundReference) {
+        lastNoteLine = -1;
+        continue;
+      }
+      if (this.parseNotes(trimmedLine, notes)) {
+        lastNoteLine = index;
+      } else if (lastNoteLine !== -1) {
+        notes[notes.length - 1].text += `
+${line}`;
+        lastNoteLine = index;
+      }
+    }
+    if (mentions.size > 0) {
+      commit.mentions = Array.from(mentions);
+    }
+    if (references.length > 0) {
+      commit.references = references;
+    }
+    if (notes.length > 0) {
+      commit.notes = notes.map((note) => ({
+        ...note,
+        text: note.text.trim()
+      }));
+    }
+  }
+  /**
+   * Parse a commit log with the following format separated by new line characters:
+   * ```txt
+   * refactor: add test file
+   * Add a test file to the project
+   * 4ef2c86d393a9660aa9f753144256b1f200c16bd
+   * 2024-12-22T17:36:50Z
+   * Fork Version
+   * fork-version@example.com
+   * ```
+   *
+   * @example
+   * ```ts
+   * parse("refactor: add test file\nAdd a test file to the project\n4ef2c86d393a9660aa9f753144256b1f200c16bd\n2024-12-22T17:36:50Z\nFork Version\nfork-version@example.com");
+   * ```
+   *
+   * The expected input value can be generated by running the following command:
+   * ```sh
+   * git log --format="%s%n%b%n%H%n%cI%n%cN%n%cE%n"
+   * ```
+   * @see {@link https://git-scm.com/docs/pretty-formats|Git Pretty Format Documentation}
+   */
+  parse(rawCommit) {
+    try {
+      const commit = this.parseRawCommit(rawCommit);
+      this.parseSubject(commit);
+      this.parseMerge(commit);
+      this.parseRevert(commit);
+      this.parseRawLines(commit);
+      return commit;
+    } catch (error) {
+      if (this.#logger) {
+        this.#logger.debug("[Commit Parser] Failed to parse commit", { error });
+      }
+      return void 0;
     }
-    return cleanedTags.sort(semver.rcompare)[0];
   }
 };
+
+// src/commit-parser/filter-reverted-commits.ts
+function filterRevertedCommits(parsedCommits) {
+  const revertedCommits = [];
+  for (const commit of parsedCommits) {
+    if (!commit.revert) continue;
+    if (revertedCommits.some(
+      (r) => r.revert?.hash === commit.hash || r.revert?.subject === commit.subject
+    )) {
+      continue;
+    }
+    revertedCommits.push(commit);
+  }
+  if (revertedCommits.length === 0) {
+    return parsedCommits;
+  }
+  const commitsWithoutReverts = [];
+  for (const commit of parsedCommits) {
+    if (commit.revert) continue;
+    const revertedIndex = revertedCommits.findIndex(
+      (r) => r.revert?.hash === commit.hash || r.revert?.subject === commit.subject
+    );
+    if (revertedIndex !== -1) {
+      revertedCommits.splice(revertedIndex, 1);
+      continue;
+    }
+    commitsWithoutReverts.push(commit);
+  }
+  return commitsWithoutReverts;
+}
+
+// src/process/get-commits.ts
+async function getCommitsSinceTag(config, logger, git) {
+  const commitParser = new CommitParser();
+  if (config.debug) commitParser.setLogger(logger);
+  const latestTag = await git.getMostRecentTag(config.tagPrefix);
+  if (!latestTag) {
+    logger.warn("No previous tag found, using all commits");
+  }
+  const foundCommits = await git.getCommits(latestTag, "HEAD");
+  logger.debug(`Found ${foundCommits.length} commits since last tag (${latestTag ?? "none"})`);
+  const commits = foundCommits.reduce((acc, commit) => {
+    const parsed = commitParser.parse(commit);
+    if (parsed) {
+      acc.push(parsed);
+    }
+    return acc;
+  }, []);
+  logger.debug(`Parsed ${commits.length} commits after applying commit parser`);
+  const filteredCommits = filterRevertedCommits(commits);
+  logger.debug(`Filtered to ${filteredCommits.length} commits after removing reverts`);
+  return {
+    latestTag,
+    commits: filteredCommits
+  };
+}
 function getPriority(type) {
   return ["patch", "minor", "major"].indexOf(type ?? "");
 }
@@ -1018,7 +1665,7 @@ async function getCurrentVersion(config, logger, git, fileManager, filesToUpdate
     versions.add(config.currentVersion);
   }
   if (versions.size === 0 && config.gitTagFallback) {
-    const version = await git.getLatestTag(config.tagPrefix);
+    const version = await git.getHighestSemverVersionFromTags(config.tagPrefix);
     if (version) {
       logger.warn(`Using latest git tag as fallback`);
       versions.add(version);
@@ -1045,65 +1692,77 @@ async function getCurrentVersion(config, logger, git, fileManager, filesToUpdate
     version: currentVersion
   };
 }
-async function getNextVersion(config, logger, currentVersion) {
+async function getNextVersion(config, logger, commits, currentVersion) {
   if (config.skipBump) {
     logger.warn(`Skip bump, using ${currentVersion} as the next version`);
     return {
       version: currentVersion
     };
   }
-  if (config.nextVersion && semver.valid(config.nextVersion)) {
+  if (config.nextVersion) {
+    if (!semver.valid(config.nextVersion)) {
+      throw new Error(`Invalid Version: ${config.nextVersion}`);
+    }
     logger.log(`Next version: ${config.nextVersion}`);
     return {
       version: config.nextVersion
     };
   }
   const isPreMajor = semver.lt(currentVersion, "1.0.0");
-  let recommendedBump;
+  let releaseType = "patch";
+  const changes = { major: 0, minor: 0, patch: 0 };
   if (config.releaseAs) {
-    recommendedBump = {
-      releaseType: config.releaseAs,
-      level: -1,
-      reason: "User defined"
-    };
+    releaseType = config.releaseAs;
   } else {
-    try {
-      recommendedBump = await conventionalRecommendedBump({
-        preset: {
-          name: "conventionalcommits",
-          ...config.changelogPresetConfig,
-          preMajor: isPreMajor
-        },
-        path: config.path,
-        tagPrefix: config.tagPrefix,
-        cwd: config.path
-      });
-    } catch (cause) {
-      throw new Error(`[conventional-recommended-bump] Unable to determine next version`, {
-        cause
-      });
+    let level = 2;
+    const MINOR_TYPES = ["feat", "feature"];
+    for (const commit of commits) {
+      if (commit.notes.length > 0 || commit.breakingChange) {
+        changes.major += commit.notes.length + (commit.breakingChange ? 1 : 0);
+        level = 0;
+      } else if (MINOR_TYPES.includes(commit.type.toLowerCase())) {
+        changes.minor += 1;
+        if (level === 2) {
+          level = 1;
+        }
+      } else {
+        changes.patch += 1;
+      }
+    }
+    if (isPreMajor && level < 2) {
+      level++;
+      changes.patch += changes.minor;
+      changes.minor = changes.major;
+      changes.major = 0;
+    }
+    if (level === 0) {
+      releaseType = "major";
+    } else if (level === 1) {
+      releaseType = "minor";
+    } else {
+      releaseType = "patch";
     }
   }
-  if (recommendedBump.releaseType) {
-    const releaseType = getReleaseType(
-      recommendedBump.releaseType,
-      currentVersion,
-      config.preRelease
+  const releaseTypeOrPreRelease = getReleaseType(releaseType, currentVersion, config.preRelease);
+  const nextVersion = semver.inc(
+    currentVersion,
+    releaseTypeOrPreRelease,
+    typeof config.preRelease === "string" ? config.preRelease : ""
+  ) ?? "";
+  logger.log(`Next version: ${nextVersion} (${releaseTypeOrPreRelease})`);
+  if (commits.length > 0) {
+    logger.log(
+      `  - Commits: ${commits.length}` + (changes.major > 0 ? `, Breaking Changes: ${changes.major}` : "") + (changes.minor > 0 ? `, New Features: ${changes.minor}` : "") + (changes.patch > 0 ? `, Bug Fixes: ${changes.patch}` : "")
     );
-    const nextVersion = semver.inc(
-      currentVersion,
-      releaseType,
-      typeof config.preRelease === "string" ? config.preRelease : void 0
-    ) ?? "";
-    logger.log(`Next version: ${nextVersion} (${releaseType})`);
-    return {
-      ...recommendedBump,
-      preMajor: isPreMajor,
-      releaseType,
-      version: nextVersion
-    };
+  } else {
+    logger.log("  - No commits found.");
   }
-  throw new Error("Unable to find next version");
+  return {
+    version: nextVersion,
+    releaseType: releaseTypeOrPreRelease,
+    preMajor: isPreMajor,
+    changes
+  };
 }
 var RELEASE_PATTERN = /(^#+ \[?[0-9]+\.[0-9]+\.[0-9]+|<a name=)/m;
 function getOldReleaseContent(filePath, exists) {
@@ -1232,6 +1891,6 @@ async function tagChanges(config, logger, git, nextVersion) {
   );
 }
 
-export { FileManager, ForkConfigSchema, Git, Logger, commitChanges, getCurrentVersion, getNextVersion, getUserConfig, tagChanges, updateChangelog };
-//# sourceMappingURL=chunk-RLGF46N7.js.map
-//# sourceMappingURL=chunk-RLGF46N7.js.map
+export { CommitParser, FileManager, ForkConfigSchema, Git, Logger, commitChanges, createParserOptions, filterRevertedCommits, getCommitsSinceTag, getCurrentVersion, getNextVersion, getUserConfig, tagChanges, updateChangelog };
+//# sourceMappingURL=chunk-D2PQT6ZM.js.map
+//# sourceMappingURL=chunk-D2PQT6ZM.js.map