bumpp 9.10.1 → 9.11.0

package/dist/{chunk-HXP7VO25.mjs → chunk-BEM77VRK.js}

@@ -1,39 +1,10 @@
 import {createRequire as __createRequire} from 'module';var require=__createRequire(import.meta.url);
 var __create = Object.create;
 var __defProp = Object.defineProperty;
-var __defProps = Object.defineProperties;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getOwnPropSymbols = Object.getOwnPropertySymbols;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __propIsEnum = Object.prototype.propertyIsEnumerable;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues = (a, b) => {
-  for (var prop in b || (b = {}))
-    if (__hasOwnProp.call(b, prop))
-      __defNormalProp(a, prop, b[prop]);
-  if (__getOwnPropSymbols)
-    for (var prop of __getOwnPropSymbols(b)) {
-      if (__propIsEnum.call(b, prop))
-        __defNormalProp(a, prop, b[prop]);
-    }
-  return a;
-};
-var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
-var __objRest = (source, exclude) => {
-  var target = {};
-  for (var prop in source)
-    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
-      target[prop] = source[prop];
-  if (source != null && __getOwnPropSymbols)
-    for (var prop of __getOwnPropSymbols(source)) {
-      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
-        target[prop] = source[prop];
-    }
-  return target;
-};
 var __commonJS = (cb, mod) => function __require() {
   return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
 };
