package-versioner 0.7.1 → 0.8.1

package/dist/index.js

@@ -105,7 +105,23 @@ function extractChangelogEntriesFromCommits(projectDir, revisionRange) {
     const commits = output.split("---COMMIT_DELIMITER---").filter((commit) => commit.trim() !== "");
     return commits.map((commit) => parseCommitMessage(commit)).filter((entry) => entry !== null);
   } catch (error) {
-    log(`Error extracting commits: ${error}`, "error");
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    if (errorMessage.includes("ambiguous argument") && errorMessage.includes("unknown revision")) {
+      const tagName = revisionRange.split("..")[0] || revisionRange;
+      if (tagName.startsWith("v") && !tagName.includes("@")) {
+        log(
+          `Error: Tag "${tagName}" not found. If you're using package-specific tags (like "package-name@v1.0.0"), you may need to configure "tagTemplate" in your version.config.json to use: \${packageName}@\${prefix}\${version}`,
+          "error"
+        );
+      } else {
+        log(
+          `Error: Tag or revision "${tagName}" not found in the repository. Please check if this tag exists or if you need to fetch it from the remote.`,
+          "error"
+        );
+      }
+    } else {
+      log(`Error extracting commits: ${errorMessage}`, "error");
+    }
     return [];
   }
 }
