package-versioner 0.7.0 → 0.7.2

package/dist/index.js

@@ -1,14 +1,14 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import * as fs9 from "node:fs";
-import path7 from "node:path";
+import * as fs10 from "fs";
+import path8 from "path";
 import { Command } from "commander";
 
 // src/changelog/changelogRegenerator.ts
-import { execSync as execSync2 } from "node:child_process";
-import fs from "node:fs";
-import path from "node:path";
+import { execSync as execSync2 } from "child_process";
+import fs from "fs";
+import path from "path";
 
 // src/utils/logging.ts
 import chalk from "chalk";
@@ -92,7 +92,7 @@ function log(message, level = "info") {
 }
 
 // src/changelog/commitParser.ts
-import { execSync } from "node:child_process";
+import { execSync } from "child_process";
 var CONVENTIONAL_COMMIT_REGEX = /^(\w+)(?:\(([^)]+)\))?(!)?: (.+)(?:\n\n([\s\S]*))?/;
 var BREAKING_CHANGE_REGEX = /BREAKING CHANGE: ([\s\S]+?)(?:\n\n|$)/;
 function extractChangelogEntriesFromCommits(projectDir, revisionRange) {
@@ -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 [];
   }
 }
@@ -521,8 +537,8 @@ async function writeChangelog(content, outputPath, dryRun) {
 }
 
 // src/config.ts
