package-versioner 0.7.2 → 0.8.2

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 behaviour**: 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,8 @@ 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)
+- `prereleaseIdentifier`: Identifier for prerelease versions (e.g., "alpha", "beta", "next") used in versions like "1.2.0-alpha.3"
 - `cargo`: Options for Rust projects:
   - `enabled`: Whether to handle Cargo.toml files (default: true)
   - `paths`: Directories to search for Cargo.toml files (optional)
@@ -142,7 +168,7 @@ For more details on CI/CD integration and advanced usage, see [CI/CD Integration
 
 ### Package Targeting
 
-The `packages` configuration option allows you to specify which packages should be processed for versioning. It supports several pattern types:
+The `packages` configuration option controls which packages are processed for versioning. It supports several pattern types:
 
 #### Exact Package Names
 ```json
@@ -175,7 +201,12 @@ Combine different pattern types:
 }
 ```
 
-**Note**: Package discovery is handled by your workspace configuration (pnpm-workspace.yaml, package.json workspaces, etc.). The `packages` option only filters which discovered packages to process.
+**Behaviour:**
+- When `packages` is specified, **only** packages matching those patterns will be processed
+- When `packages` is empty or not specified, **all** workspace packages will be processed  
+- The `skip` option can exclude specific packages from the selected set
+
+**Note**: Your workspace configuration (pnpm-workspace.yaml, package.json workspaces, etc.) determines which packages are available, but the `packages` option directly controls which ones get versioned.
 
 ### Package-Specific Tagging
 

package/dist/index.cjs

@@ -639,6 +639,30 @@ function createVersionError(code, details) {
   return new VersionError(fullMessage, code);
 }
 
+// src/utils/packageMatching.ts
+function matchesPackageTarget(packageName, target) {
+  if (packageName === target) {
+    return true;
+  }
+  if (target.endsWith("/*")) {
+    const scope = target.slice(0, -2);
+    if (scope.startsWith("@")) {
+      return packageName.startsWith(`${scope}/`);
+    }
+    return packageName.startsWith(`${scope}/`);
+  }
+  if (target === "*") {
+    return true;
+  }
+  return false;
+}
+function shouldMatchPackageTargets(packageName, targets) {
+  return targets.some((target) => matchesPackageTarget(packageName, target));
+}
+function shouldProcessPackage(packageName, skip = []) {
+  return !skip.includes(packageName);
+}
+
 // src/core/versionStrategies.ts
 var import_node_fs7 = __toESM(require("fs"), 1);
 var path7 = __toESM(require("path"), 1);
@@ -799,6 +823,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 +879,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 +946,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 +1029,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 +1144,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 +1477,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 +1538,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 +1551,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 +1613,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 +1636,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 +1672,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 +1712,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);
       }
@@ -1626,7 +1722,7 @@ To fix this mismatch:
       const bumper = new import_conventional_recommended_bump.Bumper();
       bumper.loadPreset(preset);
       const recommendedBump = await bumper.bump();