@@ -141,8 +112,7 @@ __export(symbols_exports, {
 
 // node_modules/.pnpm/yoctocolors@2.1.1/node_modules/yoctocolors/base.js
 import tty from "node:tty";
-var _a, _b, _c, _d, _e;
-var hasColors = (_e = (_d = (_c = (_b = (_a = tty) == null ? void 0 : _a.WriteStream) == null ? void 0 : _b.prototype) == null ? void 0 : _c.hasColors) == null ? void 0 : _d.call(_c)) != null ? _e : false;
+var hasColors = tty?.WriteStream?.prototype?.hasColors?.() ?? false;
 var format = (open, close) => {
   if (!hasColors) {
     return (input) => input;
@@ -228,7 +198,7 @@ var error = red(_isUnicodeSupported ? "\u2716\uFE0F" : "\xD7");
 
 // src/release-type.ts
 var prereleaseTypes = ["premajor", "preminor", "prepatch", "prerelease"];
-var releaseTypes = prereleaseTypes.concat(["major", "minor", "patch", "next"]);
+var releaseTypes = prereleaseTypes.concat(["major", "minor", "patch", "next", "conventional"]);
 function isPrerelease(value) {
   return prereleaseTypes.includes(value);
 }
@@ -298,7 +268,7 @@ var tokenizeArgs = (argsString, options) => {
   if (currentToken.length > 0) {
     tokens.push(currentToken);
   }
-  if (options == null ? void 0 : options.loose) {
+  if (options?.loose) {
     return tokens;
   }
   if (openningQuote) {
@@ -308,9 +278,10 @@ var tokenizeArgs = (argsString, options) => {
 };
 
 // src/version-bump.ts
-var import_picocolors3 = __toESM(require_picocolors());
+var import_picocolors3 = __toESM(require_picocolors(), 1);
 import prompts2 from "prompts";
-import { x as x4 } from "tinyexec";
+import { getRecentCommits } from "tiny-conventional-commits-parser";
+import { x as x3 } from "tinyexec";
 
 // src/get-current-version.ts
 import { valid as isValidVersion } from "semver";
@@ -323,15 +294,15 @@ async function readJsoncFile(name, cwd) {
   const file = await readTextFile(name, cwd);
   const data = jsonc.parse(file.data);
   const modified = [];
-  return __spreadProps(__spreadValues({}, file), { data, modified, text: file.data });
+  return { ...file, data, modified, text: file.data };
 }
 async function writeJsoncFile(file) {
   let newJSON = file.text;
   for (const [key, value] of file.modified) {
-    const edit = jsonc.modify(file.text, key, value, {});
+    const edit = jsonc.modify(newJSON, key, value, {});
     newJSON = jsonc.applyEdits(newJSON, edit);
   }
-  return writeTextFile(__spreadProps(__spreadValues({}, file), { data: newJSON }));
+  return writeTextFile({ ...file, data: newJSON });
 }
 function readTextFile(name, cwd) {
   return new Promise((resolve, reject) => {
@@ -364,8 +335,7 @@ function isManifest(obj) {
   return obj && typeof obj === "object" && isOptionalString(obj.name) && isOptionalString(obj.version) && isOptionalString(obj.description);
 }
 function isPackageLockManifest(manifest) {
-  var _a2, _b2;
-  return typeof ((_b2 = (_a2 = manifest.packages) == null ? void 0 : _a2[""]) == null ? void 0 : _b2.version) === "string";
+  return typeof manifest.packages?.[""]?.version === "string";
 }
 function isOptionalString(value) {
   const type = typeof value;
@@ -404,153 +374,22 @@ async function readVersion(file, cwd) {
       if (isValidVersion(manifest.version))
         return manifest.version;
     }
-  } catch (e) {
+  } catch {
     return void 0;
   }
 }
 
 // src/get-new-version.ts
-var import_picocolors2 = __toESM(require_picocolors());
+var import_picocolors = __toESM(require_picocolors(), 1);
 import process3 from "node:process";
 import prompts from "prompts";
 import semver, { clean as cleanVersion, valid as isValidVersion2, SemVer } from "semver";
-
-// src/print-commits.ts
-var import_picocolors = __toESM(require_picocolors());
-import { x } from "tinyexec";
-var messageColorMap = {
-  feat: import_picocolors.default.green,
-  feature: import_picocolors.default.green,
-  refactor: import_picocolors.default.cyan,
-  style: import_picocolors.default.cyan,
-  docs: import_picocolors.default.blue,
-  doc: import_picocolors.default.blue,
-  types: import_picocolors.default.blue,
-  type: import_picocolors.default.blue,
-  chore: import_picocolors.default.gray,
-  ci: import_picocolors.default.gray,
-  build: import_picocolors.default.gray,
-  deps: import_picocolors.default.gray,
-  dev: import_picocolors.default.gray,
-  fix: import_picocolors.default.yellow,
-  test: import_picocolors.default.yellow,
-  perf: import_picocolors.default.magenta,
-  revert: import_picocolors.default.red,
-  breaking: import_picocolors.default.red
-};
-function parseCommits(raw) {
-  const lines = raw.toString().trim().split(/\n/g);
-  if (!lines.length) {
-    return [];
-  }
-  return lines.map((line) => {
-    const [hash, ...parts] = line.split(" ");
-    const message = parts.join(" ");
-    const match = message.match(/^(\w+)(!)?(\([^)]+\))?(!)?:(.*)$/);
-    if (match) {
-      let color = messageColorMap[match[1].toLowerCase()] || ((c4) => c4);
-      const breaking = match[2] === "!" || match[4] === "!";
-      if (breaking) {
-        color = (s) => import_picocolors.default.inverse(import_picocolors.default.red(s));
-      }
-      const tag = [match[1], match[2], match[4]].filter(Boolean).join("");
-      const scope = match[3] || "";
-      return {
-        hash,
-        tag,
-        message: match[5].trim(),
-        scope,
-        breaking,
-        color
-      };
-    }
-    return {
-      hash,
-      tag: "",
-      message,
-      scope: "",
-      color: (c4) => c4
-    };
-  }).reverse();
-}
-function formatParsedCommits(commits) {
-  const tagLength = commits.map(({ tag }) => tag.length).reduce((a, b) => Math.max(a, b), 0);
-  let scopeLength = commits.map(({ scope }) => scope.length).reduce((a, b) => Math.max(a, b), 0);
-  if (scopeLength)
-    scopeLength += 2;
-  return commits.map(({ hash, tag, message, scope, color }) => {
-    const paddedTag = tag.padStart(tagLength + 1, " ");
-    const paddedScope = !scope ? " ".repeat(scopeLength) : import_picocolors.default.dim("(") + scope.slice(1, -1) + import_picocolors.default.dim(")") + " ".repeat(scopeLength - scope.length);
-    return [
-      import_picocolors.default.dim(hash),
-      " ",
-      color === import_picocolors.default.gray ? color(paddedTag) : import_picocolors.default.bold(color(paddedTag)),
-      " ",
-      paddedScope,
-      import_picocolors.default.dim(":"),
-      " ",
-      color === import_picocolors.default.gray ? color(message) : message
-    ].join("");
-  });
-}
-async function printRecentCommits(operation) {
-  let sha;
-  sha || (sha = await x(
-    "git",
-    ["rev-list", "-n", "1", `v${operation.state.currentVersion}`],
-    { nodeOptions: { stdio: "pipe" }, throwOnError: false }
-  ).then((res) => res.stdout.trim()));
-  sha || (sha = await x(
-    "git",
-    ["rev-list", "-n", "1", operation.state.currentVersion],
-    { nodeOptions: { stdio: "pipe" }, throwOnError: false }
-  ).then((res) => res.stdout.trim()));
-  if (!sha) {
-    console.log(
-      import_picocolors.default.blue(`i`) + import_picocolors.default.gray(` Failed to locate the previous tag ${import_picocolors.default.yellow(`v${operation.state.currentVersion}`)}`)
-    );
-    return;
-  }
-  const { stdout } = await x(
-    "git",
-    [
-      "--no-pager",
-      "log",
-      `${sha}..HEAD`,
-      "--oneline"
-    ],
-    {
-      nodeOptions: {
-        stdio: "pipe"
-      }
-    }
-  );
-  const parsed = parseCommits(stdout.toString().trim());
-  const prettified = formatParsedCommits(parsed);
-  if (!parsed.length) {
-    console.log();
-    console.log(import_picocolors.default.blue(`i`) + import_picocolors.default.gray(` No commits since ${operation.state.currentVersion}`));
-    console.log();
-    return;
-  }
-  console.log();
-  console.log(
-    import_picocolors.default.bold(
-      `${import_picocolors.default.green(parsed.length)} Commits since ${import_picocolors.default.gray(sha.slice(0, 7))}:`
-    )
-  );
-  console.log();
-  console.log(prettified.join("\n"));
-  console.log();
-}
-
-// src/get-new-version.ts
-async function getNewVersion(operation) {
+async function getNewVersion(operation, commits) {
   const { release } = operation.options;
   const { currentVersion } = operation.state;
   switch (release.type) {
     case "prompt":
-      return promptForNewVersion(operation);
+      return promptForNewVersion(operation, commits);
     case "version":
       return operation.update({
         newVersion: new SemVer(release.version, true).version
@@ -558,13 +397,20 @@ async function getNewVersion(operation) {
     default:
       return operation.update({
         release: release.type,
-        newVersion: getNextVersion(currentVersion, release)
+        newVersion: getNextVersion(currentVersion, release, commits)
       });
   }
 }
-function getNextVersion(currentVersion, bump) {
+function getNextVersion(currentVersion, bump, commits) {
   const oldSemVer = new SemVer(currentVersion);
-  const type = bump.type === "next" ? oldSemVer.prerelease.length ? "prerelease" : "patch" : bump.type;
+  let type;
+  if (bump.type === "next") {
+    type = oldSemVer.prerelease.length ? "prerelease" : "patch";
+  } else if (bump.type === "conventional") {
+    type = oldSemVer.prerelease.length ? "prerelease" : determineSemverChange(commits);
+  } else {
+    type = bump.type;
+  }
   const newSemVer = oldSemVer.inc(type, bump.preid);
   if (isPrerelease(bump.type) && newSemVer.prerelease.length === 2 && newSemVer.prerelease[0] === bump.preid && String(newSemVer.prerelease[1]) === "0") {
     newSemVer.prerelease[1] = "1";
@@ -572,43 +418,51 @@ function getNextVersion(currentVersion, bump) {
   }
   return newSemVer.version;
 }
-function getNextVersions(currentVersion, preid) {
+function determineSemverChange(commits) {
+  let [hasMajor, hasMinor] = [false, false];
+  for (const commit of commits) {
+    if (commit.isBreaking) {
+      hasMajor = true;
+    } else if (commit.type === "feat") {
+      hasMinor = true;
+    }
+  }
+  return hasMajor ? "major" : hasMinor ? "minor" : "patch";
+}
+function getNextVersions(currentVersion, preid, commits) {
   const next = {};
   const parse2 = semver.parse(currentVersion);
-  if (typeof (parse2 == null ? void 0 : parse2.prerelease[0]) === "string")
-    preid = (parse2 == null ? void 0 : parse2.prerelease[0]) || "preid";
+  if (typeof parse2?.prerelease[0] === "string")
+    preid = parse2?.prerelease[0] || "preid";
   for (const type of releaseTypes)
-    next[type] = getNextVersion(currentVersion, { type, preid });
+    next[type] = getNextVersion(currentVersion, { type, preid }, commits);
   return next;
 }
-async function promptForNewVersion(operation) {
-  var _a2, _b2;
+async function promptForNewVersion(operation, commits) {
   const { currentVersion } = operation.state;
   const release = operation.options.release;
-  const next = getNextVersions(currentVersion, release.preid);
-  const configCustomVersion = await ((_b2 = (_a2 = operation.options).customVersion) == null ? void 0 : _b2.call(_a2, currentVersion, semver));
-  if (operation.options.printCommits) {
-    await printRecentCommits(operation);
-  }
+  const next = getNextVersions(currentVersion, release.preid, commits);
+  const configCustomVersion = await operation.options.customVersion?.(currentVersion, semver);
   const PADDING = 13;
   const answers = await prompts([
     {
       type: "autocomplete",
       name: "release",
-      message: `Current version ${import_picocolors2.default.green(currentVersion)}`,
+      message: `Current version ${import_picocolors.default.green(currentVersion)}`,
       initial: configCustomVersion ? "config" : "next",
       choices: [
-        { value: "major", title: `${"major".padStart(PADDING, " ")} ${import_picocolors2.default.bold(next.major)}` },
-        { value: "minor", title: `${"minor".padStart(PADDING, " ")} ${import_picocolors2.default.bold(next.minor)}` },
-        { value: "patch", title: `${"patch".padStart(PADDING, " ")} ${import_picocolors2.default.bold(next.patch)}` },
-        { value: "next", title: `${"next".padStart(PADDING, " ")} ${import_picocolors2.default.bold(next.next)}` },
+        { value: "major", title: `${"major".padStart(PADDING, " ")} ${import_picocolors.default.bold(next.major)}` },
+        { value: "minor", title: `${"minor".padStart(PADDING, " ")} ${import_picocolors.default.bold(next.minor)}` },
+        { value: "patch", title: `${"patch".padStart(PADDING, " ")} ${import_picocolors.default.bold(next.patch)}` },
+        { value: "next", title: `${"next".padStart(PADDING, " ")} ${import_picocolors.default.bold(next.next)}` },
+        { value: "conventional", title: `${"conventional".padStart(PADDING, " ")} ${import_picocolors.default.bold(next.conventional)}` },
         ...configCustomVersion ? [
-          { value: "config", title: `${"from config".padStart(PADDING, " ")} ${import_picocolors2.default.bold(configCustomVersion)}` }
+          { value: "config", title: `${"from config".padStart(PADDING, " ")} ${import_picocolors.default.bold(configCustomVersion)}` }
         ] : [],
-        { value: "prepatch", title: `${"pre-patch".padStart(PADDING, " ")} ${import_picocolors2.default.bold(next.prepatch)}` },
-        { value: "preminor", title: `${"pre-minor".padStart(PADDING, " ")} ${import_picocolors2.default.bold(next.preminor)}` },
-        { value: "premajor", title: `${"pre-major".padStart(PADDING, " ")} ${import_picocolors2.default.bold(next.premajor)}` },
-        { value: "none", title: `${"as-is".padStart(PADDING, " ")} ${import_picocolors2.default.bold(currentVersion)}` },
+        { value: "prepatch", title: `${"pre-patch".padStart(PADDING, " ")} ${import_picocolors.default.bold(next.prepatch)}` },
+        { value: "preminor", title: `${"pre-minor".padStart(PADDING, " ")} ${import_picocolors.default.bold(next.preminor)}` },
+        { value: "premajor", title: `${"pre-major".padStart(PADDING, " ")} ${import_picocolors.default.bold(next.premajor)}` },
+        { value: "none", title: `${"as-is".padStart(PADDING, " ")} ${import_picocolors.default.bold(currentVersion)}` },
         { value: "custom", title: "custom ...".padStart(PADDING + 4, " ") }
       ]
     },
@@ -629,6 +483,7 @@ async function promptForNewVersion(operation) {
     case "custom":
     case "config":
     case "next":
+    case "conventional":
     case "none":
       return operation.update({ newVersion });
     default:
@@ -637,7 +492,7 @@ async function promptForNewVersion(operation) {
 }
 
 // src/git.ts
-import { x as x2 } from "tinyexec";
+import { x } from "tinyexec";
 async function gitCommit(operation) {
   if (!operation.options.commit)
     return operation;
@@ -657,7 +512,7 @@ async function gitCommit(operation) {
   args.push("--message", commitMessage);
   if (!all)
     args = args.concat(updatedFiles);
-  await x2("git", ["commit", ...args], { throwOnError: true });
+  await x("git", ["commit", ...args], { throwOnError: true });
   return operation.update({ event: "git commit" /* GitCommit */, commitMessage });
 }
 async function gitTag(operation) {
@@ -678,15 +533,15 @@ async function gitTag(operation) {
   if (operation.options.sign) {
     args.push("--sign");
   }
-  await x2("git", ["tag", ...args], { throwOnError: true });
+  await x("git", ["tag", ...args], { throwOnError: true });
   return operation.update({ event: "git tag" /* GitTag */, tagName });
 }
 async function gitPush(operation) {
   if (!operation.options.push)
     return operation;
-  await x2("git", ["push"], { throwOnError: true });
+  await x("git", ["push"], { throwOnError: true });
   if (operation.options.tag) {
-    await x2("git", ["push", "--tags"], { throwOnError: true });
+    await x("git", ["push", "--tags"], { throwOnError: true });
   }
   return operation.update({ event: "git push" /* GitPush */ });
 }
@@ -704,7 +559,6 @@ import process4 from "node:process";
 import yaml from "js-yaml";
 import { glob } from "tinyglobby";
 async function normalizeOptions(raw) {
-  var _a2, _b2, _d2;
   const preid = typeof raw.preid === "string" ? raw.preid : "beta";
   const sign = Boolean(raw.sign);
   const push = Boolean(raw.push);
@@ -732,7 +586,7 @@ async function normalizeOptions(raw) {
     commit = { all, noVerify, message: raw.commit };
   else if (raw.commit || tag || push)
     commit = { all, noVerify, message: "chore: release v" };
-  if (recursive && !((_a2 = raw.files) == null ? void 0 : _a2.length)) {
+  if (recursive && !raw.files?.length) {
     raw.files = [
       "package.json",
       "package-lock.json",
@@ -746,14 +600,11 @@ async function normalizeOptions(raw) {
       const pnpmWorkspace = await fs2.readFile("pnpm-workspace.yaml", "utf8");
       const workspaces = yaml.load(pnpmWorkspace);
       const workspacesWithPackageJson = workspaces.packages.map((workspace) => `${workspace}/package.json`);
-      const withoutExcludedWorkspaces = workspacesWithPackageJson.filter((workspace) => {
-        var _a3;
-        return !workspace.startsWith("!") && !((_a3 = raw.files) == null ? void 0 : _a3.includes(workspace));
-      });
+      const withoutExcludedWorkspaces = workspacesWithPackageJson.filter((workspace) => !workspace.startsWith("!") && !raw.files?.includes(workspace));
       raw.files = raw.files.concat(withoutExcludedWorkspaces);
     }
   } else {
-    raw.files = ((_b2 = raw.files) == null ? void 0 : _b2.length) ? raw.files : ["package.json", "package-lock.json", "jsr.json", "jsr.jsonc", "deno.json", "deno.jsonc"];
+    raw.files = raw.files?.length ? raw.files : ["package.json", "package-lock.json", "jsr.json", "jsr.jsonc", "deno.json", "deno.jsonc"];
   }
   const files = await glob(
     raw.files,
@@ -772,12 +623,12 @@ async function normalizeOptions(raw) {
   } else if (raw.interface === true || !raw.interface) {
     ui = { input: process4.stdin, output: process4.stdout };
   } else {
-    let _c2 = raw.interface, { input, output } = _c2, other = __objRest(_c2, ["input", "output"]);
+    let { input, output, ...other } = raw.interface;
     if (input === true || input !== false && !input)
       input = process4.stdin;
     if (output === true || output !== false && !output)
       output = process4.stdout;
-    ui = __spreadValues({ input, output }, other);
+    ui = { input, output, ...other };
   }
   if (release.type === "prompt" && !(ui.input && ui.output))
     throw new Error("Cannot prompt for the version number because input or output has been disabled.");
@@ -793,7 +644,7 @@ async function normalizeOptions(raw) {
     interface: ui,
     ignoreScripts,
     execute,
-    printCommits: (_d2 = raw.printCommits) != null ? _d2 : true,
+    printCommits: raw.printCommits ?? true,
     customVersion: raw.customVersion,
     currentVersion: raw.currentVersion
   };
@@ -802,31 +653,22 @@ async function normalizeOptions(raw) {
 // src/operation.ts
 var Operation = class _Operation {
   /**
-   * Private constructor.  Use the `Operation.start()` static method instead.
+   * The options for this operation.
    */
-  constructor(options, progress) {
-    /**
-     * The current state of the operation.
-     */
-    this.state = {
-      release: void 0,
-      currentVersion: "",
-      currentVersionSource: "",
-      newVersion: "",
-      commitMessage: "",
-      tagName: "",
-      updatedFiles: [],
-      skippedFiles: []
-    };
-    this.options = options;
-    this._progress = progress;
-    if (options.currentVersion) {
-      this.update({
-        currentVersion: options.currentVersion,
-        currentVersionSource: "user"
-      });
-    }
-  }
+  options;
+  /**
+   * The current state of the operation.
+   */
+  state = {
+    release: void 0,
+    currentVersion: "",
+    currentVersionSource: "",
+    newVersion: "",
+    commitMessage: "",
+    tagName: "",
+    updatedFiles: [],
+    skippedFiles: []
+  };
   /**
    * The results of the operation.
    */
@@ -843,6 +685,23 @@ var Operation = class _Operation {
       skippedFiles: state.skippedFiles.slice()
     };
   }
+  /**
+   * The callback that's used to report the progress of the operation.
+   */
+  _progress;
+  /**
+   * Private constructor.  Use the `Operation.start()` static method instead.
+   */
+  constructor(options, progress) {
+    this.options = options;
+    this._progress = progress;
+    if (options.currentVersion) {
+      this.update({
+        currentVersion: options.currentVersion,
+        currentVersionSource: "user"
+      });
+    }
+  }
   /**
    * Starts a new `versionBump()` operation.
    */
@@ -853,24 +712,86 @@ var Operation = class _Operation {
   /**
    * Updates the operation state and results, and reports the updated progress to the user.
    */
-  update(_a2) {
-    var _b2 = _a2, { event, script } = _b2, newState = __objRest(_b2, ["event", "script"]);
+  update({ event, script, ...newState }) {
     Object.assign(this.state, newState);
     if (event && this._progress) {
-      this._progress(__spreadValues({ event, script }, this.results));
+      this._progress({ event, script, ...this.results });
     }
     return this;
   }
 };
 
+// src/print-commits.ts
+var import_picocolors2 = __toESM(require_picocolors(), 1);
+var messageColorMap = {
+  feat: import_picocolors2.default.green,
+  feature: import_picocolors2.default.green,
+  refactor: import_picocolors2.default.cyan,
+  style: import_picocolors2.default.cyan,
+  docs: import_picocolors2.default.blue,
+  doc: import_picocolors2.default.blue,
+  types: import_picocolors2.default.blue,
+  type: import_picocolors2.default.blue,
+  chore: import_picocolors2.default.gray,
+  ci: import_picocolors2.default.gray,
+  build: import_picocolors2.default.gray,
+  deps: import_picocolors2.default.gray,
+  dev: import_picocolors2.default.gray,
+  fix: import_picocolors2.default.yellow,
+  test: import_picocolors2.default.yellow,
+  perf: import_picocolors2.default.magenta,
+  revert: import_picocolors2.default.red,
+  breaking: import_picocolors2.default.red
+};
+function formatParsedCommits(commits) {
+  const typeLength = commits.map(({ type }) => type.length).reduce((a, b) => Math.max(a, b), 0);
+  const scopeLength = commits.map(({ scope }) => scope.length).reduce((a, b) => Math.max(a, b), 0);
+  return commits.map((commit) => {
+    let color = messageColorMap[commit.type] || ((c4) => c4);
+    if (commit.isBreaking) {
+      color = (s) => import_picocolors2.default.inverse(import_picocolors2.default.red(s));
+    }
+    const paddedType = commit.type.padStart(typeLength + 1, " ");
+    const paddedScope = !commit.scope ? " ".repeat(scopeLength ? scopeLength + 2 : 0) : import_picocolors2.default.dim("(") + commit.scope + import_picocolors2.default.dim(")") + " ".repeat(scopeLength - commit.scope.length);
+    return [
+      import_picocolors2.default.dim(commit.shortHash),
+      " ",
+      color === import_picocolors2.default.gray ? color(paddedType) : import_picocolors2.default.bold(color(paddedType)),
+      " ",
+      paddedScope,
+      import_picocolors2.default.dim(":"),
+      " ",
+      color === import_picocolors2.default.gray ? color(commit.description) : commit.description
+    ].join("");
+  });
+}
+function printRecentCommits(commits) {
+  if (!commits.length) {
+    console.log();
+    console.log(import_picocolors2.default.blue(`i`) + import_picocolors2.default.gray(` No commits since the last version`));
+    console.log();
+    return;
+  }
+  const prettified = formatParsedCommits(commits);
+  console.log();
+  console.log(
+    import_picocolors2.default.bold(
+      `${import_picocolors2.default.green(commits.length)} Commits since the last version:`
+    )
+  );
+  console.log();
+  console.log(prettified.join("\n"));
+  console.log();
+}
+
 // src/run-npm-script.ts
-import { x as x3 } from "tinyexec";
+import { x as x2 } from "tinyexec";
 async function runNpmScript(script, operation) {
   const { cwd, ignoreScripts } = operation.options;
   if (!ignoreScripts) {
     const { data: manifest } = await readJsoncFile("package.json", cwd);
     if (isManifest(manifest) && hasScript(manifest, script)) {
-      await x3("npm", ["run", script, "--silent"], {
+      await x2("npm", ["run", script, "--silent"], {
         nodeOptions: { stdio: "inherit" }
       });
       operation.update({ event: "npm script" /* NpmScript */, script });
@@ -907,7 +828,7 @@ async function updateFiles(operation) {
   return operation;
 }
 async function updateFile(relPath, operation) {
-  if (!existsSync(relPath)) {
+  if (!existsSync(path2.join(operation.options.cwd, relPath))) {
     return false;
   }
   const name = path2.basename(relPath).trim().toLowerCase();
@@ -965,8 +886,12 @@ async function versionBump(arg = {}) {
   if (typeof arg === "string")
     arg = { release: arg };
   const operation = await Operation.start(arg);
+  const commits = getRecentCommits();
+  if (operation.options.printCommits) {
+    printRecentCommits(commits);
+  }
   await getCurrentVersion(operation);
-  await getNewVersion(operation);
+  await getNewVersion(operation, commits);
   if (arg.confirm) {
     printSummary(operation);
     if (!await prompts2({
@@ -983,7 +908,7 @@ async function versionBump(arg = {}) {
   if (operation.options.install) {
     const { detect } = await import("package-manager-detector/detect");
     const pm = await detect();
-    if (!(pm == null ? void 0 : pm.name)) {
+    if (!pm?.name) {
       throw new Error("Could not detect package manager, failed to run npm install");
     }
     const { COMMANDS, constructCommand } = await import("package-manager-detector/commands");
@@ -992,7 +917,7 @@ async function versionBump(arg = {}) {
       throw new Error("Could not find install command for package manager");
     }
     console.log(symbols_exports.info, "Installing dependencies with", `${command.command} ${command.args.join(" ")}`);
-    await x4(command.command, command.args, {
+    await x3(command.command, command.args, {
       throwOnError: true,
       nodeOptions: {
         stdio: "inherit",
@@ -1007,7 +932,7 @@ async function versionBump(arg = {}) {
     } else {
       const [command, ...args] = tokenizeArgs(operation.options.execute);
       console.log(symbols_exports.info, "Executing script", command, ...args);
-      await x4(command, args, {
+      await x3(command, args, {
         throwOnError: true,
         nodeOptions: {
           stdio: "inherit",
@@ -1046,8 +971,9 @@ async function versionBumpInfo(arg = {}) {
   if (typeof arg === "string")
     arg = { release: arg };
   const operation = await Operation.start(arg);
+  const commits = getRecentCommits();
   await getCurrentVersion(operation);
-  await getNewVersion(operation);
+  await getNewVersion(operation, commits);
   return operation;
 }
 
@@ -1076,7 +1002,9 @@ async function loadBumpConfig(overrides, cwd = process6.cwd()) {
   const { config } = await loadConfig({
     name,
     defaults: bumpConfigDefaults,
-    overrides: __spreadValues({}, overrides),
+    overrides: {
+      ...overrides
+    },
     cwd: configFile ? dirname(configFile) : cwd
   });
   return config;
@@ -1111,9 +1039,6 @@ function defineConfig(config) {
 }
 
 export {
-  __spreadValues,
-  __spreadProps,
-  __objRest,
   __toESM,
   symbols_exports,
   require_picocolors,