-import * as fs2 from "node:fs";
-import { cwd } from "node:process";
+import * as fs2 from "fs";
+import { cwd } from "process";
 function loadConfig(configPath) {
   const localProcess = cwd();
   const filePath = configPath || `${localProcess}/version.config.json`;
@@ -544,7 +560,7 @@ function loadConfig(configPath) {
 }
 
 // src/core/versionEngine.ts
-import { cwd as cwd4 } from "node:process";
+import { cwd as cwd4 } from "process";
 import { getPackagesSync } from "@manypkg/get-packages";
 
 // src/errors/gitError.ts
@@ -591,14 +607,14 @@ function createVersionError(code, details) {
 }
 
 // src/core/versionStrategies.ts
-import fs8 from "node:fs";
-import * as path6 from "node:path";
+import fs9 from "fs";
+import * as path7 from "path";
 
 // src/git/commands.ts
-import { cwd as cwd2 } from "node:process";
+import { cwd as cwd2 } from "process";
 
 // src/git/commandExecutor.ts
-import { exec, execSync as nativeExecSync } from "node:child_process";
+import { exec, execSync as nativeExecSync } from "child_process";
 var execAsync = (command, options) => {
   const defaultOptions = { maxBuffer: 1024 * 1024 * 10, ...options };
   return new Promise((resolve, reject) => {
@@ -618,8 +634,8 @@ var execAsync = (command, options) => {
 var execSync3 = (command, args) => nativeExecSync(command, { maxBuffer: 1024 * 1024 * 10, ...args });
 
 // src/git/repository.ts
-import { existsSync, statSync } from "node:fs";
-import { join } from "node:path";
+import { existsSync, statSync } from "fs";
+import { join } from "path";
 function isGitRepository(directory) {
   const gitDir = join(directory, ".git");
   if (!existsSync(gitDir)) {
@@ -699,6 +715,11 @@ async function gitProcess(options) {
     }
   } catch (err) {
     const errorMessage = err instanceof Error ? err.message : String(err);
+    log(`Git process error: ${errorMessage}`, "error");
+    if (err instanceof Error && err.stack) {
+      console.error("Git process stack trace:");
+      console.error(err.stack);
+    }
     throw createGitError("GIT_PROCESS_ERROR" /* GIT_PROCESS_ERROR */, errorMessage);
   }
 }
@@ -728,9 +749,16 @@ async function createGitCommitAndTag(files, nextTag, commitMessage, skipHooks, d
     const errorMessage = error instanceof Error ? error.message : String(error);
     log(`Failed to create git commit and tag: ${errorMessage}`, "error");
     if (error instanceof Error) {
+      console.error("Git operation error details:");
       console.error(error.stack || error.message);
+      if (errorMessage.includes("Command failed:")) {
+        const cmdOutput = errorMessage.split("Command failed:")[1];
+        if (cmdOutput) {
+          console.error("Git command output:", cmdOutput.trim());
+        }
+      }
     } else {
-      console.error(error);
+      console.error("Unknown git error:", error);
     }
     throw new GitError(`Git operation failed: ${errorMessage}`, "GIT_ERROR" /* GIT_ERROR */);
   }
@@ -743,38 +771,42 @@ import { getSemverTags } from "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
@@ -817,56 +849,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 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");
@@ -878,11 +925,12 @@ async function getLatestTagForPackage(packageName, versionPrefix) {
 }
 
 // src/package/packageManagement.ts
-import fs4 from "node:fs";
+import fs4 from "fs";
+import path3 from "path";
 
 // src/cargo/cargoHandler.ts
-import fs3 from "node:fs";
-import path2 from "node:path";
+import fs3 from "fs";
+import path2 from "path";
 import * as TOML from "smol-toml";
 function getCargoInfo(cargoPath) {
   var _a;
@@ -968,13 +1016,13 @@ function updatePackageVersion(packagePath, version) {
 }
 
 // src/package/packageProcessor.ts
-import * as fs7 from "node:fs";
-import path5 from "node:path";
-import { exit } from "node:process";
+import * as fs8 from "fs";
+import path6 from "path";
+import { exit } from "process";
 
 // src/changelog/changelogManager.ts
-import * as fs5 from "node:fs";
-import * as path3 from "node:path";
+import * as fs5 from "fs";
+import * as path4 from "path";
 function createChangelog(_packagePath, packageName) {
   return {
     projectName: packageName,
@@ -990,7 +1038,7 @@ function parseChangelog(filePath) {
     fs5.readFileSync(filePath, "utf8");
     log(`Parsed changelog at ${filePath}`, "info");
     return {
-      projectName: path3.basename(path3.dirname(filePath)),
+      projectName: path4.basename(path4.dirname(filePath)),
       unreleased: [],
       versions: []
     };
@@ -1259,7 +1307,7 @@ function generateChangelogContent(changelog, repoUrl, format = "keep-a-changelog
 }
 function updateChangelog(packagePath, packageName, version, entries, repoUrl, format = "keep-a-changelog") {
   try {
-    const changelogPath = path3.join(packagePath, "CHANGELOG.md");
+    const changelogPath = path4.join(packagePath, "CHANGELOG.md");
     let changelog;
     if (fs5.existsSync(changelogPath)) {
       const existingChangelog = parseChangelog(changelogPath);
@@ -1298,16 +1346,16 @@ function capitalizeFirstLetter(input) {
 }
 
 // src/core/versionCalculator.ts
-import { cwd as cwd3 } from "node:process";
+import { cwd as cwd3 } from "process";
 import { Bumper } from "conventional-recommended-bump";
 import semver2 from "semver";
 
 // src/utils/manifestHelpers.ts
-import fs6 from "node:fs";
-import path4 from "node:path";
+import fs6 from "fs";
+import path5 from "path";
 function getVersionFromManifests(packageDir) {
-  const packageJsonPath = path4.join(packageDir, "package.json");
-  const cargoTomlPath = path4.join(packageDir, "Cargo.toml");
+  const packageJsonPath = path5.join(packageDir, "package.json");
+  const cargoTomlPath = path5.join(packageDir, "Cargo.toml");
   if (fs6.existsSync(packageJsonPath)) {
     try {
       const packageJson = JSON.parse(fs6.readFileSync(packageJsonPath, "utf-8"));
@@ -1352,14 +1400,15 @@ function getVersionFromManifests(packageDir) {
   };
 }
 function throwIfNoManifestsFound(packageDir) {
-  const packageJsonPath = path4.join(packageDir, "package.json");
-  const cargoTomlPath = path4.join(packageDir, "Cargo.toml");
+  const packageJsonPath = path5.join(packageDir, "package.json");
+  const cargoTomlPath = path5.join(packageDir, "Cargo.toml");
   throw new Error(
     `Neither package.json nor Cargo.toml found at ${packageDir}. Checked paths: ${packageJsonPath}, ${cargoTomlPath}. Cannot determine version.`
   );
 }
 
 // src/utils/versionUtils.ts
+import fs7 from "fs";
 import semver from "semver";
 import * as TOML2 from "smol-toml";
 var STANDARD_BUMP_TYPES = ["major", "minor", "patch"];
@@ -1399,32 +1448,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 || 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 packageVersion = manifestResult.version;
+        if (semver2.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 (semver2.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) {
@@ -1571,13 +1678,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;
@@ -1590,7 +1723,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;
@@ -1618,18 +1750,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) {
@@ -1642,7 +1771,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(
@@ -1719,9 +1851,9 @@ var PackageProcessor = class {
         }
         let repoUrl;
         try {
-          const packageJsonPath2 = path5.join(pkgPath, "package.json");
-          if (fs7.existsSync(packageJsonPath2)) {
-            const packageJson = JSON.parse(fs7.readFileSync(packageJsonPath2, "utf8"));
+          const packageJsonPath2 = path6.join(pkgPath, "package.json");
+          if (fs8.existsSync(packageJsonPath2)) {
+            const packageJson = JSON.parse(fs8.readFileSync(packageJsonPath2, "utf8"));
             if (packageJson.repository) {
               if (typeof packageJson.repository === "string") {
                 repoUrl = packageJson.repository;
@@ -1748,8 +1880,8 @@ var PackageProcessor = class {
           this.fullConfig.changelogFormat
         );
       }
-      const packageJsonPath = path5.join(pkgPath, "package.json");
-      if (fs7.existsSync(packageJsonPath)) {
+      const packageJsonPath = path6.join(pkgPath, "package.json");
+      if (fs8.existsSync(packageJsonPath)) {
         updatePackageVersion(packageJsonPath, nextVersion);
       }
       const cargoEnabled = ((_a = this.fullConfig.cargo) == null ? void 0 : _a.enabled) !== false;
@@ -1757,14 +1889,14 @@ var PackageProcessor = class {
         const cargoPaths = (_b = this.fullConfig.cargo) == null ? void 0 : _b.paths;
         if (cargoPaths && cargoPaths.length > 0) {
           for (const cargoPath of cargoPaths) {
-            const resolvedCargoPath = path5.resolve(pkgPath, cargoPath, "Cargo.toml");
-            if (fs7.existsSync(resolvedCargoPath)) {
+            const resolvedCargoPath = path6.resolve(pkgPath, cargoPath, "Cargo.toml");
+            if (fs8.existsSync(resolvedCargoPath)) {
               updatePackageVersion(resolvedCargoPath, nextVersion);
             }
           }
         } else {
-          const cargoTomlPath = path5.join(pkgPath, "Cargo.toml");
-          if (fs7.existsSync(cargoTomlPath)) {
+          const cargoTomlPath = path6.join(pkgPath, "Cargo.toml");
+          if (fs8.existsSync(cargoTomlPath)) {
             updatePackageVersion(cargoTomlPath, nextVersion);
           }
         }
@@ -1774,7 +1906,7 @@ var PackageProcessor = class {
         this.versionPrefix,
         name,
         this.tagTemplate,
-        this.packageTagTemplate
+        this.fullConfig.packageSpecificTags
       );
       const tagMessage = `chore(release): ${name} ${nextVersion}`;
       addTag(packageTag);
@@ -1801,8 +1933,8 @@ var PackageProcessor = class {
     }
     const filesToCommit = [];
     for (const info of updatedPackagesInfo) {
-      const packageJsonPath = path5.join(info.path, "package.json");
-      if (fs7.existsSync(packageJsonPath)) {
+      const packageJsonPath = path6.join(info.path, "package.json");
+      if (fs8.existsSync(packageJsonPath)) {
         filesToCommit.push(packageJsonPath);
       }
       const cargoEnabled = ((_c = this.fullConfig.cargo) == null ? void 0 : _c.enabled) !== false;
@@ -1810,14 +1942,14 @@ var PackageProcessor = class {
         const cargoPaths = (_d = this.fullConfig.cargo) == null ? void 0 : _d.paths;
         if (cargoPaths && cargoPaths.length > 0) {
           for (const cargoPath of cargoPaths) {
-            const resolvedCargoPath = path5.resolve(info.path, cargoPath, "Cargo.toml");
-            if (fs7.existsSync(resolvedCargoPath)) {
+            const resolvedCargoPath = path6.resolve(info.path, cargoPath, "Cargo.toml");
+            if (fs8.existsSync(resolvedCargoPath)) {
               filesToCommit.push(resolvedCargoPath);
             }
           }
         } else {
-          const cargoTomlPath = path5.join(info.path, "Cargo.toml");
-          if (fs7.existsSync(cargoTomlPath)) {
+          const cargoTomlPath = path6.join(info.path, "Cargo.toml");
+          if (fs8.existsSync(cargoTomlPath)) {
             filesToCommit.push(cargoTomlPath);
           }
         }
@@ -1860,16 +1992,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) => {
@@ -1882,16 +2007,41 @@ function createSyncedStrategy(config) {
         commitMessage = "chore(release): v${version}",
         prereleaseIdentifier,
         dryRun,
-        skipHooks
+        skipHooks,
+        mainPackage
       } = config;
       const formattedPrefix = formatVersionPrefix(versionPrefix || "v");
       const latestTag = await getLatestTag();
+      let mainPkgPath = packages.root;
+      let mainPkgName;
+      if (mainPackage) {
+        const mainPkg = packages.packages.find((p) => p.packageJson.name === mainPackage);
+        if (mainPkg) {
+          mainPkgPath = mainPkg.dir;
+          mainPkgName = mainPkg.packageJson.name;
+          log(`Using ${mainPkgName} as primary package for version determination`, "info");
+        } else {
+          log(
+            `Main package '${mainPackage}' not found. Using root package for version determination.`,
+            "warning"
+          );
+        }
+      }
+      if (!mainPkgPath) {
+        mainPkgPath = process.cwd();
+        log(
+          `No valid package path found, using current working directory: ${mainPkgPath}`,
+          "warning"
+        );
+      }
       const nextVersion = await calculateVersion(config, {
         latestTag,
         versionPrefix: formattedPrefix,
         branchPattern,
         baseBranch,
         prereleaseIdentifier,
+        path: mainPkgPath,
+        name: mainPkgName,
         type: config.type
       });
       if (!nextVersion) {
@@ -1900,25 +2050,35 @@ function createSyncedStrategy(config) {
       }
       const files = [];
       const updatedPackages = [];
+      const processedPaths = /* @__PURE__ */ new Set();
       try {
-        const rootPkgPath = path6.join(packages.root, "package.json");
-        if (fs8.existsSync(rootPkgPath)) {
-          updatePackageVersion(rootPkgPath, nextVersion);
-          files.push(rootPkgPath);
-          updatedPackages.push("root");
+        if (packages.root) {
+          const rootPkgPath = path7.join(packages.root, "package.json");
+          if (fs9.existsSync(rootPkgPath)) {
+            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");
         }
       } catch (error) {
         const errMessage = error instanceof Error ? error.message : String(error);
         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;
         }
-        const packageJsonPath = path6.join(pkg.dir, "package.json");
         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");
@@ -1926,8 +2086,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) {
@@ -1945,27 +2122,34 @@ function createSingleStrategy(config) {
     try {
       const {
         packages: configPackages,
+        mainPackage,
         versionPrefix,
         tagTemplate,
-        packageTagTemplate,
         commitMessage = "chore(release): ${version}",
         dryRun,
         skipHooks
       } = config;
-      if (!configPackages || configPackages.length !== 1) {
+      let packageName;
+      if (mainPackage) {
+        packageName = mainPackage;
+      } else if (configPackages && configPackages.length === 1) {
+        packageName = configPackages[0];
+      } else {
         throw createVersionError(
           "INVALID_CONFIG" /* INVALID_CONFIG */,
-          "Single mode requires exactly one package name"
+          "Single mode requires either mainPackage or exactly one package in the packages array"
         );
       }
-      const packageName = configPackages[0];
       const pkg = packages.packages.find((p) => p.packageJson.name === packageName);
       if (!pkg) {
         throw createVersionError("PACKAGE_NOT_FOUND" /* PACKAGE_NOT_FOUND */, packageName);
       }
       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 || "";
@@ -1988,7 +2172,7 @@ function createSingleStrategy(config) {
         log(`No version change needed for ${packageName}`, "info");
         return;
       }
-      const packageJsonPath = path6.join(pkgPath, "package.json");
+      const packageJsonPath = path7.join(pkgPath, "package.json");
       updatePackageVersion(packageJsonPath, nextVersion);
       log(`Updated package ${packageName} to version ${nextVersion}`, "success");
       const nextTag = formatTag(
@@ -1996,7 +2180,7 @@ function createSingleStrategy(config) {
         formattedPrefix,
         packageName,
         tagTemplate,
-        packageTagTemplate
+        config.packageSpecificTags
       );
       const formattedCommitMessage = formatCommitMessage(commitMessage, nextVersion, packageName);
       await createGitCommitAndTag(
@@ -2029,7 +2213,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,
@@ -2082,7 +2265,7 @@ function createStrategy(config) {
   if (config.synced) {
     return createSyncedStrategy(config);
   }
-  if (((_a = config.packages) == null ? void 0 : _a.length) === 1) {
+  if (config.mainPackage || ((_a = config.packages) == null ? void 0 : _a.length) === 1) {
     return createSingleStrategy(config);
   }
   return createAsyncStrategy(config);
@@ -2127,6 +2310,13 @@ var VersionEngine = class {
       if (!pkgsResult || !pkgsResult.packages) {
         throw createVersionError("PACKAGES_NOT_FOUND" /* PACKAGES_NOT_FOUND */);
       }
+      if (!pkgsResult.root) {
+        log(
+          "Root path is undefined in packages result, setting to current working directory",
+          "warning"
+        );
+        pkgsResult.root = cwd4();
+      }
       this.workspaceCache = pkgsResult;
       return pkgsResult;
     } catch (error) {
@@ -2147,9 +2337,22 @@ var VersionEngine = class {
     } catch (error) {
       if (error instanceof VersionError || error instanceof GitError) {
         log(`Version engine failed: ${error.message} (${error.code || "UNKNOWN"})`, "error");
+        if (error instanceof GitError) {
+          console.error("Git error details:");
+          if (error.message.includes("Command failed:")) {
+            const cmdOutput = error.message.split("Command failed:")[1];
+            if (cmdOutput) {
+              console.error("Command output:", cmdOutput.trim());
+            }
+          }
+        }
       } else {
         const errorMessage = error instanceof Error ? error.message : String(error);
         log(`Version engine failed: ${errorMessage}`, "error");
+        if (error instanceof Error && error.stack) {
+          console.error("Error stack trace:");
+          console.error(error.stack);
+        }
       }
       throw error;
     }
@@ -2166,11 +2369,11 @@ var VersionEngine = class {
 // src/index.ts
 function getPackageVersion() {
   try {
-    const packageJsonPath = path7.resolve(
-      path7.dirname(import.meta.url.replace("file:", "")),
+    const packageJsonPath = path8.resolve(
+      path8.dirname(import.meta.url.replace("file:", "")),
       "../package.json"
     );
-    const packageJsonContent = fs9.readFileSync(packageJsonPath, "utf-8");
+    const packageJsonContent = fs10.readFileSync(packageJsonPath, "utf-8");
     const packageJson = JSON.parse(packageJsonContent);
     return packageJson.version || "0.0.0";
   } catch (error) {
@@ -2227,6 +2430,16 @@ async function run() {
         printJsonOutput();
       } catch (error) {
         log(error instanceof Error ? error.message : String(error), "error");
+        if (error instanceof Error) {
+          console.error("Error details:");
+          console.error(error.stack || error.message);
+          if (error.message.includes("Command failed:")) {
+            const cmdOutput = error.message.split("Command failed:")[1];
+            if (cmdOutput) {
+              console.error("Command output:", cmdOutput.trim());
+            }
+          }
+        }
         process.exit(1);
       }
     });
@@ -2253,7 +2466,7 @@ async function run() {
         const content = await regenerateChangelog(regenerateOptions);
         await writeChangelog(
           content,
-          path7.resolve(options.projectDir, options.output),
+          path8.resolve(options.projectDir, options.output),
           options.dryRun
         );
         if (!options.dryRun) {