-      const releaseTypeFromCommits = recommendedBump == null ? void 0 : recommendedBump.releaseType;
+      const releaseTypeFromCommits = recommendedBump && "releaseType" in recommendedBump ? recommendedBump.releaseType : void 0;
       if (hasNoTags) {
         if (releaseTypeFromCommits) {
           return getPackageVersionFallback(
@@ -1655,7 +1751,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 +1796,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"
@@ -1711,37 +1807,9 @@ function calculateNextVersion(version, manifestType, name, releaseType, prerelea
   return result || initialVersion;
 }
 
-// src/utils/packageMatching.ts
-function matchesPackageTarget(packageName, target) {
-  if (packageName === target) {
-    return true;
-  }
-  if (target.endsWith("/*")) {
-    const scope = target.slice(0, -2);
-    if (scope.startsWith("@")) {
-      return packageName.startsWith(`${scope}/`);
-    }
-    return packageName.startsWith(`${scope}/`);
-  }
-  if (target === "*") {
-    return true;
-  }
-  return false;
-}
-function shouldProcessPackage(packageName, targets = [], skip = []) {
-  if (skip.includes(packageName)) {
-    return false;
-  }
-  if (targets.length === 0) {
-    return true;
-  }
-  return targets.some((target) => matchesPackageTarget(packageName, target));
-}
-
 // src/package/packageProcessor.ts
 var PackageProcessor = class {
   skip;
-  targets;
   versionPrefix;
   tagTemplate;
   commitMessageTemplate;
@@ -1753,7 +1821,6 @@ var PackageProcessor = class {
   fullConfig;
   constructor(options) {
     this.skip = options.skip || [];
-    this.targets = options.targets || [];
     this.versionPrefix = options.versionPrefix || "v";
     this.tagTemplate = options.tagTemplate;
     this.commitMessageTemplate = options.commitMessageTemplate || "";
@@ -1764,13 +1831,7 @@ var PackageProcessor = class {
     this.fullConfig = options.fullConfig;
   }
   /**
-   * Set package targets to process
-   */
-  setTargets(targets) {
-    this.targets = targets;
-  }
-  /**
-   * Process packages based on targeting criteria
+   * Process packages based on skip list only (targeting handled at discovery time)
    */
   async processPackages(packages) {
     var _a, _b, _c, _d, _e;
@@ -1781,21 +1842,16 @@ var PackageProcessor = class {
       return { updatedPackages: [], tags: [] };
     }
     const pkgsToConsider = packages.filter((pkg) => {
-      var _a2;
       const pkgName = pkg.packageJson.name;
-      const shouldProcess = shouldProcessPackage(pkgName, this.targets, this.skip);
+      const shouldProcess = shouldProcessPackage(pkgName, this.skip);
       if (!shouldProcess) {
-        if ((_a2 = this.skip) == null ? void 0 : _a2.includes(pkgName)) {
-          log(`Skipping package ${pkgName} as it's in the skip list.`, "info");
-        } else {
-          log(`Package ${pkgName} not in target list, skipping.`, "info");
-        }
+        log(`Skipping package ${pkgName} as it's in the skip list.`, "info");
       }
       return shouldProcess;
     });
-    log(`Found ${pkgsToConsider.length} targeted package(s) to process after filtering.`, "info");
+    log(`Found ${pkgsToConsider.length} package(s) to process after filtering.`, "info");
     if (pkgsToConsider.length === 0) {
-      log("No matching targeted packages found to process.", "info");
+      log("No packages found to process.", "info");
       return { updatedPackages: [], tags: [] };
     }
     for (const pkg of pkgsToConsider) {
@@ -1861,7 +1917,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 = [
               {
@@ -1961,7 +2034,7 @@ var PackageProcessor = class {
       updatedPackagesInfo.push({ name, version: nextVersion, path: pkgPath });
     }
     if (updatedPackagesInfo.length === 0) {
-      log("No targeted packages required a version update.", "info");
+      log("No packages required a version update.", "info");
       return { updatedPackages: [], tags };
     }
     const filesToCommit = [];
@@ -2025,9 +2098,9 @@ var PackageProcessor = class {
 };
 
 // src/core/versionStrategies.ts
-function shouldProcessPackage2(pkg, config, targets = []) {
+function shouldProcessPackage2(pkg, config) {
   const pkgName = pkg.packageJson.name;
-  return shouldProcessPackage(pkgName, targets, config.skip);
+  return shouldProcessPackage(pkgName, config.skip);
 }
 function createSyncedStrategy(config) {
   return async (packages) => {
@@ -2243,7 +2316,6 @@ function createAsyncStrategy(config) {
   };
   const processorOptions = {
     skip: config.skip || [],
-    targets: config.packages || [],
     versionPrefix: config.versionPrefix || "v",
     tagTemplate: config.tagTemplate,
     commitMessageTemplate: config.commitMessage || "",
@@ -2260,15 +2332,9 @@ function createAsyncStrategy(config) {
     }
   };
   const packageProcessor = new PackageProcessor(processorOptions);
-  return async (packages, targets = []) => {
+  return async (packages, _targets = []) => {
     try {
-      const targetPackages = targets.length > 0 ? targets : config.packages || [];
-      packageProcessor.setTargets(targetPackages);
-      if (targetPackages.length > 0) {
-        log(`Processing targeted packages: ${targetPackages.join(", ")}`, "info");
-      } else {
-        log("No targets specified, processing all non-skipped packages", "info");
-      }
+      log(`Processing ${packages.packages.length} pre-filtered packages`, "info");
       const result = await packageProcessor.processPackages(packages.packages);
       if (result.updatedPackages.length === 0) {
         log("No packages required a version update.", "info");
@@ -2350,6 +2416,25 @@ var VersionEngine = class {
         );
         pkgsResult.root = (0, import_node_process5.cwd)();
       }
+      if (this.config.packages && this.config.packages.length > 0) {
+        const originalCount = pkgsResult.packages.length;
+        const filteredPackages = pkgsResult.packages.filter(
+          (pkg) => shouldMatchPackageTargets(pkg.packageJson.name, this.config.packages)
+        );
+        pkgsResult.packages = filteredPackages;
+        log(
+          `Filtered ${originalCount} workspace packages to ${filteredPackages.length} based on packages config`,
+          "info"
+        );
+        if (filteredPackages.length === 0) {
+          log("Warning: No packages matched the specified patterns in config.packages", "warning");
+        }
+      } else {
+        log(
+          `Processing all ${pkgsResult.packages.length} workspace packages (no packages filter specified)`,
+          "info"
+        );
+      }
       this.workspaceCache = pkgsResult;
       return pkgsResult;
     } catch (error) {

package/dist/index.js

@@ -606,6 +606,30 @@ function createVersionError(code, details) {
   return new VersionError(fullMessage, code);
 }
 
+// src/utils/packageMatching.ts
+function matchesPackageTarget(packageName, target) {
+  if (packageName === target) {
+    return true;
+  }
+  if (target.endsWith("/*")) {
+    const scope = target.slice(0, -2);
+    if (scope.startsWith("@")) {
+      return packageName.startsWith(`${scope}/`);
+    }
+    return packageName.startsWith(`${scope}/`);
+  }
+  if (target === "*") {
+    return true;
+  }
+  return false;
+}
+function shouldMatchPackageTargets(packageName, targets) {
+  return targets.some((target) => matchesPackageTarget(packageName, target));
+}
+function shouldProcessPackage(packageName, skip = []) {
+  return !skip.includes(packageName);
+}
+
 // src/core/versionStrategies.ts
 import fs9 from "fs";
 import * as path7 from "path";
@@ -766,6 +790,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 +846,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 +913,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 +996,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 +1111,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 +1444,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 +1505,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 +1518,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 +1580,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 +1603,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 +1639,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 +1679,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);
       }
@@ -1593,7 +1689,7 @@ To fix this mismatch:
       const bumper = new Bumper();
       bumper.loadPreset(preset);
       const recommendedBump = await bumper.bump();
-      const releaseTypeFromCommits = recommendedBump == null ? void 0 : recommendedBump.releaseType;
+      const releaseTypeFromCommits = recommendedBump && "releaseType" in recommendedBump ? recommendedBump.releaseType : void 0;
       if (hasNoTags) {
         if (releaseTypeFromCommits) {
           return getPackageVersionFallback(
@@ -1622,7 +1718,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 +1763,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"
@@ -1678,37 +1774,9 @@ function calculateNextVersion(version, manifestType, name, releaseType, prerelea
   return result || initialVersion;
 }
 
-// src/utils/packageMatching.ts
-function matchesPackageTarget(packageName, target) {
-  if (packageName === target) {
-    return true;
-  }
-  if (target.endsWith("/*")) {
-    const scope = target.slice(0, -2);
-    if (scope.startsWith("@")) {
-      return packageName.startsWith(`${scope}/`);
-    }
-    return packageName.startsWith(`${scope}/`);
-  }
-  if (target === "*") {
-    return true;
-  }
-  return false;
-}
-function shouldProcessPackage(packageName, targets = [], skip = []) {
-  if (skip.includes(packageName)) {
-    return false;
-  }
-  if (targets.length === 0) {
-    return true;
-  }
-  return targets.some((target) => matchesPackageTarget(packageName, target));
-}
-
 // src/package/packageProcessor.ts
 var PackageProcessor = class {
   skip;
-  targets;
   versionPrefix;
   tagTemplate;
   commitMessageTemplate;
@@ -1720,7 +1788,6 @@ var PackageProcessor = class {
   fullConfig;
   constructor(options) {
     this.skip = options.skip || [];
-    this.targets = options.targets || [];
     this.versionPrefix = options.versionPrefix || "v";
     this.tagTemplate = options.tagTemplate;
     this.commitMessageTemplate = options.commitMessageTemplate || "";
@@ -1731,13 +1798,7 @@ var PackageProcessor = class {
     this.fullConfig = options.fullConfig;
   }
   /**
-   * Set package targets to process
-   */
-  setTargets(targets) {
-    this.targets = targets;
-  }
-  /**
-   * Process packages based on targeting criteria
+   * Process packages based on skip list only (targeting handled at discovery time)
    */
   async processPackages(packages) {
     var _a, _b, _c, _d, _e;
@@ -1748,21 +1809,16 @@ var PackageProcessor = class {
       return { updatedPackages: [], tags: [] };
     }
     const pkgsToConsider = packages.filter((pkg) => {
-      var _a2;
       const pkgName = pkg.packageJson.name;
-      const shouldProcess = shouldProcessPackage(pkgName, this.targets, this.skip);
+      const shouldProcess = shouldProcessPackage(pkgName, this.skip);
       if (!shouldProcess) {
-        if ((_a2 = this.skip) == null ? void 0 : _a2.includes(pkgName)) {
-          log(`Skipping package ${pkgName} as it's in the skip list.`, "info");
-        } else {
-          log(`Package ${pkgName} not in target list, skipping.`, "info");
-        }
+        log(`Skipping package ${pkgName} as it's in the skip list.`, "info");
       }
       return shouldProcess;
     });
-    log(`Found ${pkgsToConsider.length} targeted package(s) to process after filtering.`, "info");
+    log(`Found ${pkgsToConsider.length} package(s) to process after filtering.`, "info");
     if (pkgsToConsider.length === 0) {
-      log("No matching targeted packages found to process.", "info");
+      log("No packages found to process.", "info");
       return { updatedPackages: [], tags: [] };
     }
     for (const pkg of pkgsToConsider) {
@@ -1828,7 +1884,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 = [
               {
@@ -1928,7 +2001,7 @@ var PackageProcessor = class {
       updatedPackagesInfo.push({ name, version: nextVersion, path: pkgPath });
     }
     if (updatedPackagesInfo.length === 0) {
-      log("No targeted packages required a version update.", "info");
+      log("No packages required a version update.", "info");
       return { updatedPackages: [], tags };
     }
     const filesToCommit = [];
@@ -1992,9 +2065,9 @@ var PackageProcessor = class {
 };
 
 // src/core/versionStrategies.ts
-function shouldProcessPackage2(pkg, config, targets = []) {
+function shouldProcessPackage2(pkg, config) {
   const pkgName = pkg.packageJson.name;
-  return shouldProcessPackage(pkgName, targets, config.skip);
+  return shouldProcessPackage(pkgName, config.skip);
 }
 function createSyncedStrategy(config) {
   return async (packages) => {
@@ -2210,7 +2283,6 @@ function createAsyncStrategy(config) {
   };
   const processorOptions = {
     skip: config.skip || [],
-    targets: config.packages || [],
     versionPrefix: config.versionPrefix || "v",
     tagTemplate: config.tagTemplate,
     commitMessageTemplate: config.commitMessage || "",
@@ -2227,15 +2299,9 @@ function createAsyncStrategy(config) {
     }
   };
   const packageProcessor = new PackageProcessor(processorOptions);
-  return async (packages, targets = []) => {
+  return async (packages, _targets = []) => {
     try {
-      const targetPackages = targets.length > 0 ? targets : config.packages || [];
-      packageProcessor.setTargets(targetPackages);
-      if (targetPackages.length > 0) {
-        log(`Processing targeted packages: ${targetPackages.join(", ")}`, "info");
-      } else {
-        log("No targets specified, processing all non-skipped packages", "info");
-      }
+      log(`Processing ${packages.packages.length} pre-filtered packages`, "info");
       const result = await packageProcessor.processPackages(packages.packages);
       if (result.updatedPackages.length === 0) {
         log("No packages required a version update.", "info");
@@ -2317,6 +2383,25 @@ var VersionEngine = class {
         );
         pkgsResult.root = cwd4();
       }
+      if (this.config.packages && this.config.packages.length > 0) {
+        const originalCount = pkgsResult.packages.length;
+        const filteredPackages = pkgsResult.packages.filter(
+          (pkg) => shouldMatchPackageTargets(pkg.packageJson.name, this.config.packages)
+        );
+        pkgsResult.packages = filteredPackages;
+        log(
+          `Filtered ${originalCount} workspace packages to ${filteredPackages.length} based on packages config`,
+          "info"
+        );
+        if (filteredPackages.length === 0) {
+          log("Warning: No packages matched the specified patterns in config.packages", "warning");
+        }
+      } else {
+        log(
+          `Processing all ${pkgsResult.packages.length} workspace packages (no packages filter specified)`,
+          "info"
+        );
+      }
       this.workspaceCache = pkgsResult;
       return pkgsResult;
     } catch (error) {

package/docs/CI_CD_INTEGRATION.md

@@ -154,7 +154,7 @@ git push origin "v$NEW_VERSION"
 `package-versioner` respects the following environment variables:
 
 - `NO_COLOR=1`: Disables colored output in logs (automatically detected in CI environments)
-- `CI=true`: Most CI environments set this automatically, which helps the tool adjust its output behavior
+- `CI=true`: Most CI environments set this automatically, which helps the tool adjust its output behaviour
 
 ## Skipping CI for Version Commits
 

package/docs/versioning.md

@@ -170,13 +170,6 @@ This dual support makes `package-versioner` suitable for both JavaScript/TypeScr
 
 When working with monorepos, you can control which packages are processed for versioning using the `packages` configuration option. This provides flexible targeting with support for various pattern types.
 
-### Package Discovery vs. Targeting
-
-It's important to understand the distinction:
-
-- **Package Discovery**: Handled by your workspace configuration (pnpm-workspace.yaml, package.json workspaces, etc.)
-- **Package Targeting**: Controlled by the `packages` option in version.config.json to filter which discovered packages to process
-
 ### Targeting Patterns
 
 #### Exact Package Names
@@ -212,6 +205,12 @@ Combine different pattern types for flexible targeting:
 }
 ```
 
+### Behaviour
+
+- **When `packages` is specified**: Only packages matching those patterns will be processed for versioning
+- **When `packages` is empty or not specified**: All workspace packages will be processed
+- **Error handling**: If no packages match the specified patterns, a warning is displayed
+
 ### Excluding Packages
 
 Use the `skip` option to exclude specific packages from processing:
@@ -224,6 +223,8 @@ Use the `skip` option to exclude specific packages from processing:
 
 This configuration will process all packages in the `@mycompany` scope except for `@mycompany/deprecated-package`.
 
+**Note**: Your workspace configuration (pnpm-workspace.yaml, package.json workspaces, etc.) determines which packages are available in your workspace, but the `packages` option directly controls which ones get versioned.
+
 ## Tag Templates and Configuration
 
 `package-versioner` provides flexible configuration for how Git tags are formatted, allowing you to customize the tag structure for both single package repositories and monorepos.

package/package-versioner.schema.json

@@ -21,7 +21,7 @@
     "packageSpecificTags": {
       "type": "boolean",
       "default": false,
-      "description": "Whether to enable package-specific tagging behavior"
+      "description": "Whether to enable package-specific tagging behaviour"
     },
     "preset": {
       "type": "string",
@@ -53,7 +53,7 @@
         "minLength": 1
       },
       "default": [],
-      "description": "Array of package names or patterns to target for versioning. Supports exact names (e.g., '@scope/package-a'), scope wildcards (e.g., '@scope/*'), and global wildcards (e.g., '*')"
+      "description": "Array of package names or patterns that determines which packages will be processed for versioning. When specified, only packages matching these patterns will be versioned. When empty or not specified, all workspace packages will be processed. Supports exact names (e.g., '@scope/package-a'), scope wildcards (e.g., '@scope/*'), and global wildcards (e.g., '*')"
     },
     "mainPackage": {
       "type": "string",
@@ -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.2",
   "type": "module",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",
@@ -37,17 +37,17 @@
     ]
   },
   "devDependencies": {
-    "@biomejs/biome": "^1.9.4",
+    "@biomejs/biome": "^2.0.6",
     "@types/figlet": "^1.5.5",
-    "@types/node": "^24.0.3",
+    "@types/node": "^24.0.10",
     "@types/semver": "^7.3.13",
-    "@vitest/coverage-v8": "^3.2.3",
+    "@vitest/coverage-v8": "^3.2.4",
     "husky": "^9.1.7",
     "lint-staged": "^16.1.2",
     "tsup": "^8.5.0",
     "tsx": "^4.20.3",
     "typescript": "^5.8.3",
-    "vitest": "^3.2.3"
+    "vitest": "^3.2.4"
   },
   "dependencies": {
     "@manypkg/get-packages": "^3.0.0",
@@ -59,7 +59,7 @@
     "figlet": "^1.8.1",
     "git-semver-tags": "^8.0.0",
     "semver": "^7.7.2",
-    "smol-toml": "^1.3.4"
+    "smol-toml": "^1.4.1"
   },
   "scripts": {
     "build": "tsup src/index.ts --format esm,cjs --dts",