@@ -750,43 +766,48 @@ 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) {
   return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
-function formatTag(version, versionPrefix, packageName, tagTemplate = "${prefix}${version}", packageTagTemplate = "${packageName}@${prefix}${version}") {
-  const variables = {
-    version,
-    prefix: versionPrefix || "",
-    packageName: packageName || ""
-  };
-  const template = packageName ? packageTagTemplate : tagTemplate;
-  return createTemplateString(template, variables);
-}
-function formatVersionPrefix(versionPrefix, scope) {
-  if (!versionPrefix) return "";
-  const cleanPrefix = versionPrefix.replace(/\/$/, "");
-  if (scope) {
-    return `${cleanPrefix}/${scope}`;
-  }
-  return cleanPrefix;
-}
-function formatCommitMessage(template, version, packageName, scope) {
-  return createTemplateString(template, {
-    version,
-    scope,
-    packageName: packageName || ""
-  });
+function formatVersionPrefix(prefix) {
+  return prefix.endsWith("/") ? prefix.slice(0, -1) : prefix;
+}
+function formatTag(version, prefix, packageName, template, packageSpecificTags) {
+  if ((template == null ? void 0 : template.includes("${packageName}")) && !packageName) {
+    log(
+      'Warning: Your tagTemplate contains ${packageName} but no package name is available.\nThis will result in an empty package name in the tag (e.g., "@v1.0.0" instead of "my-package@v1.0.0").\n\nTo fix this:\n\u2022 If using synced mode: Set "packageSpecificTags": true in your config to enable package names in tags\n\u2022 If you want global tags: Remove ${packageName} from your tagTemplate (e.g., use "${prefix}${version}")\n\u2022 If using single/async mode: Ensure your package.json has a valid "name" field',
+      "warning"
+    );
+  }
+  if (template) {
+    return template.replace(/\$\{version\}/g, version).replace(/\$\{prefix\}/g, prefix).replace(/\$\{packageName\}/g, packageName || "");
+  }
+  if (packageSpecificTags && packageName) {
+    return `${packageName}@${prefix}${version}`;
+  }
+  return `${prefix}${version}`;
 }
-function createTemplateString(template, variables) {
-  return Object.entries(variables).reduce((result, [key, value]) => {
-    if (value === void 0) {
-      return result;
+function formatCommitMessage(template, version, packageName, additionalContext) {
+  if (template.includes("${packageName}") && !packageName) {
+    log(
+      'Warning: Your commitMessage template contains ${packageName} but no package name is available.\nThis will result in an empty package name in the commit message (e.g., "Release @v1.0.0").\n\nTo fix this:\n\u2022 If using synced mode: Set "packageSpecificTags": true to enable package names in commits\n\u2022 If you want generic commit messages: Remove ${packageName} from your commitMessage template\n\u2022 If using single/async mode: Ensure your package.json has a valid "name" field',
+      "warning"
+    );
+  }
+  let result = template.replace(/\$\{version\}/g, version).replace(/\$\{packageName\}/g, packageName || "");
+  if (additionalContext) {
+    for (const [key, value] of Object.entries(additionalContext)) {
+      const placeholder = `\${${key}}`;
+      result = result.replace(
+        new RegExp(placeholder.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), "g"),
+        value
+      );
     }
-    const regex = new RegExp(`\\$\\{${key}\\}`, "g");
-    return result.replace(regex, value);
-  }, template);
+  }
+  return result;
 }
 
 // src/git/tagsAndBranches.ts
@@ -801,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");
@@ -829,56 +869,122 @@ async function lastMergeBranchName(branches, baseBranch) {
     return null;
   }
 }
-async function getLatestTagForPackage(packageName, versionPrefix) {
+async function getLatestTagForPackage(packageName, versionPrefix, options) {
   try {
+    const tagTemplate = (options == null ? void 0 : options.tagTemplate) || "${prefix}${version}";
+    const packageSpecificTags = (options == null ? void 0 : options.packageSpecificTags) ?? false;
     const escapedPackageName = escapeRegExp(packageName);
+    const escapedPrefix = versionPrefix ? escapeRegExp(versionPrefix) : "";
     log(
-      `Looking for tags for package ${packageName} with prefix ${versionPrefix || "none"}`,
+      `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 packageTags = [];
-    if (versionPrefix) {
-      const pattern1 = new RegExp(`^${escapedPackageName}@${escapeRegExp(versionPrefix)}`);
-      packageTags = allTags.filter((tag) => pattern1.test(tag));
+    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));
       if (packageTags.length > 0) {
-        log(
-          `Found ${packageTags.length} package tags using pattern: packageName@${versionPrefix}...`,
-          "debug"
-        );
-        log(`Using tag: ${packageTags[0]}`, "debug");
-        return packageTags[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 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 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) {
-        log(
-          `Found ${packageTags.length} package tags using pattern: ${versionPrefix}packageName@...`,
-          "debug"
-        );
-        log(`Using tag: ${packageTags[0]}`, "debug");
-        return packageTags[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 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) {
-        log(`Available tags: ${allTags.join(", ")}`, "debug");
-      } else {
-        log("No tags available in the repository", "debug");
+      const pattern3 = new RegExp(`^${escapedPackageName}@`);
+      packageTags = allTags.filter((tag) => pattern3.test(tag));
+      if (packageTags.length === 0) {
+        log("No matching tags found for pattern: packageName@version", "debug");
+        if (allTags.length > 0) {
+          log(`Available tags: ${allTags.join(", ")}`, "debug");
+        } else {
+          log("No tags available in the repository", "debug");
+        }
+        return "";
       }
-    } else {
-      log(`Using tag: ${packageTags[0]}`, "debug");
+      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];
     }
-    return packageTags[0] || "";
+    log(`Package-specific tags disabled for ${packageName}, falling back to global tags`, "debug");
+    return "";
   } catch (error) {
     const errorMessage = error instanceof Error ? error.message : String(error);
     log(`Failed to get latest tag for package ${packageName}: ${errorMessage}`, "error");
@@ -981,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";
@@ -1313,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";
@@ -1374,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) {
@@ -1387,58 +1494,116 @@ 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
 async function calculateVersion(config, options) {
   const {
-    latestTag = "",
-    type,
-    versionPrefix = "",
+    type: configType,
+    preset = "angular",
+    versionPrefix,
+    prereleaseIdentifier: configPrereleaseIdentifier,
     branchPattern,
-    baseBranch,
-    prereleaseIdentifier,
+    baseBranch
+  } = config;
+  const {
+    latestTag,
+    name,
     path: pkgPath,
-    name
+    type: optionsType,
+    prereleaseIdentifier: optionsPrereleaseIdentifier
   } = options;
-  const preset = config.preset || "conventional-commits";
+  const type = optionsType || configType;
+  const prereleaseIdentifier = optionsPrereleaseIdentifier || configPrereleaseIdentifier;
   const initialVersion = "0.1.0";
+  const hasNoTags = !latestTag || latestTag.trim() === "";
   const normalizedPrereleaseId = normalizePrereleaseIdentifier(prereleaseIdentifier, config);
   try {
     let determineTagSearchPattern2 = function(packageName, prefix) {
-      if (packageName) {
-        const escapedPackageName = escapeRegExp(packageName);
-        const escapedPrefix = escapeRegExp(prefix);
-        return `${escapedPackageName}[@]?${escapedPrefix}`;
+      if (!packageName) {
+        return prefix;
       }
-      return escapeRegExp(prefix);
+      return `${packageName}@${prefix}`;
+    }, escapeRegExp3 = function(string) {
+      return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
     };
-    var determineTagSearchPattern = determineTagSearchPattern2;
-    const hasNoTags = !latestTag;
-    const originalPrefix = versionPrefix;
+    var determineTagSearchPattern = determineTagSearchPattern2, escapeRegExp2 = escapeRegExp3;
+    const originalPrefix = versionPrefix || "";
     const tagSearchPattern = determineTagSearchPattern2(name, originalPrefix);
-    const escapedTagPattern = escapeRegExp(tagSearchPattern);
+    const escapedTagPattern = escapeRegExp3(tagSearchPattern);
+    if (!hasNoTags && pkgPath) {
+      const packageDir = pkgPath || cwd3();
+      const manifestResult = getVersionFromManifests(packageDir);
+      if (manifestResult.manifestFound && manifestResult.version) {
+        const cleanedTag = semver3.clean(latestTag) || latestTag;
+        const tagVersion = semver3.clean(cleanedTag.replace(new RegExp(`^${escapedTagPattern}`), "")) || "0.0.0";
+        const packageVersion = manifestResult.version;
+        if (semver3.gt(packageVersion, tagVersion)) {
+          log(
+            `Warning: Version mismatch detected!
+\u2022 ${manifestResult.manifestType} version: ${packageVersion}
+\u2022 Latest Git tag version: ${tagVersion} (from ${latestTag})
+\u2022 Package version is AHEAD of Git tags
+
+This usually happens when:
+\u2022 A version was released but the tag wasn't pushed to the remote repository
+\u2022 The ${manifestResult.manifestType} was manually updated without creating a corresponding tag
+\u2022 You're running in CI and the latest tag isn't available yet
+
+The tool will use the Git tag version (${tagVersion}) as the base for calculation.
+Expected next version will be based on ${tagVersion}, not ${packageVersion}.
+
+To fix this mismatch:
+\u2022 Push missing tags: git push origin --tags
+\u2022 Or use package version as base by ensuring tags are up to date`,
+            "warning"
+          );
+        } else if (semver3.gt(tagVersion, packageVersion)) {
+          log(
+            `Warning: Version mismatch detected!
+\u2022 ${manifestResult.manifestType} version: ${packageVersion}
+\u2022 Latest Git tag version: ${tagVersion} (from ${latestTag})
+\u2022 Git tag version is AHEAD of package version
+
+This usually happens when:
+\u2022 A release was tagged but the ${manifestResult.manifestType} wasn't updated
+\u2022 You're on an older branch that hasn't been updated with the latest version
+\u2022 Automated release process created tags but didn't update manifest files
+\u2022 You pulled tags but not the corresponding commits that update the package version
+
+The tool will use the Git tag version (${tagVersion}) as the base for calculation.
+This will likely result in a version that's already been released.
+
+To fix this mismatch:
+\u2022 Update ${manifestResult.manifestType}: Set version to ${tagVersion} or higher
+\u2022 Or checkout the branch/commit that corresponds to the tag
+\u2022 Or ensure your branch is up to date with the latest changes`,
+            "warning"
+          );
+        }
+      }
+    }
     const specifiedType = type;
     if (specifiedType) {
       if (hasNoTags) {
@@ -1450,9 +1615,9 @@ async function calculateVersion(config, options) {
           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"
@@ -1490,8 +1655,8 @@ async function calculateVersion(config, options) {
             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);
       }
@@ -1529,7 +1694,7 @@ async function calculateVersion(config, options) {
         );
         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");
@@ -1574,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"
@@ -1585,13 +1750,39 @@ 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;
-  packageTagTemplate;
   commitMessageTemplate;
   dryRun;
   skipHooks;
@@ -1604,7 +1795,6 @@ var PackageProcessor = class {
     this.targets = options.targets || [];
     this.versionPrefix = options.versionPrefix || "v";
     this.tagTemplate = options.tagTemplate;
-    this.packageTagTemplate = options.packageTagTemplate;
     this.commitMessageTemplate = options.commitMessageTemplate || "";
     this.dryRun = options.dryRun || false;
     this.skipHooks = options.skipHooks || false;
@@ -1632,18 +1822,15 @@ var PackageProcessor = class {
     const pkgsToConsider = packages.filter((pkg) => {
       var _a2;
       const pkgName = pkg.packageJson.name;
-      if ((_a2 = this.skip) == null ? void 0 : _a2.includes(pkgName)) {
-        log(`Skipping package ${pkgName} as it's in the skip list.`, "info");
-        return false;
-      }
-      if (!this.targets || this.targets.length === 0) {
-        return true;
-      }
-      const isTargeted = this.targets.includes(pkgName);
-      if (!isTargeted) {
-        log(`Package ${pkgName} not in target list, skipping.`, "info");
+      const shouldProcess = shouldProcessPackage(pkgName, this.targets, 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");
+        }
       }
-      return isTargeted;
+      return shouldProcess;
     });
     log(`Found ${pkgsToConsider.length} targeted package(s) to process after filtering.`, "info");
     if (pkgsToConsider.length === 0) {
@@ -1656,7 +1843,10 @@ var PackageProcessor = class {
       const formattedPrefix = formatVersionPrefix(this.versionPrefix);
       let latestTagResult = "";
       try {
-        latestTagResult = await getLatestTagForPackage(name, this.versionPrefix);
+        latestTagResult = await getLatestTagForPackage(name, this.versionPrefix, {
+          tagTemplate: this.tagTemplate,
+          packageSpecificTags: this.fullConfig.packageSpecificTags
+        });
       } catch (error) {
         const errorMessage = error instanceof Error ? error.message : String(error);
         log(
@@ -1710,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 = [
               {
@@ -1788,7 +1995,7 @@ var PackageProcessor = class {
         this.versionPrefix,
         name,
         this.tagTemplate,
-        this.packageTagTemplate
+        this.fullConfig.packageSpecificTags
       );
       const tagMessage = `chore(release): ${name} ${nextVersion}`;
       addTag(packageTag);
@@ -1874,16 +2081,9 @@ var PackageProcessor = class {
 };
 
 // src/core/versionStrategies.ts
-function shouldProcessPackage(pkg, config, targets = []) {
-  var _a;
+function shouldProcessPackage2(pkg, config, targets = []) {
   const pkgName = pkg.packageJson.name;
-  if ((_a = config.skip) == null ? void 0 : _a.includes(pkgName)) {
-    return false;
-  }
-  if (!targets || targets.length === 0) {
-    return true;
-  }
-  return targets.includes(pkgName);
+  return shouldProcessPackage(pkgName, targets, config.skip);
 }
 function createSyncedStrategy(config) {
   return async (packages) => {
@@ -1939,6 +2139,7 @@ function createSyncedStrategy(config) {
       }
       const files = [];
       const updatedPackages = [];
+      const processedPaths = /* @__PURE__ */ new Set();
       try {
         if (packages.root) {
           const rootPkgPath = path7.join(packages.root, "package.json");
@@ -1946,6 +2147,7 @@ function createSyncedStrategy(config) {
             updatePackageVersion(rootPkgPath, nextVersion);
             files.push(rootPkgPath);
             updatedPackages.push("root");
+            processedPaths.add(rootPkgPath);
           }
         } else {
           log("Root package path is undefined, skipping root package.json update", "warning");
@@ -1955,13 +2157,17 @@ function createSyncedStrategy(config) {
         log(`Failed to update root package.json: ${errMessage}`, "error");
       }
       for (const pkg of packages.packages) {
-        if (!shouldProcessPackage(pkg, config)) {
+        if (!shouldProcessPackage2(pkg, config)) {
           continue;
         }
         const packageJsonPath = path7.join(pkg.dir, "package.json");
+        if (processedPaths.has(packageJsonPath)) {
+          continue;
+        }
         updatePackageVersion(packageJsonPath, nextVersion);
         files.push(packageJsonPath);
         updatedPackages.push(pkg.packageJson.name);
+        processedPaths.add(packageJsonPath);
       }
       if (updatedPackages.length > 0) {
         log(`Updated ${updatedPackages.length} package(s) to version ${nextVersion}`, "success");
@@ -1969,8 +2175,25 @@ function createSyncedStrategy(config) {
         log("No packages were updated", "warning");
         return;
       }
-      const nextTag = formatTag(nextVersion, formattedPrefix, null, tagTemplate);
-      const formattedCommitMessage = formatCommitMessage(commitMessage, nextVersion);
+      let tagPackageName = null;
+      let commitPackageName = void 0;
+      if (config.packageSpecificTags && packages.packages.length === 1) {
+        tagPackageName = packages.packages[0].packageJson.name;
+        commitPackageName = packages.packages[0].packageJson.name;
+      }
+      const nextTag = formatTag(
+        nextVersion,
+        formattedPrefix,
+        tagPackageName,
+        tagTemplate,
+        config.packageSpecificTags || false
+      );
+      const formattedCommitMessage = formatCommitMessage(
+        commitMessage,
+        nextVersion,
+        commitPackageName,
+        void 0
+      );
       await createGitCommitAndTag(files, nextTag, formattedCommitMessage, skipHooks, dryRun);
     } catch (error) {
       if (error instanceof VersionError || error instanceof GitError) {
@@ -1991,7 +2214,6 @@ function createSingleStrategy(config) {
         mainPackage,
         versionPrefix,
         tagTemplate,
-        packageTagTemplate,
         commitMessage = "chore(release): ${version}",
         dryRun,
         skipHooks
@@ -2013,7 +2235,10 @@ function createSingleStrategy(config) {
       }
       const pkgPath = pkg.dir;
       const formattedPrefix = formatVersionPrefix(versionPrefix || "v");
-      let latestTagResult = await getLatestTagForPackage(packageName, formattedPrefix);
+      let latestTagResult = await getLatestTagForPackage(packageName, formattedPrefix, {
+        tagTemplate,
+        packageSpecificTags: config.packageSpecificTags
+      });
       if (!latestTagResult) {
         const globalTagResult = await getLatestTag();
         latestTagResult = globalTagResult || "";
@@ -2044,7 +2269,7 @@ function createSingleStrategy(config) {
         formattedPrefix,
         packageName,
         tagTemplate,
-        packageTagTemplate
+        config.packageSpecificTags
       );
       const formattedCommitMessage = formatCommitMessage(commitMessage, nextVersion, packageName);
       await createGitCommitAndTag(
@@ -2077,7 +2302,6 @@ function createAsyncStrategy(config) {
     targets: config.packages || [],
     versionPrefix: config.versionPrefix || "v",
     tagTemplate: config.tagTemplate,
-    packageTagTemplate: config.packageTagTemplate,
     commitMessageTemplate: config.commitMessage || "",
     dryRun: config.dryRun || false,
     skipHooks: config.skipHooks || false,