@releasekit/version 0.2.0-next.1 → 0.2.0-next.10

package/dist/{chunk-3JG7UWIT.js → chunk-DXDB5P7S.js}

@@ -1,6 +1,10 @@
 import {
   BaseVersionError
 } from "./chunk-GQLJ7JQY.js";
+import {
+  execAsync,
+  execSync
+} from "./chunk-LMPZV35Z.js";
 
 // src/config.ts
 import { loadVersionConfig } from "@releasekit/config";
@@ -202,24 +206,6 @@ import semver3 from "semver";
 // src/git/repository.ts
 import { existsSync, statSync } from "fs";
 import { join } from "path";
-
-// src/git/commandExecutor.ts
-import { execFile, execFileSync } from "child_process";
-var execAsync = (file, args, options) => {
-  const defaultOptions = { maxBuffer: 1024 * 1024 * 10, ...options };
-  return new Promise((resolve2, reject) => {
-    execFile(file, args, defaultOptions, (error, stdout, stderr) => {
-      if (error) {
-        reject(error);
-      } else {
-        resolve2({ stdout: stdout.toString(), stderr: stderr.toString() });
-      }
-    });
-  });
-};
-var execSync = (file, args, options) => execFileSync(file, args, { maxBuffer: 1024 * 1024 * 10, ...options });
-
-// src/git/repository.ts
 function isGitRepository(directory) {
   const gitDir = join(directory, ".git");
   if (!existsSync(gitDir)) {
@@ -374,28 +360,37 @@ async function getLatestTagForPackage(packageName, versionPrefix, options) {
       `Looking for tags for package ${packageName} with prefix ${versionPrefix || "none"}, packageSpecificTags: ${packageSpecificTags}`,
       "debug"
     );
-    const allTags = await getSemverTags({
-      tagPrefix: versionPrefix
-    });
-    log(`Retrieved ${allTags.length} tags: ${allTags.join(", ")}`, "debug");
+    let allTags = [];
+    try {
+      const { execSync: execSync2 } = await import("./commandExecutor-E44ID5U4.js");
+      const tagsOutput = execSync2("git", ["tag", "-l"], { cwd: process.cwd() });
+      allTags = tagsOutput.toString().trim().split("\n").filter((tag) => tag.length > 0);
+    } catch (err) {
+      log(`Error getting tags: ${err instanceof Error ? err.message : String(err)}`, "error");
+    }
+    log(`Retrieved ${allTags.length} tags`, "debug");
     if (packageSpecificTags) {
       const packageTagPattern = escapeRegExp(tagTemplate).replace(/\\\$\\\{packageName\\\}/g, `(?:${escapedPackageName})`).replace(/\\\$\\\{prefix\\\}/g, `(?:${escapedPrefix})`).replace(/\\\$\\\{version\\\}/g, "(?:[0-9]+\\.[0-9]+\\.[0-9]+(?:-[a-zA-Z0-9.-]+)?)");
       log(`Using package tag pattern: ${packageTagPattern}`, "debug");
       const packageTagRegex = new RegExp(`^${packageTagPattern}$`);
       let packageTags = allTags.filter((tag) => packageTagRegex.test(tag));
+      log(`Found ${packageTags.length} matching tags for ${packageName}`, "debug");
       if (packageTags.length > 0) {
         const chronologicalFirst = packageTags[0];
+        void chronologicalFirst;
         const sortedPackageTags2 = [...packageTags].sort((a, b) => {
           let versionA = "";
           let versionB = "";
           if (a.includes("@")) {
-            const afterAt = a.split("@")[1] || "";
+            const parts = a.split("@");
+            const afterAt = parts[parts.length - 1] || "";
             versionA = afterAt.replace(new RegExp(`^${escapeRegExp(versionPrefix || "")}`), "");
           } else {
             versionA = a.replace(new RegExp(`^${escapeRegExp(packageName)}`), "").replace(new RegExp(`^${escapeRegExp(versionPrefix || "")}`), "");
           }
           if (b.includes("@")) {
-            const afterAtB = b.split("@")[1] || "";
+            const parts = b.split("@");
+            const afterAtB = parts[parts.length - 1] || "";
             versionB = afterAtB.replace(new RegExp(`^${escapeRegExp(versionPrefix || "")}`), "");
           } else {
             versionB = b.replace(new RegExp(`^${escapeRegExp(packageName)}`), "").replace(new RegExp(`^${escapeRegExp(versionPrefix || "")}`), "");
@@ -406,12 +401,6 @@ async function getLatestTagForPackage(packageName, versionPrefix, options) {
         });
         log(`Found ${packageTags.length} package tags using configured pattern`, "debug");
         log(`Using semantically latest tag: ${sortedPackageTags2[0]}`, "debug");
-        if (sortedPackageTags2[0] !== chronologicalFirst) {
-          log(
-            `Package tag ordering differs: chronological first is ${chronologicalFirst}, semantic latest is ${sortedPackageTags2[0]}`,
-            "debug"
-          );
-        }
         return sortedPackageTags2[0];
       }
       if (versionPrefix) {
@@ -419,9 +408,11 @@ async function getLatestTagForPackage(packageName, versionPrefix, options) {
         packageTags = allTags.filter((tag) => pattern1.test(tag));
         if (packageTags.length > 0) {
           const sortedPackageTags2 = [...packageTags].sort((a, b) => {
-            const afterAt = a.split("@")[1] || "";
+            const aParts = a.split("@");
+            const afterAt = aParts[aParts.length - 1] || "";
             const versionA = afterAt.replace(new RegExp(`^${escapeRegExp(versionPrefix || "")}`), "");
-            const afterAtB = b.split("@")[1] || "";
+            const bParts = b.split("@");
+            const afterAtB = bParts[bParts.length - 1] || "";
             const versionB = afterAtB.replace(new RegExp(`^${escapeRegExp(versionPrefix || "")}`), "");
             const cleanVersionA = semver.clean(versionA) || "0.0.0";
             const cleanVersionB = semver.clean(versionB) || "0.0.0";
@@ -437,8 +428,10 @@ async function getLatestTagForPackage(packageName, versionPrefix, options) {
         packageTags = allTags.filter((tag) => pattern2.test(tag));
         if (packageTags.length > 0) {
           const sortedPackageTags2 = [...packageTags].sort((a, b) => {
-            const versionA = semver.clean(a.split("@")[1] || "") || "0.0.0";
-            const versionB = semver.clean(b.split("@")[1] || "") || "0.0.0";
+            const aParts = a.split("@");
+            const versionA = semver.clean(aParts[aParts.length - 1] || "") || "0.0.0";
+            const bParts = b.split("@");
+            const versionB = semver.clean(bParts[bParts.length - 1] || "") || "0.0.0";
             return semver.rcompare(versionA, versionB);
           });
           log(`Found ${packageTags.length} package tags using pattern: ${versionPrefix}packageName@...`, "debug");
@@ -458,8 +451,10 @@ async function getLatestTagForPackage(packageName, versionPrefix, options) {
         return "";
       }
       const sortedPackageTags = [...packageTags].sort((a, b) => {
-        const versionA = semver.clean(a.split("@")[1] || "") || "0.0.0";
-        const versionB = semver.clean(b.split("@")[1] || "") || "0.0.0";
+        const aParts = a.split("@");
+        const versionA = semver.clean(aParts[aParts.length - 1] || "") || "0.0.0";
+        const bParts = b.split("@");
+        const versionB = semver.clean(bParts[bParts.length - 1] || "") || "0.0.0";
         return semver.rcompare(versionA, versionB);
       });
       log(`Found ${packageTags.length} package tags for ${packageName}`, "debug");
@@ -698,12 +693,17 @@ var VersionMismatchError = class extends Error {
     this.name = "VersionMismatchError";
   }
 };
-async function getBestVersionSource(tagName, packageVersion, cwd4, mismatchStrategy = "error") {
+async function getBestVersionSource(tagName, packageVersion, cwd4, mismatchStrategy = "error", strictReachable = false) {
   if (!tagName?.trim()) {
     return packageVersion ? { source: "package", version: packageVersion, reason: "No git tag provided" } : { source: "initial", version: "0.1.0", reason: "No git tag or package version available" };
   }
   const verification = verifyTag(tagName, cwd4);
   if (!verification.exists || !verification.reachable) {
+    if (strictReachable) {
+      throw new Error(
+        `Git tag '${tagName}' is not reachable from the current commit. The tag exists but cannot be reached from HEAD, which usually means you're on a different branch or the tag is orphaned. To allow fallback to package version, set strictReachable to false in your configuration.`
+      );
+    }
     if (packageVersion) {
       log(
         `Git tag '${tagName}' unreachable (${verification.error}), using package version: ${packageVersion}`,
@@ -809,7 +809,8 @@ async function calculateVersion(config, options) {
     prereleaseIdentifier: configPrereleaseIdentifier,
     branchPattern,
     baseBranch,
-    mismatchStrategy
+    mismatchStrategy,
+    strictReachable
   } = config;
   const {
     latestTag,
@@ -854,7 +855,13 @@ async function calculateVersion(config, options) {
       const packageDir = pkgPath || cwd();
       const manifestResult = getVersionFromManifests(packageDir);
       const packageVersion = manifestResult.manifestFound && manifestResult.version ? manifestResult.version : void 0;
-      versionSource = await getBestVersionSource(latestTag, packageVersion, packageDir, mismatchStrategy);
+      versionSource = await getBestVersionSource(
+        latestTag,
+        packageVersion,
+        packageDir,
+        mismatchStrategy,
+        strictReachable
+      );
       log(`Using version source: ${versionSource.source} (${versionSource.reason})`, "info");
     }
     const specifiedType = type;
@@ -962,12 +969,56 @@ import { exit } from "process";
 // src/changelog/commitParser.ts
 var CONVENTIONAL_COMMIT_REGEX = /^(\w+)(?:\(([^)]+)\))?(!)?: (.+)(?:\n\n([\s\S]*))?/;
 var BREAKING_CHANGE_REGEX = /BREAKING CHANGE: ([\s\S]+?)(?:\n\n|$)/;
+function extractChangelogEntriesWithHash(projectDir, revisionRange) {
+  try {
+    const args = ["log", revisionRange, "--pretty=format:%H|||%B---COMMIT_DELIMITER---", "--no-merges", "--", "."];
+    const output = execSync("git", args, { cwd: projectDir, encoding: "utf8" }).toString();
+    const commits = output.split("---COMMIT_DELIMITER---").filter((commit) => commit.trim() !== "");
+    return commits.map((commit) => {
+      const [hash, ...messageParts] = commit.split("|||");
+      const message = messageParts.join("|||").trim();
+      const entry = parseCommitMessage(message);
+      if (entry && hash) {
+        return { hash: hash.trim(), entry };
+      }
+      return null;
+    }).filter((item) => item !== null);
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    log(`Error extracting commits with hash: ${errorMessage}`, "error");
+    return [];
+  }
+}
+function extractAllChangelogEntriesWithHash(projectDir, revisionRange) {
+  try {
+    const args = ["log", revisionRange, "--pretty=format:%H|||%B---COMMIT_DELIMITER---", "--no-merges"];
+    const output = execSync("git", args, { cwd: projectDir, encoding: "utf8" }).toString();
+    const commits = output.split("---COMMIT_DELIMITER---").filter((commit) => commit.trim() !== "");
+    return commits.map((commit) => {
+      const [hash, ...messageParts] = commit.split("|||");
+      const message = messageParts.join("|||").trim();
+      const entry = parseCommitMessage(message);
+      if (entry && hash) {
+        return { hash: hash.trim(), entry };
+      }
+      return null;
+    }).filter((item) => item !== null);
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    log(`Error extracting all commits with hash: ${errorMessage}`, "error");
+    return [];
+  }
+}
 function extractChangelogEntriesFromCommits(projectDir, revisionRange) {
+  return extractCommitsFromGitLog(projectDir, revisionRange, true);
+}
+function extractCommitsFromGitLog(projectDir, revisionRange, filterToPath) {
   try {
-    const output = execSync("git", ["log", revisionRange, "--pretty=format:%B---COMMIT_DELIMITER---", "--no-merges"], {
-      cwd: projectDir,
-      encoding: "utf8"
-    }).toString();
+    const args = ["log", revisionRange, "--pretty=format:%B---COMMIT_DELIMITER---", "--no-merges"];
+    if (filterToPath) {
+      args.push("--", ".");
+    }
+    const output = execSync("git", args, { cwd: projectDir, encoding: "utf8" }).toString();
     const commits = output.split("---COMMIT_DELIMITER---").filter((commit) => commit.trim() !== "");
     return commits.map((commit) => parseCommitMessage(commit)).filter((entry) => entry !== null);
   } catch (error) {
@@ -1395,6 +1446,11 @@ var PackageProcessor = class {
           if (verification.exists && verification.reachable) {
             revisionRange = `${latestTag}..HEAD`;
           } else {
+            if (this.config.strictReachable) {
+              throw new Error(
+                `Cannot generate changelog: tag '${latestTag}' is not reachable from the current commit. When strictReachable is enabled, all tags must be reachable. To allow fallback to all commits, set strictReachable to false.`
+              );
+            }
             log(`Tag ${latestTag} is unreachable (${verification.error}), using all commits for changelog`, "debug");
             revisionRange = "HEAD";
           }
@@ -1402,6 +1458,14 @@ var PackageProcessor = class {
           revisionRange = "HEAD";
         }
         changelogEntries = extractChangelogEntriesFromCommits(pkgPath, revisionRange);
+        const allCommitsWithHash = extractAllChangelogEntriesWithHash(pkgPath, revisionRange);
+        const packageCommitsWithHash = extractChangelogEntriesWithHash(pkgPath, revisionRange);
+        const packageCommitHashes = new Set(packageCommitsWithHash.map((c) => c.hash));
+        const globalCommits = allCommitsWithHash.filter((c) => !packageCommitHashes.has(c.hash)).map((c) => c.entry);
+        if (globalCommits.length > 0) {
+          log(`Adding ${globalCommits.length} global commit(s) to ${name} changelog`, "debug");
+          changelogEntries = [...globalCommits, ...changelogEntries];
+        }
         if (changelogEntries.length === 0) {
           changelogEntries = [
             {
@@ -1712,6 +1776,11 @@ function createSyncStrategy(config) {
             });
             revisionRange = `${latestTag}..HEAD`;
           } catch {
+            if (config.strictReachable) {
+              throw new Error(
+                `Cannot generate changelog: tag '${latestTag}' is not reachable from the current commit. When strictReachable is enabled, all tags must be reachable. To allow fallback to all commits, set strictReachable to false.`
+              );
+            }
             log(`Tag ${latestTag} doesn't exist, using all commits for changelog`, "debug");
             revisionRange = "HEAD";
           }
@@ -1831,6 +1900,11 @@ function createSingleStrategy(config) {
             });
             revisionRange = `${latestTag}..HEAD`;
           } catch {
+            if (config.strictReachable) {
+              throw new Error(
+                `Cannot generate changelog: tag '${latestTag}' is not reachable from the current commit. When strictReachable is enabled, all tags must be reachable. To allow fallback to all commits, set strictReachable to false.`
+              );
+            }
             log(`Tag ${latestTag} doesn't exist, using all commits for changelog`, "debug");
             revisionRange = "HEAD";
           }

package/dist/chunk-LMPZV35Z.js

@@ -0,0 +1,20 @@
+// src/git/commandExecutor.ts
+import { execFile, execFileSync } from "child_process";
+var execAsync = (file, args, options) => {
+  const defaultOptions = { maxBuffer: 1024 * 1024 * 10, ...options };
+  return new Promise((resolve, reject) => {
+    execFile(file, args, defaultOptions, (error, stdout, stderr) => {
+      if (error) {
+        reject(error);
+      } else {
+        resolve({ stdout: stdout.toString(), stderr: stderr.toString() });
+      }
+    });
+  });
+};
+var execSync = (file, args, options) => execFileSync(file, args, { maxBuffer: 1024 * 1024 * 10, ...options });
+
+export {
+  execAsync,
+  execSync
+};

package/dist/cli.cjs

@@ -57,6 +57,33 @@ var init_baseError = __esm({
   }
 });
 
+// src/git/commandExecutor.ts
+var commandExecutor_exports = {};
+__export(commandExecutor_exports, {
+  execAsync: () => execAsync,
+  execSync: () => execSync
+});
+var import_node_child_process, execAsync, execSync;
+var init_commandExecutor = __esm({
+  "src/git/commandExecutor.ts"() {
+    "use strict";
+    import_node_child_process = require("child_process");
+    execAsync = (file, args, options) => {
+      const defaultOptions = { maxBuffer: 1024 * 1024 * 10, ...options };
+      return new Promise((resolve2, reject) => {
+        (0, import_node_child_process.execFile)(file, args, defaultOptions, (error, stdout, stderr) => {
+          if (error) {
+            reject(error);
+          } else {
+            resolve2({ stdout: stdout.toString(), stderr: stderr.toString() });
+          }
+        });
+      });
+    };
+    execSync = (file, args, options) => (0, import_node_child_process.execFileSync)(file, args, { maxBuffer: 1024 * 1024 * 10, ...options });
+  }
+});
+
 // src/cli.ts
 var cli_exports = {};
 __export(cli_exports, {
@@ -370,31 +397,60 @@ function matchesPackageNamePattern(packageName, pattern) {
 var import_node_fs6 = __toESM(require("fs"), 1);
 var path6 = __toESM(require("path"), 1);
 
-// src/git/commandExecutor.ts
-var import_node_child_process = require("child_process");
-var execAsync = (file, args, options) => {
-  const defaultOptions = { maxBuffer: 1024 * 1024 * 10, ...options };
-  return new Promise((resolve2, reject) => {
-    (0, import_node_child_process.execFile)(file, args, defaultOptions, (error, stdout, stderr) => {
-      if (error) {
-        reject(error);
-      } else {
-        resolve2({ stdout: stdout.toString(), stderr: stderr.toString() });
-      }
-    });
-  });
-};
-var execSync = (file, args, options) => (0, import_node_child_process.execFileSync)(file, args, { maxBuffer: 1024 * 1024 * 10, ...options });
-
 // src/changelog/commitParser.ts
+init_commandExecutor();
 var CONVENTIONAL_COMMIT_REGEX = /^(\w+)(?:\(([^)]+)\))?(!)?: (.+)(?:\n\n([\s\S]*))?/;
 var BREAKING_CHANGE_REGEX = /BREAKING CHANGE: ([\s\S]+?)(?:\n\n|$)/;
+function extractChangelogEntriesWithHash(projectDir, revisionRange) {
+  try {
+    const args = ["log", revisionRange, "--pretty=format:%H|||%B---COMMIT_DELIMITER---", "--no-merges", "--", "."];
+    const output = execSync("git", args, { cwd: projectDir, encoding: "utf8" }).toString();
+    const commits = output.split("---COMMIT_DELIMITER---").filter((commit) => commit.trim() !== "");
+    return commits.map((commit) => {
+      const [hash, ...messageParts] = commit.split("|||");
+      const message = messageParts.join("|||").trim();
+      const entry = parseCommitMessage(message);
+      if (entry && hash) {
+        return { hash: hash.trim(), entry };
+      }
+      return null;
+    }).filter((item) => item !== null);
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    log(`Error extracting commits with hash: ${errorMessage}`, "error");
+    return [];
+  }
+}
+function extractAllChangelogEntriesWithHash(projectDir, revisionRange) {
+  try {
+    const args = ["log", revisionRange, "--pretty=format:%H|||%B---COMMIT_DELIMITER---", "--no-merges"];
+    const output = execSync("git", args, { cwd: projectDir, encoding: "utf8" }).toString();
+    const commits = output.split("---COMMIT_DELIMITER---").filter((commit) => commit.trim() !== "");
+    return commits.map((commit) => {
+      const [hash, ...messageParts] = commit.split("|||");
+      const message = messageParts.join("|||").trim();
+      const entry = parseCommitMessage(message);
+      if (entry && hash) {
+        return { hash: hash.trim(), entry };
+      }
+      return null;
+    }).filter((item) => item !== null);
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    log(`Error extracting all commits with hash: ${errorMessage}`, "error");
+    return [];
+  }
+}
 function extractChangelogEntriesFromCommits(projectDir, revisionRange) {
+  return extractCommitsFromGitLog(projectDir, revisionRange, true);
+}
+function extractCommitsFromGitLog(projectDir, revisionRange, filterToPath) {
   try {
-    const output = execSync("git", ["log", revisionRange, "--pretty=format:%B---COMMIT_DELIMITER---", "--no-merges"], {
-      cwd: projectDir,
-      encoding: "utf8"
-    }).toString();
+    const args = ["log", revisionRange, "--pretty=format:%B---COMMIT_DELIMITER---", "--no-merges"];
+    if (filterToPath) {
+      args.push("--", ".");
+    }
+    const output = execSync("git", args, { cwd: projectDir, encoding: "utf8" }).toString();
     const commits = output.split("---COMMIT_DELIMITER---").filter((commit) => commit.trim() !== "");
     return commits.map((commit) => parseCommitMessage(commit)).filter((entry) => entry !== null);
   } catch (error) {
@@ -489,13 +545,16 @@ function extractIssueIds(body) {
 
 // src/core/versionStrategies.ts
 init_baseError();
+init_commandExecutor();
 
 // src/git/commands.ts
 var import_node_process = require("process");
+init_commandExecutor();
 
 // src/git/repository.ts
 var import_node_fs = require("fs");
 var import_node_path2 = require("path");
+init_commandExecutor();
 function isGitRepository(directory) {
   const gitDir = (0, import_node_path2.join)(directory, ".git");
   if (!(0, import_node_fs.existsSync)(gitDir)) {
@@ -700,6 +759,7 @@ To fix this:
 }
 
 // src/git/tagsAndBranches.ts
+init_commandExecutor();
 function getCommitsLength(pkgRoot, sinceTag) {
   try {
     let amount;
@@ -777,28 +837,37 @@ async function getLatestTagForPackage(packageName, versionPrefix, options) {
       `Looking for tags for package ${packageName} with prefix ${versionPrefix || "none"}, packageSpecificTags: ${packageSpecificTags}`,
       "debug"
     );
-    const allTags = await (0, import_git_semver_tags.getSemverTags)({
-      tagPrefix: versionPrefix
-    });
-    log(`Retrieved ${allTags.length} tags: ${allTags.join(", ")}`, "debug");
+    let allTags = [];
+    try {
+      const { execSync: execSync2 } = await Promise.resolve().then(() => (init_commandExecutor(), commandExecutor_exports));
+      const tagsOutput = execSync2("git", ["tag", "-l"], { cwd: process.cwd() });
+      allTags = tagsOutput.toString().trim().split("\n").filter((tag) => tag.length > 0);
+    } catch (err) {
+      log(`Error getting tags: ${err instanceof Error ? err.message : String(err)}`, "error");
+    }
+    log(`Retrieved ${allTags.length} tags`, "debug");
     if (packageSpecificTags) {
       const packageTagPattern = escapeRegExp(tagTemplate).replace(/\\\$\\\{packageName\\\}/g, `(?:${escapedPackageName})`).replace(/\\\$\\\{prefix\\\}/g, `(?:${escapedPrefix})`).replace(/\\\$\\\{version\\\}/g, "(?:[0-9]+\\.[0-9]+\\.[0-9]+(?:-[a-zA-Z0-9.-]+)?)");
       log(`Using package tag pattern: ${packageTagPattern}`, "debug");
       const packageTagRegex = new RegExp(`^${packageTagPattern}$`);
       let packageTags = allTags.filter((tag) => packageTagRegex.test(tag));
+      log(`Found ${packageTags.length} matching tags for ${packageName}`, "debug");
       if (packageTags.length > 0) {
         const chronologicalFirst = packageTags[0];
+        void chronologicalFirst;
         const sortedPackageTags2 = [...packageTags].sort((a, b) => {
           let versionA = "";
           let versionB = "";
           if (a.includes("@")) {
-            const afterAt = a.split("@")[1] || "";
+            const parts = a.split("@");
+            const afterAt = parts[parts.length - 1] || "";
             versionA = afterAt.replace(new RegExp(`^${escapeRegExp(versionPrefix || "")}`), "");
           } else {
             versionA = a.replace(new RegExp(`^${escapeRegExp(packageName)}`), "").replace(new RegExp(`^${escapeRegExp(versionPrefix || "")}`), "");
           }
           if (b.includes("@")) {
-            const afterAtB = b.split("@")[1] || "";
+            const parts = b.split("@");
+            const afterAtB = parts[parts.length - 1] || "";
             versionB = afterAtB.replace(new RegExp(`^${escapeRegExp(versionPrefix || "")}`), "");
           } else {
             versionB = b.replace(new RegExp(`^${escapeRegExp(packageName)}`), "").replace(new RegExp(`^${escapeRegExp(versionPrefix || "")}`), "");
@@ -809,12 +878,6 @@ async function getLatestTagForPackage(packageName, versionPrefix, options) {
         });
         log(`Found ${packageTags.length} package tags using configured pattern`, "debug");
         log(`Using semantically latest tag: ${sortedPackageTags2[0]}`, "debug");
-        if (sortedPackageTags2[0] !== chronologicalFirst) {
-          log(
-            `Package tag ordering differs: chronological first is ${chronologicalFirst}, semantic latest is ${sortedPackageTags2[0]}`,
-            "debug"
-          );
-        }
         return sortedPackageTags2[0];
       }
       if (versionPrefix) {
@@ -822,9 +885,11 @@ async function getLatestTagForPackage(packageName, versionPrefix, options) {
         packageTags = allTags.filter((tag) => pattern1.test(tag));
         if (packageTags.length > 0) {
           const sortedPackageTags2 = [...packageTags].sort((a, b) => {
-            const afterAt = a.split("@")[1] || "";
+            const aParts = a.split("@");
+            const afterAt = aParts[aParts.length - 1] || "";
             const versionA = afterAt.replace(new RegExp(`^${escapeRegExp(versionPrefix || "")}`), "");
-            const afterAtB = b.split("@")[1] || "";
+            const bParts = b.split("@");
+            const afterAtB = bParts[bParts.length - 1] || "";
             const versionB = afterAtB.replace(new RegExp(`^${escapeRegExp(versionPrefix || "")}`), "");
             const cleanVersionA = import_semver.default.clean(versionA) || "0.0.0";
             const cleanVersionB = import_semver.default.clean(versionB) || "0.0.0";
@@ -840,8 +905,10 @@ async function getLatestTagForPackage(packageName, versionPrefix, options) {
         packageTags = allTags.filter((tag) => pattern2.test(tag));
         if (packageTags.length > 0) {
           const sortedPackageTags2 = [...packageTags].sort((a, b) => {
-            const versionA = import_semver.default.clean(a.split("@")[1] || "") || "0.0.0";
-            const versionB = import_semver.default.clean(b.split("@")[1] || "") || "0.0.0";
+            const aParts = a.split("@");
+            const versionA = import_semver.default.clean(aParts[aParts.length - 1] || "") || "0.0.0";
+            const bParts = b.split("@");
+            const versionB = import_semver.default.clean(bParts[bParts.length - 1] || "") || "0.0.0";
             return import_semver.default.rcompare(versionA, versionB);
           });
           log(`Found ${packageTags.length} package tags using pattern: ${versionPrefix}packageName@...`, "debug");
@@ -861,8 +928,10 @@ async function getLatestTagForPackage(packageName, versionPrefix, options) {
         return "";
       }
       const sortedPackageTags = [...packageTags].sort((a, b) => {
-        const versionA = import_semver.default.clean(a.split("@")[1] || "") || "0.0.0";
-        const versionB = import_semver.default.clean(b.split("@")[1] || "") || "0.0.0";
+        const aParts = a.split("@");
+        const versionA = import_semver.default.clean(aParts[aParts.length - 1] || "") || "0.0.0";
+        const bParts = b.split("@");
+        const versionB = import_semver.default.clean(bParts[bParts.length - 1] || "") || "0.0.0";
         return import_semver.default.rcompare(versionA, versionB);
       });
       log(`Found ${packageTags.length} package tags for ${packageName}`, "debug");
@@ -1039,6 +1108,7 @@ var import_config3 = require("@releasekit/config");
 var import_semver2 = __toESM(require("semver"), 1);
 
 // src/git/tagVerification.ts
+init_commandExecutor();
 function verifyTag(tagName, cwd4) {
   if (!tagName || tagName.trim() === "") {
     return { exists: false, reachable: false, error: "Empty tag name" };
@@ -1142,12 +1212,17 @@ var VersionMismatchError = class extends Error {
     this.name = "VersionMismatchError";
   }
 };
-async function getBestVersionSource(tagName, packageVersion, cwd4, mismatchStrategy = "error") {
+async function getBestVersionSource(tagName, packageVersion, cwd4, mismatchStrategy = "error", strictReachable = false) {
   if (!tagName?.trim()) {
     return packageVersion ? { source: "package", version: packageVersion, reason: "No git tag provided" } : { source: "initial", version: "0.1.0", reason: "No git tag or package version available" };
   }
   const verification = verifyTag(tagName, cwd4);
   if (!verification.exists || !verification.reachable) {
+    if (strictReachable) {
+      throw new Error(
+        `Git tag '${tagName}' is not reachable from the current commit. The tag exists but cannot be reached from HEAD, which usually means you're on a different branch or the tag is orphaned. To allow fallback to package version, set strictReachable to false in your configuration.`
+      );
+    }
     if (packageVersion) {
       log(
         `Git tag '${tagName}' unreachable (${verification.error}), using package version: ${packageVersion}`,
@@ -1253,7 +1328,8 @@ async function calculateVersion(config, options) {
     prereleaseIdentifier: configPrereleaseIdentifier,
     branchPattern,
     baseBranch,
-    mismatchStrategy
+    mismatchStrategy,
+    strictReachable
   } = config;
   const {
     latestTag,
@@ -1298,7 +1374,13 @@ async function calculateVersion(config, options) {
       const packageDir = pkgPath || (0, import_node_process2.cwd)();
       const manifestResult = getVersionFromManifests(packageDir);
       const packageVersion = manifestResult.manifestFound && manifestResult.version ? manifestResult.version : void 0;
-      versionSource = await getBestVersionSource(latestTag, packageVersion, packageDir, mismatchStrategy);
+      versionSource = await getBestVersionSource(
+        latestTag,
+        packageVersion,
+        packageDir,
+        mismatchStrategy,
+        strictReachable
+      );
       log(`Using version source: ${versionSource.source} (${versionSource.reason})`, "info");
     }
     const specifiedType = type;
@@ -1540,6 +1622,11 @@ var PackageProcessor = class {
           if (verification.exists && verification.reachable) {
             revisionRange = `${latestTag}..HEAD`;
           } else {
+            if (this.config.strictReachable) {
+              throw new Error(
+                `Cannot generate changelog: tag '${latestTag}' is not reachable from the current commit. When strictReachable is enabled, all tags must be reachable. To allow fallback to all commits, set strictReachable to false.`
+              );
+            }
             log(`Tag ${latestTag} is unreachable (${verification.error}), using all commits for changelog`, "debug");
             revisionRange = "HEAD";
           }
@@ -1547,6 +1634,14 @@ var PackageProcessor = class {
           revisionRange = "HEAD";
         }
         changelogEntries = extractChangelogEntriesFromCommits(pkgPath, revisionRange);
+        const allCommitsWithHash = extractAllChangelogEntriesWithHash(pkgPath, revisionRange);
+        const packageCommitsWithHash = extractChangelogEntriesWithHash(pkgPath, revisionRange);
+        const packageCommitHashes = new Set(packageCommitsWithHash.map((c) => c.hash));
+        const globalCommits = allCommitsWithHash.filter((c) => !packageCommitHashes.has(c.hash)).map((c) => c.entry);
+        if (globalCommits.length > 0) {
+          log(`Adding ${globalCommits.length} global commit(s) to ${name} changelog`, "debug");
+          changelogEntries = [...globalCommits, ...changelogEntries];
+        }
         if (changelogEntries.length === 0) {
           changelogEntries = [
             {
@@ -1855,6 +1950,11 @@ function createSyncStrategy(config) {
             });
             revisionRange = `${latestTag}..HEAD`;
           } catch {
+            if (config.strictReachable) {
+              throw new Error(
+                `Cannot generate changelog: tag '${latestTag}' is not reachable from the current commit. When strictReachable is enabled, all tags must be reachable. To allow fallback to all commits, set strictReachable to false.`
+              );
+            }
             log(`Tag ${latestTag} doesn't exist, using all commits for changelog`, "debug");
             revisionRange = "HEAD";
           }
@@ -1974,6 +2074,11 @@ function createSingleStrategy(config) {
             });
             revisionRange = `${latestTag}..HEAD`;
           } catch {
+            if (config.strictReachable) {
+              throw new Error(
+                `Cannot generate changelog: tag '${latestTag}' is not reachable from the current commit. When strictReachable is enabled, all tags must be reachable. To allow fallback to all commits, set strictReachable to false.`
+              );
+            }
             log(`Tag ${latestTag} doesn't exist, using all commits for changelog`, "debug");
             revisionRange = "HEAD";
           }

package/dist/cli.js

@@ -5,8 +5,9 @@ import {
   loadConfig,
   log,
   printJsonOutput
-} from "./chunk-3JG7UWIT.js";
+} from "./chunk-DXDB5P7S.js";
 import "./chunk-GQLJ7JQY.js";
+import "./chunk-LMPZV35Z.js";
 
 // src/cli.ts
 import * as fs from "fs";

package/dist/commandExecutor-E44ID5U4.js

@@ -0,0 +1,8 @@
+import {
+  execAsync,
+  execSync
+} from "./chunk-LMPZV35Z.js";
+export {
+  execAsync,
+  execSync
+};

package/dist/index.cjs

@@ -5,6 +5,9 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -27,6 +30,33 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
+// src/git/commandExecutor.ts
+var commandExecutor_exports = {};
+__export(commandExecutor_exports, {
+  execAsync: () => execAsync,
+  execSync: () => execSync
+});
+var import_node_child_process, execAsync, execSync;
+var init_commandExecutor = __esm({
+  "src/git/commandExecutor.ts"() {
+    "use strict";
+    import_node_child_process = require("child_process");
+    execAsync = (file, args, options) => {
+      const defaultOptions = { maxBuffer: 1024 * 1024 * 10, ...options };
+      return new Promise((resolve2, reject) => {
+        (0, import_node_child_process.execFile)(file, args, defaultOptions, (error, stdout, stderr) => {
+          if (error) {
+            reject(error);
+          } else {
+            resolve2({ stdout: stdout.toString(), stderr: stderr.toString() });
+          }
+        });
+      });
+    };
+    execSync = (file, args, options) => (0, import_node_child_process.execFileSync)(file, args, { maxBuffer: 1024 * 1024 * 10, ...options });
+  }
+});
+
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
@@ -100,24 +130,7 @@ var import_semver3 = __toESM(require("semver"), 1);
 // src/git/repository.ts
 var import_node_fs = require("fs");
 var import_node_path = require("path");
-
-// src/git/commandExecutor.ts
-var import_node_child_process = require("child_process");
-var execAsync = (file, args, options) => {
-  const defaultOptions = { maxBuffer: 1024 * 1024 * 10, ...options };
-  return new Promise((resolve2, reject) => {
-    (0, import_node_child_process.execFile)(file, args, defaultOptions, (error, stdout, stderr) => {
-      if (error) {
-        reject(error);
-      } else {
-        resolve2({ stdout: stdout.toString(), stderr: stderr.toString() });
-      }
-    });
-  });
-};
-var execSync = (file, args, options) => (0, import_node_child_process.execFileSync)(file, args, { maxBuffer: 1024 * 1024 * 10, ...options });
-
-// src/git/repository.ts
+init_commandExecutor();
 function isGitRepository(directory) {
   const gitDir = (0, import_node_path.join)(directory, ".git");
   if (!(0, import_node_fs.existsSync)(gitDir)) {
@@ -280,6 +293,7 @@ To fix this:
 }
 
 // src/git/tagsAndBranches.ts
+init_commandExecutor();
 function getCommitsLength(pkgRoot, sinceTag) {
   try {
     let amount;
@@ -357,28 +371,37 @@ async function getLatestTagForPackage(packageName, versionPrefix, options) {
       `Looking for tags for package ${packageName} with prefix ${versionPrefix || "none"}, packageSpecificTags: ${packageSpecificTags}`,
       "debug"
     );
-    const allTags = await (0, import_git_semver_tags.getSemverTags)({
-      tagPrefix: versionPrefix
-    });
-    log(`Retrieved ${allTags.length} tags: ${allTags.join(", ")}`, "debug");
+    let allTags = [];
+    try {
+      const { execSync: execSync2 } = await Promise.resolve().then(() => (init_commandExecutor(), commandExecutor_exports));
+      const tagsOutput = execSync2("git", ["tag", "-l"], { cwd: process.cwd() });
+      allTags = tagsOutput.toString().trim().split("\n").filter((tag) => tag.length > 0);
+    } catch (err) {
+      log(`Error getting tags: ${err instanceof Error ? err.message : String(err)}`, "error");
+    }
+    log(`Retrieved ${allTags.length} tags`, "debug");
     if (packageSpecificTags) {
       const packageTagPattern = escapeRegExp(tagTemplate).replace(/\\\$\\\{packageName\\\}/g, `(?:${escapedPackageName})`).replace(/\\\$\\\{prefix\\\}/g, `(?:${escapedPrefix})`).replace(/\\\$\\\{version\\\}/g, "(?:[0-9]+\\.[0-9]+\\.[0-9]+(?:-[a-zA-Z0-9.-]+)?)");
       log(`Using package tag pattern: ${packageTagPattern}`, "debug");
       const packageTagRegex = new RegExp(`^${packageTagPattern}$`);
       let packageTags = allTags.filter((tag) => packageTagRegex.test(tag));
+      log(`Found ${packageTags.length} matching tags for ${packageName}`, "debug");
       if (packageTags.length > 0) {
         const chronologicalFirst = packageTags[0];
+        void chronologicalFirst;
         const sortedPackageTags2 = [...packageTags].sort((a, b) => {
           let versionA = "";
           let versionB = "";
           if (a.includes("@")) {
-            const afterAt = a.split("@")[1] || "";
+            const parts = a.split("@");
+            const afterAt = parts[parts.length - 1] || "";
             versionA = afterAt.replace(new RegExp(`^${escapeRegExp(versionPrefix || "")}`), "");
           } else {
             versionA = a.replace(new RegExp(`^${escapeRegExp(packageName)}`), "").replace(new RegExp(`^${escapeRegExp(versionPrefix || "")}`), "");
           }
           if (b.includes("@")) {
-            const afterAtB = b.split("@")[1] || "";
+            const parts = b.split("@");
+            const afterAtB = parts[parts.length - 1] || "";
             versionB = afterAtB.replace(new RegExp(`^${escapeRegExp(versionPrefix || "")}`), "");
           } else {
             versionB = b.replace(new RegExp(`^${escapeRegExp(packageName)}`), "").replace(new RegExp(`^${escapeRegExp(versionPrefix || "")}`), "");
@@ -389,12 +412,6 @@ async function getLatestTagForPackage(packageName, versionPrefix, options) {
         });
         log(`Found ${packageTags.length} package tags using configured pattern`, "debug");
         log(`Using semantically latest tag: ${sortedPackageTags2[0]}`, "debug");
-        if (sortedPackageTags2[0] !== chronologicalFirst) {
-          log(
-            `Package tag ordering differs: chronological first is ${chronologicalFirst}, semantic latest is ${sortedPackageTags2[0]}`,
-            "debug"
-          );
-        }
         return sortedPackageTags2[0];
       }
       if (versionPrefix) {
@@ -402,9 +419,11 @@ async function getLatestTagForPackage(packageName, versionPrefix, options) {
         packageTags = allTags.filter((tag) => pattern1.test(tag));
         if (packageTags.length > 0) {
           const sortedPackageTags2 = [...packageTags].sort((a, b) => {
-            const afterAt = a.split("@")[1] || "";
+            const aParts = a.split("@");
+            const afterAt = aParts[aParts.length - 1] || "";
             const versionA = afterAt.replace(new RegExp(`^${escapeRegExp(versionPrefix || "")}`), "");
-            const afterAtB = b.split("@")[1] || "";
+            const bParts = b.split("@");
+            const afterAtB = bParts[bParts.length - 1] || "";
             const versionB = afterAtB.replace(new RegExp(`^${escapeRegExp(versionPrefix || "")}`), "");
             const cleanVersionA = import_semver.default.clean(versionA) || "0.0.0";
             const cleanVersionB = import_semver.default.clean(versionB) || "0.0.0";
@@ -420,8 +439,10 @@ async function getLatestTagForPackage(packageName, versionPrefix, options) {
         packageTags = allTags.filter((tag) => pattern2.test(tag));
         if (packageTags.length > 0) {
           const sortedPackageTags2 = [...packageTags].sort((a, b) => {
-            const versionA = import_semver.default.clean(a.split("@")[1] || "") || "0.0.0";
-            const versionB = import_semver.default.clean(b.split("@")[1] || "") || "0.0.0";
+            const aParts = a.split("@");
+            const versionA = import_semver.default.clean(aParts[aParts.length - 1] || "") || "0.0.0";
+            const bParts = b.split("@");
+            const versionB = import_semver.default.clean(bParts[bParts.length - 1] || "") || "0.0.0";
             return import_semver.default.rcompare(versionA, versionB);
           });
           log(`Found ${packageTags.length} package tags using pattern: ${versionPrefix}packageName@...`, "debug");
@@ -441,8 +462,10 @@ async function getLatestTagForPackage(packageName, versionPrefix, options) {
         return "";
       }
       const sortedPackageTags = [...packageTags].sort((a, b) => {
-        const versionA = import_semver.default.clean(a.split("@")[1] || "") || "0.0.0";
-        const versionB = import_semver.default.clean(b.split("@")[1] || "") || "0.0.0";
+        const aParts = a.split("@");
+        const versionA = import_semver.default.clean(aParts[aParts.length - 1] || "") || "0.0.0";
+        const bParts = b.split("@");
+        const versionB = import_semver.default.clean(bParts[bParts.length - 1] || "") || "0.0.0";
         return import_semver.default.rcompare(versionA, versionB);
       });
       log(`Found ${packageTags.length} package tags for ${packageName}`, "debug");
@@ -578,6 +601,7 @@ var import_config3 = require("@releasekit/config");
 var import_semver2 = __toESM(require("semver"), 1);
 
 // src/git/tagVerification.ts
+init_commandExecutor();
 function verifyTag(tagName, cwd4) {
   if (!tagName || tagName.trim() === "") {
     return { exists: false, reachable: false, error: "Empty tag name" };
@@ -681,12 +705,17 @@ var VersionMismatchError = class extends Error {
     this.name = "VersionMismatchError";
   }
 };
-async function getBestVersionSource(tagName, packageVersion, cwd4, mismatchStrategy = "error") {
+async function getBestVersionSource(tagName, packageVersion, cwd4, mismatchStrategy = "error", strictReachable = false) {
   if (!tagName?.trim()) {
     return packageVersion ? { source: "package", version: packageVersion, reason: "No git tag provided" } : { source: "initial", version: "0.1.0", reason: "No git tag or package version available" };
   }
   const verification = verifyTag(tagName, cwd4);
   if (!verification.exists || !verification.reachable) {
+    if (strictReachable) {
+      throw new Error(
+        `Git tag '${tagName}' is not reachable from the current commit. The tag exists but cannot be reached from HEAD, which usually means you're on a different branch or the tag is orphaned. To allow fallback to package version, set strictReachable to false in your configuration.`
+      );
+    }
     if (packageVersion) {
       log(
         `Git tag '${tagName}' unreachable (${verification.error}), using package version: ${packageVersion}`,
@@ -792,7 +821,8 @@ async function calculateVersion(config, options) {
     prereleaseIdentifier: configPrereleaseIdentifier,
     branchPattern,
     baseBranch,
-    mismatchStrategy
+    mismatchStrategy,
+    strictReachable
   } = config;
   const {
     latestTag,
@@ -837,7 +867,13 @@ async function calculateVersion(config, options) {
       const packageDir = pkgPath || (0, import_node_process.cwd)();
       const manifestResult = getVersionFromManifests(packageDir);
       const packageVersion = manifestResult.manifestFound && manifestResult.version ? manifestResult.version : void 0;
-      versionSource = await getBestVersionSource(latestTag, packageVersion, packageDir, mismatchStrategy);
+      versionSource = await getBestVersionSource(
+        latestTag,
+        packageVersion,
+        packageDir,
+        mismatchStrategy,
+        strictReachable
+      );
       log(`Using version source: ${versionSource.source} (${versionSource.reason})`, "info");
     }
     const specifiedType = type;
@@ -1129,14 +1165,59 @@ var import_node_fs6 = __toESM(require("fs"), 1);
 var path6 = __toESM(require("path"), 1);
 
 // src/changelog/commitParser.ts
+init_commandExecutor();
 var CONVENTIONAL_COMMIT_REGEX = /^(\w+)(?:\(([^)]+)\))?(!)?: (.+)(?:\n\n([\s\S]*))?/;
 var BREAKING_CHANGE_REGEX = /BREAKING CHANGE: ([\s\S]+?)(?:\n\n|$)/;
+function extractChangelogEntriesWithHash(projectDir, revisionRange) {
+  try {
+    const args = ["log", revisionRange, "--pretty=format:%H|||%B---COMMIT_DELIMITER---", "--no-merges", "--", "."];
+    const output = execSync("git", args, { cwd: projectDir, encoding: "utf8" }).toString();
+    const commits = output.split("---COMMIT_DELIMITER---").filter((commit) => commit.trim() !== "");
+    return commits.map((commit) => {
+      const [hash, ...messageParts] = commit.split("|||");
+      const message = messageParts.join("|||").trim();
+      const entry = parseCommitMessage(message);
+      if (entry && hash) {
+        return { hash: hash.trim(), entry };
+      }
+      return null;
+    }).filter((item) => item !== null);
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    log(`Error extracting commits with hash: ${errorMessage}`, "error");
+    return [];
+  }
+}
+function extractAllChangelogEntriesWithHash(projectDir, revisionRange) {
+  try {
+    const args = ["log", revisionRange, "--pretty=format:%H|||%B---COMMIT_DELIMITER---", "--no-merges"];
+    const output = execSync("git", args, { cwd: projectDir, encoding: "utf8" }).toString();
+    const commits = output.split("---COMMIT_DELIMITER---").filter((commit) => commit.trim() !== "");
+    return commits.map((commit) => {
+      const [hash, ...messageParts] = commit.split("|||");
+      const message = messageParts.join("|||").trim();
+      const entry = parseCommitMessage(message);
+      if (entry && hash) {
+        return { hash: hash.trim(), entry };
+      }
+      return null;
+    }).filter((item) => item !== null);
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    log(`Error extracting all commits with hash: ${errorMessage}`, "error");
+    return [];
+  }
+}
 function extractChangelogEntriesFromCommits(projectDir, revisionRange) {
+  return extractCommitsFromGitLog(projectDir, revisionRange, true);
+}
+function extractCommitsFromGitLog(projectDir, revisionRange, filterToPath) {
   try {
-    const output = execSync("git", ["log", revisionRange, "--pretty=format:%B---COMMIT_DELIMITER---", "--no-merges"], {
-      cwd: projectDir,
-      encoding: "utf8"
-    }).toString();
+    const args = ["log", revisionRange, "--pretty=format:%B---COMMIT_DELIMITER---", "--no-merges"];
+    if (filterToPath) {
+      args.push("--", ".");
+    }
+    const output = execSync("git", args, { cwd: projectDir, encoding: "utf8" }).toString();
     const commits = output.split("---COMMIT_DELIMITER---").filter((commit) => commit.trim() !== "");
     return commits.map((commit) => parseCommitMessage(commit)).filter((entry) => entry !== null);
   } catch (error) {
@@ -1229,8 +1310,12 @@ function extractIssueIds(body) {
   return issueIds;
 }
 
+// src/core/versionStrategies.ts
+init_commandExecutor();
+
 // src/git/commands.ts
 var import_node_process2 = require("process");
+init_commandExecutor();
 async function gitAdd(files) {
   return execAsync("git", ["add", ...files]);
 }
@@ -1535,6 +1620,11 @@ var PackageProcessor = class {
           if (verification.exists && verification.reachable) {
             revisionRange = `${latestTag}..HEAD`;
           } else {
+            if (this.config.strictReachable) {
+              throw new Error(
+                `Cannot generate changelog: tag '${latestTag}' is not reachable from the current commit. When strictReachable is enabled, all tags must be reachable. To allow fallback to all commits, set strictReachable to false.`
+              );
+            }
             log(`Tag ${latestTag} is unreachable (${verification.error}), using all commits for changelog`, "debug");
             revisionRange = "HEAD";
           }
@@ -1542,6 +1632,14 @@ var PackageProcessor = class {
           revisionRange = "HEAD";
         }
         changelogEntries = extractChangelogEntriesFromCommits(pkgPath, revisionRange);
+        const allCommitsWithHash = extractAllChangelogEntriesWithHash(pkgPath, revisionRange);
+        const packageCommitsWithHash = extractChangelogEntriesWithHash(pkgPath, revisionRange);
+        const packageCommitHashes = new Set(packageCommitsWithHash.map((c) => c.hash));
+        const globalCommits = allCommitsWithHash.filter((c) => !packageCommitHashes.has(c.hash)).map((c) => c.entry);
+        if (globalCommits.length > 0) {
+          log(`Adding ${globalCommits.length} global commit(s) to ${name} changelog`, "debug");
+          changelogEntries = [...globalCommits, ...changelogEntries];
+        }
         if (changelogEntries.length === 0) {
           changelogEntries = [
             {
@@ -1850,6 +1948,11 @@ function createSyncStrategy(config) {
             });
             revisionRange = `${latestTag}..HEAD`;
           } catch {
+            if (config.strictReachable) {
+              throw new Error(
+                `Cannot generate changelog: tag '${latestTag}' is not reachable from the current commit. When strictReachable is enabled, all tags must be reachable. To allow fallback to all commits, set strictReachable to false.`
+              );
+            }
             log(`Tag ${latestTag} doesn't exist, using all commits for changelog`, "debug");
             revisionRange = "HEAD";
           }
@@ -1969,6 +2072,11 @@ function createSingleStrategy(config) {
             });
             revisionRange = `${latestTag}..HEAD`;
           } catch {
+            if (config.strictReachable) {
+              throw new Error(
+                `Cannot generate changelog: tag '${latestTag}' is not reachable from the current commit. When strictReachable is enabled, all tags must be reachable. To allow fallback to all commits, set strictReachable to false.`
+              );
+            }
             log(`Tag ${latestTag} doesn't exist, using all commits for changelog`, "debug");
             revisionRange = "HEAD";
           }

package/dist/index.d.cts

@@ -11,6 +11,7 @@ interface VersionConfigBase {
     baseBranch?: string;
     path?: string;
     name?: string;
+    strictReachable?: boolean;
 }
 interface Config extends VersionConfigBase {
     tagTemplate: string;
@@ -30,6 +31,7 @@ interface Config extends VersionConfigBase {
     latestTag?: string;
     isPrerelease?: boolean;
     mismatchStrategy?: 'error' | 'warn' | 'ignore' | 'prefer-package' | 'prefer-git';
+    strictReachable?: boolean;
     cargo?: {
         enabled?: boolean;
         paths?: string[];

package/dist/index.d.ts

@@ -11,6 +11,7 @@ interface VersionConfigBase {
     baseBranch?: string;
     path?: string;
     name?: string;
+    strictReachable?: boolean;
 }
 interface Config extends VersionConfigBase {
     tagTemplate: string;
@@ -30,6 +31,7 @@ interface Config extends VersionConfigBase {
     latestTag?: string;
     isPrerelease?: boolean;
     mismatchStrategy?: 'error' | 'warn' | 'ignore' | 'prefer-package' | 'prefer-git';
+    strictReachable?: boolean;
     cargo?: {
         enabled?: boolean;
         paths?: string[];

package/dist/index.js

@@ -10,10 +10,11 @@ import {
   enableJsonOutput,
   getJsonData,
   loadConfig
-} from "./chunk-3JG7UWIT.js";
+} from "./chunk-DXDB5P7S.js";
 import {
   BaseVersionError
 } from "./chunk-GQLJ7JQY.js";
+import "./chunk-LMPZV35Z.js";
 export {
   BaseVersionError,
   PackageProcessor,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@releasekit/version",
-  "version": "0.2.0-next.1",
+  "version": "0.2.0-next.10",
   "description": "Semantic versioning based on Git history and conventional commits",
   "type": "module",
   "main": "./dist/index.cjs",