package-versioner 0.7.1 → 0.7.2

package/README.md

@@ -92,14 +92,14 @@ For detailed examples of how to use this in CI/CD pipelines, see [CI/CD Integrat
 
 ## Configuration
 
-Customize behavior by creating a `version.config.json` file in your project root:
+Customize behaviour by creating a `version.config.json` file in your project root:
 
 ```json
 {
   "preset": "angular",
   "versionPrefix": "v",
-  "tagTemplate": "${prefix}${version}",
-  "packageTagTemplate": "${packageName}@${prefix}${version}",
+  "tagTemplate": "${packageName}@${prefix}${version}",
+  "packageSpecificTags": true,
   "commitMessage": "chore: release ${packageName}@${version} [skip ci]",
   "updateChangelog": true,
   "changelogFormat": "keep-a-changelog",
@@ -108,7 +108,7 @@ Customize behavior by creating a `version.config.json` file in your project root
     "docs",
     "e2e"
   ],
-  "packages": ["packages/*"],
+  "packages": ["@mycompany/*"],
   "mainPackage": "primary-package",
   "cargo": {
     "enabled": true,
@@ -133,13 +133,92 @@ Customize behavior by creating a `version.config.json` file in your project root
 #### Monorepo-Specific Options
 - `synced`: Whether all packages should be versioned together (default: true)
 - `skip`: Array of package names to exclude from versioning
-- `packages`: Glob patterns for package discovery (e.g., ["packages/*"])
+- `packages`: Array of package names or patterns to target for versioning. Supports exact names, scope wildcards, and global wildcards (e.g., ["@scope/package-a", "@scope/*", "*"])
 - `mainPackage`: Package name whose commit history should drive version determination
-- `packageTagTemplate`: Template for package-specific Git tags (default: "${packageName}@${prefix}${version}")
+- `packageSpecificTags`: Whether to enable package-specific tagging behaviour (default: false)
 - `updateInternalDependencies`: How to update internal dependencies ("patch", "minor", "major", or "inherit")
 
 For more details on CI/CD integration and advanced usage, see [CI/CD Integration](./docs/CI_CD_INTEGRATION.md).
 
+### Package Targeting
+
+The `packages` configuration option allows you to specify which packages should be processed for versioning. It supports several pattern types:
+
+#### Exact Package Names
+```json
+{
+  "packages": ["@mycompany/core", "@mycompany/utils", "standalone-package"]
+}
+```
+
+#### Scope Wildcards
+Target all packages within a specific scope:
+```json
+{
+  "packages": ["@mycompany/*"]
+}
+```
+
+#### Global Wildcard
+Target all packages in the workspace:
+```json
+{
+  "packages": ["*"]
+}
+```
+
+#### Mixed Patterns
+Combine different pattern types:
+```json
+{
+  "packages": ["@mycompany/*", "@utils/logger", "legacy-package"]
+}
+```
+
+**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.
+
+### Package-Specific Tagging
+
+The `packageSpecificTags` option controls whether the tool creates and searches for package-specific Git tags:
+
+- **When `false` (default)**: Creates global tags like `v1.2.3` and searches for the latest global tag
+- **When `true`**: Creates package-specific tags like `@scope/package-a@v1.2.3` and searches for package-specific tags
+
+This option works in conjunction with `tagTemplate` to control tag formatting. The `tagTemplate` is used for all tag creation, with the `packageSpecificTags` boolean controlling whether the `${packageName}` variable is populated:
+
+- When `packageSpecificTags` is `false`: The `${packageName}` variable is empty, so templates should use `${prefix}${version}`
+- When `packageSpecificTags` is `true`: The `${packageName}` variable contains the package name
+
+**Examples:**
+
+For single-package repositories or synced monorepos:
+```json
+{
+  "packageSpecificTags": true,
+  "tagTemplate": "${packageName}@${prefix}${version}"
+}
+```
+Creates tags like `my-package@v1.2.3`
+
+For global versioning:
+```json
+{
+  "packageSpecificTags": false,
+  "tagTemplate": "${prefix}${version}"
+}
+```
+Creates tags like `v1.2.3`
+
+**Important Notes:**
+- In **synced mode** with a single package, `packageSpecificTags: true` will use the package name even though all packages are versioned together
+- In **synced mode** with multiple packages, package names are not used regardless of the setting
+- In **async mode**, each package gets its own tag when `packageSpecificTags` is enabled
+
+With package-specific tagging enabled, the tool will:
+1. Look for existing tags matching the configured pattern for each package
+2. Create new tags using the same pattern when releasing
+3. Fall back to global tag lookup if no package-specific tags are found
+
 ## How Versioning Works
 
 `package-versioner` determines the next version based on your configuration (`version.config.json`). The two main approaches are:

package/dist/index.cjs

@@ -138,7 +138,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 [];
   }
 }
@@ -788,38 +804,42 @@ var import_git_semver_tags = require("git-semver-tags");
 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 createTemplateString(template, variables) {
-  return Object.entries(variables).reduce((result, [key, value]) => {
-    if (value === void 0) {
-      return result;
+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 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
@@ -862,56 +882,71 @@ 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 (0, import_git_semver_tags.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(`Found ${packageTags.length} package tags using configured pattern`, "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) {
-        log(
-          `Found ${packageTags.length} package tags using pattern: ${versionPrefix}packageName@...`,
-          "debug"
-        );
-        log(`Using tag: ${packageTags[0]}`, "debug");
-        return packageTags[0];
+      if (versionPrefix) {
+        const pattern1 = new RegExp(`^${escapedPackageName}@${escapeRegExp(versionPrefix)}`);
+        packageTags = allTags.filter((tag) => pattern1.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 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");
+      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];
+        }
+      }
+      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");
+        }
       } else {
-        log("No tags available in the repository", "debug");
+        log(`Using tag: ${packageTags[0]}`, "debug");
       }
-    } else {
-      log(`Using tag: ${packageTags[0]}`, "debug");
+      return packageTags[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");
@@ -1446,32 +1481,90 @@ function bumpVersion(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 || (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 packageVersion = manifestResult.version;
+        if (import_semver2.default.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 (import_semver2.default.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) {
@@ -1618,13 +1711,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;
@@ -1637,7 +1756,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;
@@ -1665,18 +1783,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) {
@@ -1689,7 +1804,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(
@@ -1821,7 +1939,7 @@ var PackageProcessor = class {
         this.versionPrefix,
         name,
         this.tagTemplate,
-        this.packageTagTemplate
+        this.fullConfig.packageSpecificTags
       );
       const tagMessage = `chore(release): ${name} ${nextVersion}`;
       addTag(packageTag);
@@ -1907,16 +2025,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) => {
@@ -1972,6 +2083,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");
@@ -1979,6 +2091,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");
@@ -1988,13 +2101,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");
@@ -2002,8 +2119,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) {
@@ -2024,7 +2158,6 @@ function createSingleStrategy(config) {
         mainPackage,
         versionPrefix,
         tagTemplate,
-        packageTagTemplate,
         commitMessage = "chore(release): ${version}",
         dryRun,
         skipHooks
@@ -2046,7 +2179,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 || "";
@@ -2077,7 +2213,7 @@ function createSingleStrategy(config) {
         formattedPrefix,
         packageName,
         tagTemplate,
-        packageTagTemplate
+        config.packageSpecificTags
       );
       const formattedCommitMessage = formatCommitMessage(commitMessage, nextVersion, packageName);
       await createGitCommitAndTag(
@@ -2110,7 +2246,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,