package-versioner 0.7.2 → 0.8.1

package/README.md

@@ -58,6 +58,9 @@ npx package-versioner -t @scope/package-a,@scope/package-b
 # Perform a dry run: calculates version, logs actions, but makes no file changes or Git commits/tags
 npx package-versioner --dry-run
 
+# Only use reachable tags (Git-semantic mode, no fallback to unreachable tags)
+npx package-versioner --strict-reachable
+
 # Output results as JSON (useful for CI/CD scripts)
 npx package-versioner --json
 
@@ -67,6 +70,26 @@ npx package-versioner --dry-run --json
 
 **Note on Targeting:** Using the `-t` flag creates package-specific tags (e.g., `@scope/package-a@1.2.0`) but *not* a global tag (like `v1.2.0`). If needed, create the global tag manually in your CI/CD script after this command.
 
+### Git Tag Reachability
+
+By default, `package-versioner` intelligently handles Git tag reachability to provide the best user experience:
+
+- **Default behavior**: Uses reachable tags when available, but falls back to the latest repository tag if needed (common in feature branches)
+- **Strict mode (`--strict-reachable`)**: Only uses tags reachable from the current commit, following strict Git semantics
+
+This is particularly useful when working on feature branches that have diverged from the main branch where newer tags exist. The tool will automatically detect the Git context and provide helpful guidance:
+
+```bash
+# On a feature branch with unreachable tags
+npx package-versioner --dry-run
+# Output: "No tags reachable from current branch 'feature-x'. Using latest repository tag v1.2.3 as version base."
+# Tip: Consider 'git merge main' or 'git rebase main' to include tag history in your branch.
+
+# Force strict Git semantics
+npx package-versioner --dry-run --strict-reachable
+# Output: Uses only reachable tags, may result in "No reachable tags found"
+```
+
 ## JSON Output
 
 When using the `--json` flag, normal console output is suppressed and the tool outputs a structured JSON object that includes information about the versioning operation.
@@ -103,6 +126,7 @@ Customize behaviour by creating a `version.config.json` file in your project roo
   "commitMessage": "chore: release ${packageName}@${version} [skip ci]",
   "updateChangelog": true,
   "changelogFormat": "keep-a-changelog",
