package-versioner 0.7.0 → 0.7.2

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 [];
   }
 }
@@ -732,6 +748,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);
   }
 }
@@ -761,9 +782,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 */);
   }
@@ -776,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
@@ -850,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");
@@ -1434,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) {
@@ -1606,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;
@@ -1625,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;
@@ -1653,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) {
@@ -1677,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(
@@ -1809,7 +1939,7 @@ var PackageProcessor = class {
         this.versionPrefix,
         name,
         this.tagTemplate,
-        this.packageTagTemplate
+        this.fullConfig.packageSpecificTags
       );
       const tagMessage = `chore(release): ${name} ${nextVersion}`;
       addTag(packageTag);
@@ -1895,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) => {
@@ -1917,16 +2040,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) {
@@ -1935,25 +2083,35 @@ function createSyncedStrategy(config) {
       }
       const files = [];
       const updatedPackages = [];
+      const processedPaths = /* @__PURE__ */ new Set();
       try {
-        const rootPkgPath = path7.join(packages.root, "package.json");
-        if (import_node_fs7.default.existsSync(rootPkgPath)) {
-          updatePackageVersion(rootPkgPath, nextVersion);
-          files.push(rootPkgPath);
-          updatedPackages.push("root");
+        if (packages.root) {
+          const rootPkgPath = path7.join(packages.root, "package.json");
+          if (import_node_fs7.default.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;
+        }
         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");
@@ -1961,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) {
@@ -1980,27 +2155,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 || "";
@@ -2031,7 +2213,7 @@ function createSingleStrategy(config) {
         formattedPrefix,
         packageName,
         tagTemplate,
-        packageTagTemplate
+        config.packageSpecificTags
       );
       const formattedCommitMessage = formatCommitMessage(commitMessage, nextVersion, packageName);
       await createGitCommitAndTag(
@@ -2064,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,
@@ -2117,7 +2298,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);
@@ -2162,6 +2343,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 = (0, import_node_process5.cwd)();
+      }
       this.workspaceCache = pkgsResult;
       return pkgsResult;
     } catch (error) {
@@ -2182,9 +2370,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;
     }
@@ -2263,6 +2464,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);
       }
     });