+  "strictReachable": false,
   "synced": true,
   "skip": [
     "docs",
@@ -126,6 +150,7 @@ Customize behaviour by creating a `version.config.json` file in your project roo
 - `commitMessage`: Template for commit messages (default: "chore(release): ${version}")
 - `updateChangelog`: Whether to automatically update changelogs (default: true)
 - `changelogFormat`: Format for changelogs - "keep-a-changelog" or "angular" (default: "keep-a-changelog")
+- `strictReachable`: Only use reachable tags, no fallback to unreachable tags (default: false)
 - `cargo`: Options for Rust projects:
   - `enabled`: Whether to handle Cargo.toml files (default: true)
   - `paths`: Directories to search for Cargo.toml files (optional)

package/dist/index.cjs

@@ -799,6 +799,7 @@ async function createGitCommitAndTag(files, nextTag, commitMessage, skipHooks, d
 
 // src/git/tagsAndBranches.ts
 var import_git_semver_tags = require("git-semver-tags");
+var import_semver = __toESM(require("semver"), 1);
 
 // src/utils/formatting.ts
 function escapeRegExp(string) {
@@ -854,10 +855,29 @@ function getCommitsLength(pkgRoot) {
     return 0;
   }
 }
-async function getLatestTag() {
+async function getLatestTag(versionPrefix) {
   try {
-    const tags = await (0, import_git_semver_tags.getSemverTags)({});
-    return tags[0] || "";
+    const tags = await (0, import_git_semver_tags.getSemverTags)({
+      tagPrefix: versionPrefix
+    });
+    if (tags.length === 0) {
+      return "";
+    }
+    const chronologicalLatest = tags[0];
+    const sortedTags = [...tags].sort((a, b) => {
+      const versionA = import_semver.default.clean(a) || "0.0.0";
+      const versionB = import_semver.default.clean(b) || "0.0.0";
+      return import_semver.default.rcompare(versionA, versionB);
+    });
+    const semanticLatest = sortedTags[0];
+    if (semanticLatest !== chronologicalLatest) {
+      log(
+        `Tag ordering differs: chronological latest is ${chronologicalLatest}, semantic latest is ${semanticLatest}`,
+        "debug"
+      );
+      log(`Using semantic latest (${semanticLatest}) to handle out-of-order tag creation`, "info");
+    }
+    return semanticLatest;
   } catch (error) {
     const errorMessage = error instanceof Error ? error.message : String(error);
     log(`Failed to get latest tag: ${errorMessage}`, "error");
@@ -902,37 +922,82 @@ async function getLatestTagForPackage(packageName, versionPrefix, options) {
       const packageTagRegex = new RegExp(`^${packageTagPattern}$`);
       let packageTags = allTags.filter((tag) => packageTagRegex.test(tag));
       if (packageTags.length > 0) {
+        const chronologicalFirst = packageTags[0];
+        const sortedPackageTags2 = [...packageTags].sort((a, b) => {
+          let versionA = "";
+          let versionB = "";
+          if (a.includes("@")) {
+            const afterAt = a.split("@")[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] || "";
+            versionB = afterAtB.replace(new RegExp(`^${escapeRegExp(versionPrefix || "")}`), "");
+          } else {
+            versionB = b.replace(new RegExp(`^${escapeRegExp(packageName)}`), "").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";
+          return import_semver.default.rcompare(cleanVersionA, cleanVersionB);
+        });
         log(`Found ${packageTags.length} package tags using configured pattern`, "debug");
-        log(`Using tag: ${packageTags[0]}`, "debug");
-        return packageTags[0];
+        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) {
         const pattern1 = new RegExp(`^${escapedPackageName}@${escapeRegExp(versionPrefix)}`);
         packageTags = allTags.filter((tag) => pattern1.test(tag));
         if (packageTags.length > 0) {
+          const sortedPackageTags2 = [...packageTags].sort((a, b) => {
+            const afterAt = a.split("@")[1] || "";
+            const versionA = afterAt.replace(
+              new RegExp(`^${escapeRegExp(versionPrefix || "")}`),
+              ""
+            );
+            const afterAtB = b.split("@")[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";
+            return import_semver.default.rcompare(cleanVersionA, cleanVersionB);
+          });
           log(
             `Found ${packageTags.length} package tags using pattern: packageName@${versionPrefix}...`,
             "debug"
           );
-          log(`Using tag: ${packageTags[0]}`, "debug");
-          return packageTags[0];
+          log(`Using semantically latest tag: ${sortedPackageTags2[0]}`, "debug");
+          return sortedPackageTags2[0];
         }
       }
       if (versionPrefix) {
         const pattern2 = new RegExp(`^${escapeRegExp(versionPrefix)}${escapedPackageName}@`);
         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";
+            return import_semver.default.rcompare(versionA, versionB);
+          });
           log(
             `Found ${packageTags.length} package tags using pattern: ${versionPrefix}packageName@...`,
             "debug"
           );
-          log(`Using tag: ${packageTags[0]}`, "debug");
-          return packageTags[0];
+          log(`Using semantically latest tag: ${sortedPackageTags2[0]}`, "debug");
+          return sortedPackageTags2[0];
         }
       }
       const pattern3 = new RegExp(`^${escapedPackageName}@`);
       packageTags = allTags.filter((tag) => pattern3.test(tag));
-      log(`Found ${packageTags.length} package tags for ${packageName}`, "debug");
       if (packageTags.length === 0) {
         log("No matching tags found for pattern: packageName@version", "debug");
         if (allTags.length > 0) {
@@ -940,10 +1005,16 @@ async function getLatestTagForPackage(packageName, versionPrefix, options) {
         } else {
           log("No tags available in the repository", "debug");
         }
-      } else {
-        log(`Using tag: ${packageTags[0]}`, "debug");
+        return "";
       }
-      return packageTags[0] || "";
+      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";
+        return import_semver.default.rcompare(versionA, versionB);
+      });
+      log(`Found ${packageTags.length} package tags for ${packageName}`, "debug");
+      log(`Using semantically latest tag: ${sortedPackageTags[0]}`, "debug");
+      return sortedPackageTags[0];
     }
     log(`Package-specific tags disabled for ${packageName}, falling back to global tags`, "debug");
     return "";
@@ -1049,6 +1120,7 @@ function updatePackageVersion(packagePath, version) {
 }
 
 // src/package/packageProcessor.ts
+var import_node_child_process4 = require("child_process");
 var fs8 = __toESM(require("fs"), 1);
 var import_node_path6 = __toESM(require("path"), 1);
 var import_node_process4 = require("process");
@@ -1381,7 +1453,7 @@ function capitalizeFirstLetter(input) {
 // src/core/versionCalculator.ts
 var import_node_process3 = require("process");
 var import_conventional_recommended_bump = require("conventional-recommended-bump");
-var import_semver2 = __toESM(require("semver"), 1);
+var import_semver3 = __toESM(require("semver"), 1);
 
 // src/utils/manifestHelpers.ts
 var import_node_fs5 = __toESM(require("fs"), 1);
@@ -1442,7 +1514,7 @@ function throwIfNoManifestsFound(packageDir) {
 
 // src/utils/versionUtils.ts
 var import_node_fs6 = __toESM(require("fs"), 1);
-var import_semver = __toESM(require("semver"), 1);
+var import_semver2 = __toESM(require("semver"), 1);
 var TOML2 = __toESM(require("smol-toml"), 1);
 var STANDARD_BUMP_TYPES = ["major", "minor", "patch"];
 function normalizePrereleaseIdentifier(prereleaseIdentifier, config) {
@@ -1455,27 +1527,27 @@ function normalizePrereleaseIdentifier(prereleaseIdentifier, config) {
   return void 0;
 }
 function bumpVersion(currentVersion, bumpType, prereleaseIdentifier) {
-  if (prereleaseIdentifier && STANDARD_BUMP_TYPES.includes(bumpType) && !import_semver.default.prerelease(currentVersion)) {
+  if (prereleaseIdentifier && STANDARD_BUMP_TYPES.includes(bumpType) && !import_semver2.default.prerelease(currentVersion)) {
     const preBumpType = `pre${bumpType}`;
     log(
       `Creating prerelease version with identifier '${prereleaseIdentifier}' using ${preBumpType}`,
       "debug"
     );
-    return import_semver.default.inc(currentVersion, preBumpType, prereleaseIdentifier) || "";
+    return import_semver2.default.inc(currentVersion, preBumpType, prereleaseIdentifier) || "";
   }
-  if (import_semver.default.prerelease(currentVersion) && STANDARD_BUMP_TYPES.includes(bumpType)) {
-    const parsed = import_semver.default.parse(currentVersion);
+  if (import_semver2.default.prerelease(currentVersion) && STANDARD_BUMP_TYPES.includes(bumpType)) {
+    const parsed = import_semver2.default.parse(currentVersion);
     if (!parsed) {
-      return import_semver.default.inc(currentVersion, bumpType) || "";
+      return import_semver2.default.inc(currentVersion, bumpType) || "";
     }
     if (bumpType === "major" && parsed.minor === 0 && parsed.patch === 0 || bumpType === "minor" && parsed.patch === 0 || bumpType === "patch") {
       log(`Cleaning prerelease identifier from ${currentVersion} for ${bumpType} bump`, "debug");
       return `${parsed.major}.${parsed.minor}.${parsed.patch}`;
     }
     log(`Standard increment for ${currentVersion} with ${bumpType} bump`, "debug");
-    return import_semver.default.inc(currentVersion, bumpType) || "";
+    return import_semver2.default.inc(currentVersion, bumpType) || "";
   }
-  return import_semver.default.inc(currentVersion, bumpType, prereleaseIdentifier) || "";
+  return import_semver2.default.inc(currentVersion, bumpType, prereleaseIdentifier) || "";
 }
 
 // src/core/versionCalculator.ts
@@ -1517,10 +1589,10 @@ async function calculateVersion(config, options) {
       const packageDir = pkgPath || (0, import_node_process3.cwd)();
       const manifestResult = getVersionFromManifests(packageDir);
       if (manifestResult.manifestFound && manifestResult.version) {
-        const cleanedTag = import_semver2.default.clean(latestTag) || latestTag;
-        const tagVersion = import_semver2.default.clean(cleanedTag.replace(new RegExp(`^${escapedTagPattern}`), "")) || "0.0.0";
+        const cleanedTag = import_semver3.default.clean(latestTag) || latestTag;
+        const tagVersion = import_semver3.default.clean(cleanedTag.replace(new RegExp(`^${escapedTagPattern}`), "")) || "0.0.0";
         const packageVersion = manifestResult.version;
-        if (import_semver2.default.gt(packageVersion, tagVersion)) {
+        if (import_semver3.default.gt(packageVersion, tagVersion)) {
           log(
             `Warning: Version mismatch detected!
 \u2022 ${manifestResult.manifestType} version: ${packageVersion}
@@ -1540,7 +1612,7 @@ To fix this mismatch:
 \u2022 Or use package version as base by ensuring tags are up to date`,
             "warning"
           );
-        } else if (import_semver2.default.gt(tagVersion, packageVersion)) {
+        } else if (import_semver3.default.gt(tagVersion, packageVersion)) {
           log(
             `Warning: Version mismatch detected!
 \u2022 ${manifestResult.manifestType} version: ${packageVersion}
@@ -1576,9 +1648,9 @@ To fix this mismatch:
           initialVersion
         );
       }
-      const cleanedTag = import_semver2.default.clean(latestTag) || latestTag;
-      const currentVersion = import_semver2.default.clean(cleanedTag.replace(new RegExp(`^${escapedTagPattern}`), "")) || "0.0.0";
-      if (STANDARD_BUMP_TYPES.includes(specifiedType) && (import_semver2.default.prerelease(currentVersion) || normalizedPrereleaseId)) {
+      const cleanedTag = import_semver3.default.clean(latestTag) || latestTag;
+      const currentVersion = import_semver3.default.clean(cleanedTag.replace(new RegExp(`^${escapedTagPattern}`), "")) || "0.0.0";
+      if (STANDARD_BUMP_TYPES.includes(specifiedType) && (import_semver3.default.prerelease(currentVersion) || normalizedPrereleaseId)) {
         log(
           normalizedPrereleaseId ? `Creating prerelease version with identifier '${normalizedPrereleaseId}' using ${specifiedType}` : `Cleaning prerelease identifier from ${currentVersion} for ${specifiedType} bump`,
           "debug"
@@ -1616,8 +1688,8 @@ To fix this mismatch:
             initialVersion
           );
         }
-        const cleanedTag = import_semver2.default.clean(latestTag) || latestTag;
-        const currentVersion = import_semver2.default.clean(cleanedTag.replace(new RegExp(`^${escapedTagPattern}`), "")) || "0.0.0";
+        const cleanedTag = import_semver3.default.clean(latestTag) || latestTag;
+        const currentVersion = import_semver3.default.clean(cleanedTag.replace(new RegExp(`^${escapedTagPattern}`), "")) || "0.0.0";
         log(`Applying ${branchVersionType} bump based on branch pattern`, "debug");
         return bumpVersion(currentVersion, branchVersionType, normalizedPrereleaseId);
       }
@@ -1655,7 +1727,7 @@ To fix this mismatch:
         );
         return "";
       }
-      const currentVersion = import_semver2.default.clean(latestTag.replace(new RegExp(`^${escapedTagPattern}`), "")) || "0.0.0";
+      const currentVersion = import_semver3.default.clean(latestTag.replace(new RegExp(`^${escapedTagPattern}`), "")) || "0.0.0";
       return bumpVersion(currentVersion, releaseTypeFromCommits, normalizedPrereleaseId);
     } catch (error) {
       log(`Failed to calculate version for ${name || "project"}`, "error");
@@ -1700,7 +1772,7 @@ function calculateNextVersion(version, manifestType, name, releaseType, prerelea
     `No tags found for ${name || "package"}, using ${manifestType} version: ${version} as base`,
     "info"
   );
-  if (STANDARD_BUMP_TYPES.includes(releaseType) && (import_semver2.default.prerelease(version) || prereleaseIdentifier)) {
+  if (STANDARD_BUMP_TYPES.includes(releaseType) && (import_semver3.default.prerelease(version) || prereleaseIdentifier)) {
     log(
       prereleaseIdentifier ? `Creating prerelease version with identifier '${prereleaseIdentifier}' using ${releaseType}` : `Cleaning prerelease identifier from ${version} for ${releaseType} bump`,
       "debug"
@@ -1861,7 +1933,24 @@ var PackageProcessor = class {
       if (this.fullConfig.updateChangelog !== false) {
         let changelogEntries = [];
         try {
-          changelogEntries = extractChangelogEntriesFromCommits(pkgPath, latestTag);
+          let revisionRange = latestTag;
+          if (latestTag) {
+            try {
+              (0, import_node_child_process4.execSync)(`git rev-parse --verify "${latestTag}"`, {
+                cwd: pkgPath,
+                stdio: "ignore"
+              });
+            } catch {
+              log(
+                `Tag ${latestTag} doesn't exist, using recent commits from HEAD for changelog`,
+                "debug"
+              );
+              revisionRange = "HEAD~10..HEAD";
+            }
+          } else {
+            revisionRange = "HEAD~10..HEAD";
+          }
+          changelogEntries = extractChangelogEntriesFromCommits(pkgPath, revisionRange);
           if (changelogEntries.length === 0) {
             changelogEntries = [
               {

package/dist/index.js

@@ -766,6 +766,7 @@ async function createGitCommitAndTag(files, nextTag, commitMessage, skipHooks, d
 
 // src/git/tagsAndBranches.ts
 import { getSemverTags } from "git-semver-tags";
+import semver from "semver";
 
 // src/utils/formatting.ts
 function escapeRegExp(string) {
@@ -821,10 +822,29 @@ function getCommitsLength(pkgRoot) {
     return 0;
   }
 }
-async function getLatestTag() {
+async function getLatestTag(versionPrefix) {
   try {
-    const tags = await getSemverTags({});
-    return tags[0] || "";
+    const tags = await getSemverTags({
+      tagPrefix: versionPrefix
+    });
+    if (tags.length === 0) {
+      return "";
+    }
+    const chronologicalLatest = tags[0];
+    const sortedTags = [...tags].sort((a, b) => {
+      const versionA = semver.clean(a) || "0.0.0";
+      const versionB = semver.clean(b) || "0.0.0";
+      return semver.rcompare(versionA, versionB);
+    });
+    const semanticLatest = sortedTags[0];
+    if (semanticLatest !== chronologicalLatest) {
+      log(
+        `Tag ordering differs: chronological latest is ${chronologicalLatest}, semantic latest is ${semanticLatest}`,
+        "debug"
+      );
+      log(`Using semantic latest (${semanticLatest}) to handle out-of-order tag creation`, "info");
+    }
+    return semanticLatest;
   } catch (error) {
     const errorMessage = error instanceof Error ? error.message : String(error);
     log(`Failed to get latest tag: ${errorMessage}`, "error");
@@ -869,37 +889,82 @@ async function getLatestTagForPackage(packageName, versionPrefix, options) {
       const packageTagRegex = new RegExp(`^${packageTagPattern}$`);
       let packageTags = allTags.filter((tag) => packageTagRegex.test(tag));
       if (packageTags.length > 0) {
+        const chronologicalFirst = packageTags[0];
+        const sortedPackageTags2 = [...packageTags].sort((a, b) => {
+          let versionA = "";
+          let versionB = "";
+          if (a.includes("@")) {
+            const afterAt = a.split("@")[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] || "";
+            versionB = afterAtB.replace(new RegExp(`^${escapeRegExp(versionPrefix || "")}`), "");
+          } else {
+            versionB = b.replace(new RegExp(`^${escapeRegExp(packageName)}`), "").replace(new RegExp(`^${escapeRegExp(versionPrefix || "")}`), "");
+          }
+          const cleanVersionA = semver.clean(versionA) || "0.0.0";
+          const cleanVersionB = semver.clean(versionB) || "0.0.0";
+          return semver.rcompare(cleanVersionA, cleanVersionB);
+        });
         log(`Found ${packageTags.length} package tags using configured pattern`, "debug");
-        log(`Using tag: ${packageTags[0]}`, "debug");
-        return packageTags[0];
+        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) {
         const pattern1 = new RegExp(`^${escapedPackageName}@${escapeRegExp(versionPrefix)}`);
         packageTags = allTags.filter((tag) => pattern1.test(tag));
         if (packageTags.length > 0) {
+          const sortedPackageTags2 = [...packageTags].sort((a, b) => {
+            const afterAt = a.split("@")[1] || "";
+            const versionA = afterAt.replace(
+              new RegExp(`^${escapeRegExp(versionPrefix || "")}`),
+              ""
+            );
+            const afterAtB = b.split("@")[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";
+            return semver.rcompare(cleanVersionA, cleanVersionB);
+          });
           log(
             `Found ${packageTags.length} package tags using pattern: packageName@${versionPrefix}...`,
             "debug"
           );
-          log(`Using tag: ${packageTags[0]}`, "debug");
-          return packageTags[0];
+          log(`Using semantically latest tag: ${sortedPackageTags2[0]}`, "debug");
+          return sortedPackageTags2[0];
         }
       }
       if (versionPrefix) {
         const pattern2 = new RegExp(`^${escapeRegExp(versionPrefix)}${escapedPackageName}@`);
         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";
+            return semver.rcompare(versionA, versionB);
+          });
           log(
             `Found ${packageTags.length} package tags using pattern: ${versionPrefix}packageName@...`,
             "debug"
           );
-          log(`Using tag: ${packageTags[0]}`, "debug");
-          return packageTags[0];
+          log(`Using semantically latest tag: ${sortedPackageTags2[0]}`, "debug");
+          return sortedPackageTags2[0];
         }
       }
       const pattern3 = new RegExp(`^${escapedPackageName}@`);
       packageTags = allTags.filter((tag) => pattern3.test(tag));
-      log(`Found ${packageTags.length} package tags for ${packageName}`, "debug");
       if (packageTags.length === 0) {
         log("No matching tags found for pattern: packageName@version", "debug");
         if (allTags.length > 0) {
@@ -907,10 +972,16 @@ async function getLatestTagForPackage(packageName, versionPrefix, options) {
         } else {
           log("No tags available in the repository", "debug");
         }
-      } else {
-        log(`Using tag: ${packageTags[0]}`, "debug");
+        return "";
       }
-      return packageTags[0] || "";
+      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";
+        return semver.rcompare(versionA, versionB);
+      });
+      log(`Found ${packageTags.length} package tags for ${packageName}`, "debug");
+      log(`Using semantically latest tag: ${sortedPackageTags[0]}`, "debug");
+      return sortedPackageTags[0];
     }
     log(`Package-specific tags disabled for ${packageName}, falling back to global tags`, "debug");
     return "";
@@ -1016,6 +1087,7 @@ function updatePackageVersion(packagePath, version) {
 }
 
 // src/package/packageProcessor.ts
+import { execSync as execSync4 } from "child_process";
 import * as fs8 from "fs";
 import path6 from "path";
 import { exit } from "process";
@@ -1348,7 +1420,7 @@ function capitalizeFirstLetter(input) {
 // src/core/versionCalculator.ts
 import { cwd as cwd3 } from "process";
 import { Bumper } from "conventional-recommended-bump";
-import semver2 from "semver";
+import semver3 from "semver";
 
 // src/utils/manifestHelpers.ts
 import fs6 from "fs";
@@ -1409,7 +1481,7 @@ function throwIfNoManifestsFound(packageDir) {
 
 // src/utils/versionUtils.ts
 import fs7 from "fs";
-import semver from "semver";
+import semver2 from "semver";
 import * as TOML2 from "smol-toml";
 var STANDARD_BUMP_TYPES = ["major", "minor", "patch"];
 function normalizePrereleaseIdentifier(prereleaseIdentifier, config) {
@@ -1422,27 +1494,27 @@ function normalizePrereleaseIdentifier(prereleaseIdentifier, config) {
   return void 0;
 }
 function bumpVersion(currentVersion, bumpType, prereleaseIdentifier) {
-  if (prereleaseIdentifier && STANDARD_BUMP_TYPES.includes(bumpType) && !semver.prerelease(currentVersion)) {
+  if (prereleaseIdentifier && STANDARD_BUMP_TYPES.includes(bumpType) && !semver2.prerelease(currentVersion)) {
     const preBumpType = `pre${bumpType}`;
     log(
       `Creating prerelease version with identifier '${prereleaseIdentifier}' using ${preBumpType}`,
       "debug"
     );
-    return semver.inc(currentVersion, preBumpType, prereleaseIdentifier) || "";
+    return semver2.inc(currentVersion, preBumpType, prereleaseIdentifier) || "";
   }
-  if (semver.prerelease(currentVersion) && STANDARD_BUMP_TYPES.includes(bumpType)) {
-    const parsed = semver.parse(currentVersion);
+  if (semver2.prerelease(currentVersion) && STANDARD_BUMP_TYPES.includes(bumpType)) {
+    const parsed = semver2.parse(currentVersion);
     if (!parsed) {
-      return semver.inc(currentVersion, bumpType) || "";
+      return semver2.inc(currentVersion, bumpType) || "";
     }
     if (bumpType === "major" && parsed.minor === 0 && parsed.patch === 0 || bumpType === "minor" && parsed.patch === 0 || bumpType === "patch") {
       log(`Cleaning prerelease identifier from ${currentVersion} for ${bumpType} bump`, "debug");
       return `${parsed.major}.${parsed.minor}.${parsed.patch}`;
     }
     log(`Standard increment for ${currentVersion} with ${bumpType} bump`, "debug");
-    return semver.inc(currentVersion, bumpType) || "";
+    return semver2.inc(currentVersion, bumpType) || "";
   }
-  return semver.inc(currentVersion, bumpType, prereleaseIdentifier) || "";
+  return semver2.inc(currentVersion, bumpType, prereleaseIdentifier) || "";
 }
 
 // src/core/versionCalculator.ts
@@ -1484,10 +1556,10 @@ async function calculateVersion(config, options) {
       const packageDir = pkgPath || cwd3();
       const manifestResult = getVersionFromManifests(packageDir);
       if (manifestResult.manifestFound && manifestResult.version) {
-        const cleanedTag = semver2.clean(latestTag) || latestTag;
-        const tagVersion = semver2.clean(cleanedTag.replace(new RegExp(`^${escapedTagPattern}`), "")) || "0.0.0";
+        const cleanedTag = semver3.clean(latestTag) || latestTag;
+        const tagVersion = semver3.clean(cleanedTag.replace(new RegExp(`^${escapedTagPattern}`), "")) || "0.0.0";
         const packageVersion = manifestResult.version;
-        if (semver2.gt(packageVersion, tagVersion)) {
+        if (semver3.gt(packageVersion, tagVersion)) {
           log(
             `Warning: Version mismatch detected!
 \u2022 ${manifestResult.manifestType} version: ${packageVersion}
@@ -1507,7 +1579,7 @@ To fix this mismatch:
 \u2022 Or use package version as base by ensuring tags are up to date`,
             "warning"
           );
-        } else if (semver2.gt(tagVersion, packageVersion)) {
+        } else if (semver3.gt(tagVersion, packageVersion)) {
           log(
             `Warning: Version mismatch detected!
 \u2022 ${manifestResult.manifestType} version: ${packageVersion}
@@ -1543,9 +1615,9 @@ To fix this mismatch:
           initialVersion
         );
       }
-      const cleanedTag = semver2.clean(latestTag) || latestTag;
-      const currentVersion = semver2.clean(cleanedTag.replace(new RegExp(`^${escapedTagPattern}`), "")) || "0.0.0";
-      if (STANDARD_BUMP_TYPES.includes(specifiedType) && (semver2.prerelease(currentVersion) || normalizedPrereleaseId)) {
+      const cleanedTag = semver3.clean(latestTag) || latestTag;
+      const currentVersion = semver3.clean(cleanedTag.replace(new RegExp(`^${escapedTagPattern}`), "")) || "0.0.0";
+      if (STANDARD_BUMP_TYPES.includes(specifiedType) && (semver3.prerelease(currentVersion) || normalizedPrereleaseId)) {
         log(
           normalizedPrereleaseId ? `Creating prerelease version with identifier '${normalizedPrereleaseId}' using ${specifiedType}` : `Cleaning prerelease identifier from ${currentVersion} for ${specifiedType} bump`,
           "debug"
@@ -1583,8 +1655,8 @@ To fix this mismatch:
             initialVersion
           );
         }
-        const cleanedTag = semver2.clean(latestTag) || latestTag;
-        const currentVersion = semver2.clean(cleanedTag.replace(new RegExp(`^${escapedTagPattern}`), "")) || "0.0.0";
+        const cleanedTag = semver3.clean(latestTag) || latestTag;
+        const currentVersion = semver3.clean(cleanedTag.replace(new RegExp(`^${escapedTagPattern}`), "")) || "0.0.0";
         log(`Applying ${branchVersionType} bump based on branch pattern`, "debug");
         return bumpVersion(currentVersion, branchVersionType, normalizedPrereleaseId);
       }
@@ -1622,7 +1694,7 @@ To fix this mismatch:
         );
         return "";
       }
-      const currentVersion = semver2.clean(latestTag.replace(new RegExp(`^${escapedTagPattern}`), "")) || "0.0.0";
+      const currentVersion = semver3.clean(latestTag.replace(new RegExp(`^${escapedTagPattern}`), "")) || "0.0.0";
       return bumpVersion(currentVersion, releaseTypeFromCommits, normalizedPrereleaseId);
     } catch (error) {
       log(`Failed to calculate version for ${name || "project"}`, "error");
@@ -1667,7 +1739,7 @@ function calculateNextVersion(version, manifestType, name, releaseType, prerelea
     `No tags found for ${name || "package"}, using ${manifestType} version: ${version} as base`,
     "info"
   );
-  if (STANDARD_BUMP_TYPES.includes(releaseType) && (semver2.prerelease(version) || prereleaseIdentifier)) {
+  if (STANDARD_BUMP_TYPES.includes(releaseType) && (semver3.prerelease(version) || prereleaseIdentifier)) {
     log(
       prereleaseIdentifier ? `Creating prerelease version with identifier '${prereleaseIdentifier}' using ${releaseType}` : `Cleaning prerelease identifier from ${version} for ${releaseType} bump`,
       "debug"
@@ -1828,7 +1900,24 @@ var PackageProcessor = class {
       if (this.fullConfig.updateChangelog !== false) {
         let changelogEntries = [];
         try {
-          changelogEntries = extractChangelogEntriesFromCommits(pkgPath, latestTag);
+          let revisionRange = latestTag;
+          if (latestTag) {
+            try {
+              execSync4(`git rev-parse --verify "${latestTag}"`, {
+                cwd: pkgPath,
+                stdio: "ignore"
+              });
+            } catch {
+              log(
+                `Tag ${latestTag} doesn't exist, using recent commits from HEAD for changelog`,
+                "debug"
+              );
+              revisionRange = "HEAD~10..HEAD";
+            }
+          } else {
+            revisionRange = "HEAD~10..HEAD";
+          }
+          changelogEntries = extractChangelogEntriesFromCommits(pkgPath, revisionRange);
           if (changelogEntries.length === 0) {
             changelogEntries = [
               {

package/package-versioner.schema.json

@@ -111,6 +111,11 @@
       "default": true,
       "description": "Whether to automatically generate and update changelogs"
     },
+    "strictReachable": {
+      "type": "boolean",
+      "default": false,
+      "description": "Only use reachable tags (no fallback to unreachable tags)"
+    },
     "cargo": {
       "type": "object",
       "properties": {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "package-versioner",
   "description": "A lightweight yet powerful CLI tool for automated semantic versioning based on Git history and conventional commits.",
-  "version": "0.7.2",
+  "version": "0.8.1",
   "type": "module",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",