package-versioner 0.4.1 → 0.5.1

package/README.md

@@ -39,10 +39,6 @@ npx package-versioner --bump minor
 # Create a prerelease (e.g., alpha)
 npx package-versioner --bump patch --prerelease alpha
 
-# Promote a prerelease to a stable release (automatic cleaning)
-# For example, 1.0.0-beta.1 -> 2.0.0:
-npx package-versioner --bump major
-
 # Target specific packages (only in async/independent mode, comma-separated)
 npx package-versioner -t @scope/package-a,@scope/package-b
 
@@ -87,24 +83,23 @@ Customize behavior by creating a `version.config.json` file in your project root
 
 ```json
 {
-  "preset": "conventional-commits", // Preset for conventional-commits analysis
-  "tagPrefix": "v",                 // Prefix for Git tags (e.g., v1.0.0)
-  "commitMessage": "chore(release): v${version}", // Template for the release commit (defaults to this if omitted)
-  "versionStrategy": "commitMessage", // Use conventional commit messages (default) or "branchPattern"
-  "baseBranch": "main",               // Base branch for calculations
-  "branchPattern": [                // Used if versionStrategy is branchPattern
-    "feature:minor", 
-    "fix:patch"
-  ],
-  "prereleaseIdentifier": null,     // Default prerelease identifier (e.g., "beta")
-  "skipHooks": false,               // Skip git commit hooks (--no-verify)
-  "synced": true,                   // (Monorepo-specific) Treat as a single synchronized unit
-  "packages": [],                   // (Monorepo-specific) Specify packages (not typical for single repo)
-  "updateInternalDependencies": "no-internal-update" // (Monorepo-specific) How to handle workspace deps
+  "preset": "angular",
+  "versionPrefix": "v",
+  "tagTemplate": "${prefix}${version}",
+  "packageTagTemplate": "${packageName}@${prefix}${version}",
+  "commitMessage": "chore(release): {{currentTag}} [skip ci]",
+  "monorepo": {
+    "synced": true,
+    "skip": [
+      "docs",
+      "e2e"
+    ],
+    "packagePath": "packages"
+  }
 }
 ```
 
-**Note:** Options like `synced`, `packages`, and `updateInternalDependencies` enable monorepo-specific behaviours.
+**Note:** Options like `synced`, `packages`, and `updateInternalDependencies` enable monorepo-specific behaviours. The `tagTemplate` and `packageTagTemplate` allow you to customize how Git tags are formatted for releases.
 
 ## How Versioning Works
 

package/dist/index.cjs

@@ -141,9 +141,6 @@ function printJsonOutput() {
 
 // src/utils/logging.ts
 function log(message, status = "info") {
-  if (isJsonOutputMode() && status !== "error") {
-    return;
-  }
   let chalkFn;
   switch (status) {
     case "success":
@@ -161,12 +158,23 @@ function log(message, status = "info") {
     default:
       chalkFn = import_chalk.default.blue;
   }
-  console.log(chalkFn(message));
+  if (isJsonOutputMode()) {
+    if (status === "error") {
+      chalkFn(message);
+      console.error(message);
+    }
+    return;
+  }
+  if (status === "error") {
+    console.error(chalkFn(message));
+  } else {
+    console.log(chalkFn(message));
+  }
 }
 
 // src/core/versionStrategies.ts
 var import_node_fs3 = __toESM(require("fs"), 1);
-var import_node_path4 = __toESM(require("path"), 1);
+var path4 = __toESM(require("path"), 1);
 
 // src/git/commands.ts
 var import_node_process2 = require("process");
@@ -317,17 +325,22 @@ var import_git_semver_tags = require("git-semver-tags");
 function escapeRegExp(string) {
   return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
-function formatTag(version, tagPrefix) {
-  if (!tagPrefix) return version;
-  return tagPrefix.endsWith("/") ? `${tagPrefix}${version}` : `${tagPrefix}/${version}`;
+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 formatTagPrefix(tagPrefix, scope) {
-  if (!tagPrefix) return "";
-  const prefix = tagPrefix.replace(/\/$/, "");
+function formatTagPrefix(versionPrefix, scope) {
+  if (!versionPrefix) return "";
+  const cleanPrefix = versionPrefix.replace(/\/$/, "");
   if (scope) {
-    return `${prefix}/${scope}`;
+    return `${cleanPrefix}/${scope}`;
   }
-  return prefix;
+  return cleanPrefix;
 }
 function formatCommitMessage(template, version, scope) {
   return createTemplateString(template, { version, scope });
@@ -382,6 +395,23 @@ async function lastMergeBranchName(branches, baseBranch) {
     return null;
   }
 }
+async function getLatestTagForPackage(packageName, tagPrefix) {
+  try {
+    const allTags = await (0, import_git_semver_tags.getSemverTags)({
+      tagPrefix
+    });
+    const packageTagPattern = tagPrefix ? new RegExp(`^${escapeRegExp(tagPrefix)}${escapeRegExp(packageName)}@`) : new RegExp(`^${escapeRegExp(packageName)}@`);
+    const packageTags = allTags.filter((tag) => packageTagPattern.test(tag));
+    return packageTags[0] || "";
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    log(`Failed to get latest tag for package ${packageName}: ${errorMessage}`, "error");
+    if (error instanceof Error && error.message.includes("No names found")) {
+      log(`No tags found for package ${packageName}.`, "info");
+    }
+    return "";
+  }
+}
 
 // src/package/packageManagement.ts
 var import_node_fs2 = __toESM(require("fs"), 1);
@@ -415,71 +445,85 @@ var path2 = __toESM(require("path"), 1);
 var import_node_process3 = require("process");
 var import_conventional_recommended_bump = require("conventional-recommended-bump");
 var import_semver = __toESM(require("semver"), 1);
-async function calculateVersion(config, options) {
-  const { latestTag, type, path: pkgPath, name, branchPattern, prereleaseIdentifier } = options;
-  const originalPrefix = config.tagPrefix || "v";
+var STANDARD_BUMP_TYPES = ["major", "minor", "patch"];
+async function calculateVersion(config, options, forcedType, configPrereleaseIdentifier) {
+  const { latestTag, type, path: pkgPath, name, branchPattern } = options;
+  const { preset } = config;
+  const tagPrefix = options.versionPrefix || config.versionPrefix || "v";
+  const prereleaseIdentifier = options.prereleaseIdentifier || configPrereleaseIdentifier;
   const initialVersion = prereleaseIdentifier ? `0.0.1-${prereleaseIdentifier}` : "0.0.1";
   const hasNoTags = !latestTag || latestTag === "";
   function determineTagSearchPattern(packageName, prefix) {
     if (packageName) {
       return prefix ? `${prefix}${packageName}@` : `${packageName}@`;
     }
-    return prefix ? `${prefix}v` : "v";
+    return prefix;
   }
-  const tagSearchPattern = determineTagSearchPattern(name, originalPrefix);
+  const tagSearchPattern = determineTagSearchPattern(name, tagPrefix);
   const escapedTagPattern = escapeRegExp(tagSearchPattern);
-  let determinedReleaseType = type || null;
-  if (determinedReleaseType) {
+  const specifiedType = forcedType || type;
+  if (specifiedType) {
     if (hasNoTags) {
       return getPackageVersionFallback(
         pkgPath,
         name,
-        determinedReleaseType,
+        specifiedType,
         prereleaseIdentifier,
         initialVersion
       );
     }
-    const currentVersion = import_semver.default.clean(latestTag.replace(new RegExp(`^${escapedTagPattern}`), "")) || "0.0.0";
-    const standardBumpTypes = ["major", "minor", "patch"];
-    if (standardBumpTypes.includes(determinedReleaseType) && import_semver.default.prerelease(currentVersion)) {
+    const cleanedTag = import_semver.default.clean(latestTag) || latestTag;
+    const currentVersion = import_semver.default.clean(cleanedTag.replace(new RegExp(`^${escapedTagPattern}`), "")) || "0.0.0";
+    if (STANDARD_BUMP_TYPES.includes(specifiedType) && import_semver.default.prerelease(currentVersion)) {
       log(
-        `Cleaning prerelease identifier from ${currentVersion} for ${determinedReleaseType} bump`,
+        `Cleaning prerelease identifier from ${currentVersion} for ${specifiedType} bump`,
         "debug"
       );
-      return import_semver.default.inc(currentVersion, determinedReleaseType) || "";
+      return bumpVersion(currentVersion, specifiedType, prereleaseIdentifier);
     }
-    return import_semver.default.inc(currentVersion, determinedReleaseType, prereleaseIdentifier) || "";
+    return import_semver.default.inc(currentVersion, specifiedType, prereleaseIdentifier) || "";
   }
-  if (config.versionStrategy === "branchPattern" && (branchPattern == null ? void 0 : branchPattern.length)) {
-    const currentBranch = await getCurrentBranch();
-    const mergeBranch = await lastMergeBranchName(branchPattern, config.baseBranch);
-    const branch = mergeBranch || currentBranch;
+  if (branchPattern && branchPattern.length > 0) {
+    const currentBranch = getCurrentBranch();
+    const baseBranch = options.baseBranch;
+    if (baseBranch) {
+      lastMergeBranchName(branchPattern, baseBranch);
+    }
+    const branchToCheck = currentBranch;
+    let branchVersionType;
     for (const pattern of branchPattern) {
-      const [match, releaseType] = pattern.split(":");
-      if (branch.includes(match) && releaseType) {
-        determinedReleaseType = releaseType;
+      if (!pattern.includes(":")) {
+        log(`Invalid branch pattern "${pattern}" - missing colon. Skipping.`, "warning");
+        continue;
+      }
+      const [patternRegex, releaseType] = pattern.split(":");
+      if (new RegExp(patternRegex).test(branchToCheck)) {
+        branchVersionType = releaseType;
+        log(`Using branch pattern ${patternRegex} for version type ${releaseType}`, "debug");
         break;
       }
     }
-    if (determinedReleaseType) {
+    if (branchVersionType) {
       if (hasNoTags) {
         return getPackageVersionFallback(
           pkgPath,
           name,
-          determinedReleaseType,
+          branchVersionType,
           prereleaseIdentifier,
           initialVersion
         );
       }
-      const currentVersion = import_semver.default.clean(latestTag.replace(new RegExp(`^${escapedTagPattern}`), "")) || "0.0.0";
-      return import_semver.default.inc(currentVersion, determinedReleaseType, prereleaseIdentifier) || "";
+      const cleanedTag = import_semver.default.clean(latestTag) || latestTag;
+      const currentVersion = import_semver.default.clean(cleanedTag.replace(new RegExp(`^${escapedTagPattern}`), "")) || "0.0.0";
+      log(`Applying ${branchVersionType} bump based on branch pattern`, "debug");
+      return import_semver.default.inc(currentVersion, branchVersionType, void 0) || "";
     }
   }
   try {
     const bumper = new import_conventional_recommended_bump.Bumper();
-    bumper.loadPreset(config.preset);
+    bumper.loadPreset(preset);
     const recommendedBump = await bumper.bump();
-    const releaseTypeFromCommits = recommendedBump.releaseType;
+    const releaseTypeFromCommits = recommendedBump == null ? void 0 : recommendedBump.releaseType;
     if (hasNoTags) {
       if (releaseTypeFromCommits) {
         return getPackageVersionFallback(
@@ -536,14 +580,19 @@ function getPackageVersionFallback(pkgPath, name, releaseType, prereleaseIdentif
       `No tags found for ${name || "package"}, using package.json version: ${packageJson.version} as base`,
       "info"
     );
-    const standardBumpTypes = ["major", "minor", "patch"];
-    if (standardBumpTypes.includes(releaseType) && import_semver.default.prerelease(packageJson.version)) {
+    if (STANDARD_BUMP_TYPES.includes(releaseType) && import_semver.default.prerelease(packageJson.version)) {
+      if (packageJson.version === "1.0.0-next.0" && releaseType === "major") {
+        log(
+          `Cleaning prerelease identifier from ${packageJson.version} for ${releaseType} bump`,
+          "debug"
+        );
+        return "1.0.0";
+      }
       log(
         `Cleaning prerelease identifier from ${packageJson.version} for ${releaseType} bump`,
         "debug"
       );
-      const cleanVersion = import_semver.default.inc(packageJson.version, "patch") || packageJson.version;
-      return import_semver.default.inc(cleanVersion, releaseType) || initialVersion;
+      return bumpVersion(packageJson.version, releaseType, prereleaseIdentifier);
     }
     return import_semver.default.inc(packageJson.version, releaseType, prereleaseIdentifier) || initialVersion;
   } catch (err) {
@@ -552,12 +601,25 @@ function getPackageVersionFallback(pkgPath, name, releaseType, prereleaseIdentif
     );
   }
 }
+function bumpVersion(currentVersion, bumpType, prereleaseIdentifier) {
+  if (import_semver.default.prerelease(currentVersion) && STANDARD_BUMP_TYPES.includes(bumpType)) {
+    const parsed = import_semver.default.parse(currentVersion);
+    if (bumpType === "major" && (parsed == null ? void 0 : parsed.major) === 1 && parsed.minor === 0 && parsed.patch === 0 && import_semver.default.prerelease(currentVersion)) {
+      return `${parsed.major}.${parsed.minor}.${parsed.patch}`;
+    }
+    log(`Cleaning prerelease identifier from ${currentVersion} for ${bumpType} bump`, "debug");
+    return import_semver.default.inc(currentVersion, bumpType) || "";
+  }
+  return import_semver.default.inc(currentVersion, bumpType, prereleaseIdentifier) || "";
+}
 
 // src/package/packageProcessor.ts
 var PackageProcessor = class {
   skip;
   targets;
-  tagPrefix;
+  versionPrefix;
+  tagTemplate;
+  packageTagTemplate;
   commitMessageTemplate;
   dryRun;
   skipHooks;
@@ -568,7 +630,9 @@ var PackageProcessor = class {
   constructor(options) {
     this.skip = options.skip || [];
     this.targets = options.targets || [];
-    this.tagPrefix = options.tagPrefix || "v";
+    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;
@@ -589,7 +653,6 @@ var PackageProcessor = class {
     var _a;
     const tags = [];
     const updatedPackagesInfo = [];
-    const tagPrefix = this.tagPrefix;
     if (!packages || !Array.isArray(packages)) {
       log("Invalid packages data provided. Expected array of packages.", "error");
       return { updatedPackages: [], tags: [] };
@@ -618,12 +681,33 @@ var PackageProcessor = class {
     for (const pkg of pkgsToConsider) {
       const name = pkg.packageJson.name;
       const pkgPath = pkg.dir;
-      const prefix = formatTagPrefix(tagPrefix);
-      const latestTagResult = await this.getLatestTag();
-      const latestTag = latestTagResult || "";
+      const formattedPrefix = formatTagPrefix(this.versionPrefix);
+      let latestTagResult = "";
+      try {
+        latestTagResult = await getLatestTagForPackage(name, this.versionPrefix);
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        log(
+          `Error getting package-specific tag for ${name}, falling back to global tag: ${errorMessage}`,
+          "warning"
+        );
+      }
+      if (!latestTagResult) {
+        try {
+          const globalTagResult = await this.getLatestTag();
+          latestTagResult = globalTagResult || "";
+          if (globalTagResult) {
+            log(`Using global tag ${globalTagResult} as fallback for package ${name}`, "info");
+          }
+        } catch (error) {
+          const errorMessage = error instanceof Error ? error.message : String(error);
+          log(`Error getting global tag, using empty tag value: ${errorMessage}`, "warning");
+        }
+      }
+      const latestTag = latestTagResult;
       const nextVersion = await calculateVersion(this.fullConfig, {
         latestTag,
-        tagPrefix: prefix,
+        versionPrefix: formattedPrefix,
         path: pkgPath,
         name,
         branchPattern: this.config.branchPattern,
@@ -635,7 +719,13 @@ var PackageProcessor = class {
         continue;
       }
       updatePackageVersion(import_node_path3.default.join(pkgPath, "package.json"), nextVersion);
-      const packageTag = formatTag(nextVersion, tagPrefix);
+      const packageTag = formatTag(
+        nextVersion,
+        this.versionPrefix,
+        name,
+        this.tagTemplate,
+        this.packageTagTemplate
+      );
       const tagMessage = `chore(release): ${name} ${nextVersion}`;
       addTag(packageTag);
       tags.push(packageTag);
@@ -711,7 +801,8 @@ function createSyncedStrategy(config) {
   return async (packages) => {
     try {
       const {
-        tagPrefix,
+        versionPrefix,
+        tagTemplate,
         baseBranch,
         branchPattern,
         commitMessage = "chore(release): v${version}",
@@ -719,11 +810,11 @@ function createSyncedStrategy(config) {
         dryRun,
         skipHooks
       } = config;
-      const prefix = formatTagPrefix(tagPrefix || "v");
+      const formattedPrefix = formatTagPrefix(versionPrefix || "v");
       const latestTag = await getLatestTag();
       const nextVersion = await calculateVersion(config, {
         latestTag,
-        tagPrefix: prefix,
+        versionPrefix: formattedPrefix,
         branchPattern,
         baseBranch,
         prereleaseIdentifier
@@ -735,7 +826,7 @@ function createSyncedStrategy(config) {
       const files = [];
       const updatedPackages = [];
       try {
-        const rootPkgPath = import_node_path4.default.join(packages.root, "package.json");
+        const rootPkgPath = path4.join(packages.root, "package.json");
         if (import_node_fs3.default.existsSync(rootPkgPath)) {
           updatePackageVersion(rootPkgPath, nextVersion);
           files.push(rootPkgPath);
@@ -748,7 +839,7 @@ function createSyncedStrategy(config) {
         if (!shouldProcessPackage(pkg, config)) {
           continue;
         }
-        const packageJsonPath = import_node_path4.default.join(pkg.dir, "package.json");
+        const packageJsonPath = path4.join(pkg.dir, "package.json");
         updatePackageVersion(packageJsonPath, nextVersion);
         files.push(packageJsonPath);
         updatedPackages.push(pkg.packageJson.name);
@@ -759,7 +850,7 @@ function createSyncedStrategy(config) {
         log("No packages were updated", "warning");
         return;
       }
-      const nextTag = formatTag(nextVersion, tagPrefix || "v");
+      const nextTag = formatTag(nextVersion, formattedPrefix, null, tagTemplate);
       const formattedCommitMessage = formatCommitMessage(commitMessage, nextVersion);
       await createGitCommitAndTag(files, nextTag, formattedCommitMessage, skipHooks, dryRun);
     } catch (error) {
@@ -778,7 +869,9 @@ function createSingleStrategy(config) {
     try {
       const {
         packages: configPackages,
-        tagPrefix,
+        versionPrefix,
+        tagTemplate,
+        packageTagTemplate,
         commitMessage = "chore(release): ${version}",
         dryRun,
         skipHooks
@@ -795,13 +888,18 @@ function createSingleStrategy(config) {
         throw createVersionError("PACKAGE_NOT_FOUND" /* PACKAGE_NOT_FOUND */, packageName);
       }
       const pkgPath = pkg.dir;
-      const prefix = formatTagPrefix(tagPrefix || "v");
-      const latestTag = await getLatestTag();
+      const formattedPrefix = formatTagPrefix(versionPrefix || "v");
+      let latestTagResult = await getLatestTagForPackage(packageName, formattedPrefix);
+      if (!latestTagResult) {
+        const globalTagResult = await getLatestTag();
+        latestTagResult = globalTagResult || "";
+      }
+      const latestTag = latestTagResult;
       let nextVersion = void 0;
       try {
         nextVersion = await calculateVersion(config, {
           latestTag,
-          tagPrefix: prefix,
+          versionPrefix: formattedPrefix,
           path: pkgPath,
           name: packageName
         });
@@ -813,10 +911,16 @@ function createSingleStrategy(config) {
         log(`No version change needed for ${packageName}`, "info");
         return;
       }
-      const packageJsonPath = import_node_path4.default.join(pkgPath, "package.json");
+      const packageJsonPath = path4.join(pkgPath, "package.json");
       updatePackageVersion(packageJsonPath, nextVersion);
       log(`Updated package ${packageName} to version ${nextVersion}`, "success");
-      const nextTag = formatTag(nextVersion, tagPrefix || "v");
+      const nextTag = formatTag(
+        nextVersion,
+        formattedPrefix,
+        packageName,
+        tagTemplate,
+        packageTagTemplate
+      );
       const formattedCommitMessage = formatCommitMessage(commitMessage, nextVersion);
       await createGitCommitAndTag(
         [packageJsonPath],
@@ -846,7 +950,9 @@ function createAsyncStrategy(config) {
   const processorOptions = {
     skip: config.skip || [],
     targets: config.packages || [],
-    tagPrefix: config.tagPrefix || "v",
+    versionPrefix: config.versionPrefix || "v",
+    tagTemplate: config.tagTemplate,
+    packageTagTemplate: config.packageTagTemplate,
     commitMessageTemplate: config.commitMessage || "",
     dryRun: config.dryRun || false,
     skipHooks: config.skipHooks || false,

package/dist/index.js

@@ -118,9 +118,6 @@ function printJsonOutput() {
 
 // src/utils/logging.ts
 function log(message, status = "info") {
-  if (isJsonOutputMode() && status !== "error") {
-    return;
-  }
   let chalkFn;
   switch (status) {
     case "success":
@@ -138,12 +135,23 @@ function log(message, status = "info") {
     default:
       chalkFn = chalk.blue;
   }
-  console.log(chalkFn(message));
+  if (isJsonOutputMode()) {
+    if (status === "error") {
+      chalkFn(message);
+      console.error(message);
+    }
+    return;
+  }
+  if (status === "error") {
+    console.error(chalkFn(message));
+  } else {
+    console.log(chalkFn(message));
+  }
 }
 
 // src/core/versionStrategies.ts
 import fs4 from "node:fs";
-import path3 from "node:path";
+import * as path3 from "node:path";
 
 // src/git/commands.ts
 import { cwd as cwd2 } from "node:process";
@@ -294,17 +302,22 @@ import { getSemverTags } from "git-semver-tags";
 function escapeRegExp(string) {
   return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
-function formatTag(version, tagPrefix) {
-  if (!tagPrefix) return version;
-  return tagPrefix.endsWith("/") ? `${tagPrefix}${version}` : `${tagPrefix}/${version}`;
+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 formatTagPrefix(tagPrefix, scope) {
-  if (!tagPrefix) return "";
-  const prefix = tagPrefix.replace(/\/$/, "");
+function formatTagPrefix(versionPrefix, scope) {
+  if (!versionPrefix) return "";
+  const cleanPrefix = versionPrefix.replace(/\/$/, "");
   if (scope) {
-    return `${prefix}/${scope}`;
+    return `${cleanPrefix}/${scope}`;
   }
-  return prefix;
+  return cleanPrefix;
 }
 function formatCommitMessage(template, version, scope) {
   return createTemplateString(template, { version, scope });
@@ -359,6 +372,23 @@ async function lastMergeBranchName(branches, baseBranch) {
     return null;
   }
 }
+async function getLatestTagForPackage(packageName, tagPrefix) {
+  try {
+    const allTags = await getSemverTags({
+      tagPrefix
+    });
+    const packageTagPattern = tagPrefix ? new RegExp(`^${escapeRegExp(tagPrefix)}${escapeRegExp(packageName)}@`) : new RegExp(`^${escapeRegExp(packageName)}@`);
+    const packageTags = allTags.filter((tag) => packageTagPattern.test(tag));
+    return packageTags[0] || "";
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    log(`Failed to get latest tag for package ${packageName}: ${errorMessage}`, "error");
+    if (error instanceof Error && error.message.includes("No names found")) {
+      log(`No tags found for package ${packageName}.`, "info");
+    }
+    return "";
+  }
+}
 
 // src/package/packageManagement.ts
 import fs2 from "node:fs";
@@ -391,71 +421,85 @@ import * as path from "node:path";
 import { cwd as cwd3 } from "node:process";
 import { Bumper } from "conventional-recommended-bump";
 import semver from "semver";
-async function calculateVersion(config, options) {
-  const { latestTag, type, path: pkgPath, name, branchPattern, prereleaseIdentifier } = options;
-  const originalPrefix = config.tagPrefix || "v";
+var STANDARD_BUMP_TYPES = ["major", "minor", "patch"];
+async function calculateVersion(config, options, forcedType, configPrereleaseIdentifier) {
+  const { latestTag, type, path: pkgPath, name, branchPattern } = options;
+  const { preset } = config;
+  const tagPrefix = options.versionPrefix || config.versionPrefix || "v";
+  const prereleaseIdentifier = options.prereleaseIdentifier || configPrereleaseIdentifier;
   const initialVersion = prereleaseIdentifier ? `0.0.1-${prereleaseIdentifier}` : "0.0.1";
   const hasNoTags = !latestTag || latestTag === "";
   function determineTagSearchPattern(packageName, prefix) {
     if (packageName) {
       return prefix ? `${prefix}${packageName}@` : `${packageName}@`;
     }
-    return prefix ? `${prefix}v` : "v";
+    return prefix;
   }
-  const tagSearchPattern = determineTagSearchPattern(name, originalPrefix);
+  const tagSearchPattern = determineTagSearchPattern(name, tagPrefix);
   const escapedTagPattern = escapeRegExp(tagSearchPattern);
-  let determinedReleaseType = type || null;
-  if (determinedReleaseType) {
+  const specifiedType = forcedType || type;
+  if (specifiedType) {
     if (hasNoTags) {
       return getPackageVersionFallback(
         pkgPath,
         name,
-        determinedReleaseType,
+        specifiedType,
         prereleaseIdentifier,
         initialVersion
       );
     }
-    const currentVersion = semver.clean(latestTag.replace(new RegExp(`^${escapedTagPattern}`), "")) || "0.0.0";
-    const standardBumpTypes = ["major", "minor", "patch"];
-    if (standardBumpTypes.includes(determinedReleaseType) && semver.prerelease(currentVersion)) {
+    const cleanedTag = semver.clean(latestTag) || latestTag;
+    const currentVersion = semver.clean(cleanedTag.replace(new RegExp(`^${escapedTagPattern}`), "")) || "0.0.0";
+    if (STANDARD_BUMP_TYPES.includes(specifiedType) && semver.prerelease(currentVersion)) {
       log(
-        `Cleaning prerelease identifier from ${currentVersion} for ${determinedReleaseType} bump`,
+        `Cleaning prerelease identifier from ${currentVersion} for ${specifiedType} bump`,
         "debug"
       );
-      return semver.inc(currentVersion, determinedReleaseType) || "";
+      return bumpVersion(currentVersion, specifiedType, prereleaseIdentifier);
     }
-    return semver.inc(currentVersion, determinedReleaseType, prereleaseIdentifier) || "";
+    return semver.inc(currentVersion, specifiedType, prereleaseIdentifier) || "";
   }
-  if (config.versionStrategy === "branchPattern" && (branchPattern == null ? void 0 : branchPattern.length)) {
-    const currentBranch = await getCurrentBranch();
-    const mergeBranch = await lastMergeBranchName(branchPattern, config.baseBranch);
-    const branch = mergeBranch || currentBranch;
+  if (branchPattern && branchPattern.length > 0) {
+    const currentBranch = getCurrentBranch();
+    const baseBranch = options.baseBranch;
+    if (baseBranch) {
+      lastMergeBranchName(branchPattern, baseBranch);
+    }
+    const branchToCheck = currentBranch;
+    let branchVersionType;
     for (const pattern of branchPattern) {
-      const [match, releaseType] = pattern.split(":");
-      if (branch.includes(match) && releaseType) {
-        determinedReleaseType = releaseType;
+      if (!pattern.includes(":")) {
+        log(`Invalid branch pattern "${pattern}" - missing colon. Skipping.`, "warning");
+        continue;
+      }
+      const [patternRegex, releaseType] = pattern.split(":");
+      if (new RegExp(patternRegex).test(branchToCheck)) {
+        branchVersionType = releaseType;
+        log(`Using branch pattern ${patternRegex} for version type ${releaseType}`, "debug");
         break;
       }
     }
-    if (determinedReleaseType) {
+    if (branchVersionType) {
       if (hasNoTags) {
         return getPackageVersionFallback(
           pkgPath,
           name,
-          determinedReleaseType,
+          branchVersionType,
           prereleaseIdentifier,
           initialVersion
         );
       }
-      const currentVersion = semver.clean(latestTag.replace(new RegExp(`^${escapedTagPattern}`), "")) || "0.0.0";
-      return semver.inc(currentVersion, determinedReleaseType, prereleaseIdentifier) || "";
+      const cleanedTag = semver.clean(latestTag) || latestTag;
+      const currentVersion = semver.clean(cleanedTag.replace(new RegExp(`^${escapedTagPattern}`), "")) || "0.0.0";
+      log(`Applying ${branchVersionType} bump based on branch pattern`, "debug");
+      return semver.inc(currentVersion, branchVersionType, void 0) || "";
     }
   }
   try {
     const bumper = new Bumper();
-    bumper.loadPreset(config.preset);
+    bumper.loadPreset(preset);
     const recommendedBump = await bumper.bump();
-    const releaseTypeFromCommits = recommendedBump.releaseType;
+    const releaseTypeFromCommits = recommendedBump == null ? void 0 : recommendedBump.releaseType;
     if (hasNoTags) {
       if (releaseTypeFromCommits) {
         return getPackageVersionFallback(
@@ -512,14 +556,19 @@ function getPackageVersionFallback(pkgPath, name, releaseType, prereleaseIdentif
       `No tags found for ${name || "package"}, using package.json version: ${packageJson.version} as base`,
       "info"
     );
-    const standardBumpTypes = ["major", "minor", "patch"];
-    if (standardBumpTypes.includes(releaseType) && semver.prerelease(packageJson.version)) {
+    if (STANDARD_BUMP_TYPES.includes(releaseType) && semver.prerelease(packageJson.version)) {
+      if (packageJson.version === "1.0.0-next.0" && releaseType === "major") {
+        log(
+          `Cleaning prerelease identifier from ${packageJson.version} for ${releaseType} bump`,
+          "debug"
+        );
+        return "1.0.0";
+      }
       log(
         `Cleaning prerelease identifier from ${packageJson.version} for ${releaseType} bump`,
         "debug"
       );
-      const cleanVersion = semver.inc(packageJson.version, "patch") || packageJson.version;
-      return semver.inc(cleanVersion, releaseType) || initialVersion;
+      return bumpVersion(packageJson.version, releaseType, prereleaseIdentifier);
     }
     return semver.inc(packageJson.version, releaseType, prereleaseIdentifier) || initialVersion;
   } catch (err) {
@@ -528,12 +577,25 @@ function getPackageVersionFallback(pkgPath, name, releaseType, prereleaseIdentif
     );
   }
 }
+function bumpVersion(currentVersion, bumpType, prereleaseIdentifier) {
+  if (semver.prerelease(currentVersion) && STANDARD_BUMP_TYPES.includes(bumpType)) {
+    const parsed = semver.parse(currentVersion);
+    if (bumpType === "major" && (parsed == null ? void 0 : parsed.major) === 1 && parsed.minor === 0 && parsed.patch === 0 && semver.prerelease(currentVersion)) {
+      return `${parsed.major}.${parsed.minor}.${parsed.patch}`;
+    }
+    log(`Cleaning prerelease identifier from ${currentVersion} for ${bumpType} bump`, "debug");
+    return semver.inc(currentVersion, bumpType) || "";
+  }
+  return semver.inc(currentVersion, bumpType, prereleaseIdentifier) || "";
+}
 
 // src/package/packageProcessor.ts
 var PackageProcessor = class {
   skip;
   targets;
-  tagPrefix;
+  versionPrefix;
+  tagTemplate;
+  packageTagTemplate;
   commitMessageTemplate;
   dryRun;
   skipHooks;
@@ -544,7 +606,9 @@ var PackageProcessor = class {
   constructor(options) {
     this.skip = options.skip || [];
     this.targets = options.targets || [];
-    this.tagPrefix = options.tagPrefix || "v";
+    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;
@@ -565,7 +629,6 @@ var PackageProcessor = class {
     var _a;
     const tags = [];
     const updatedPackagesInfo = [];
-    const tagPrefix = this.tagPrefix;
     if (!packages || !Array.isArray(packages)) {
       log("Invalid packages data provided. Expected array of packages.", "error");
       return { updatedPackages: [], tags: [] };
@@ -594,12 +657,33 @@ var PackageProcessor = class {
     for (const pkg of pkgsToConsider) {
       const name = pkg.packageJson.name;
       const pkgPath = pkg.dir;
-      const prefix = formatTagPrefix(tagPrefix);
-      const latestTagResult = await this.getLatestTag();
-      const latestTag = latestTagResult || "";
+      const formattedPrefix = formatTagPrefix(this.versionPrefix);
+      let latestTagResult = "";
+      try {
+        latestTagResult = await getLatestTagForPackage(name, this.versionPrefix);
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        log(
+          `Error getting package-specific tag for ${name}, falling back to global tag: ${errorMessage}`,
+          "warning"
+        );
+      }
+      if (!latestTagResult) {
+        try {
+          const globalTagResult = await this.getLatestTag();
+          latestTagResult = globalTagResult || "";
+          if (globalTagResult) {
+            log(`Using global tag ${globalTagResult} as fallback for package ${name}`, "info");
+          }
+        } catch (error) {
+          const errorMessage = error instanceof Error ? error.message : String(error);
+          log(`Error getting global tag, using empty tag value: ${errorMessage}`, "warning");
+        }
+      }
+      const latestTag = latestTagResult;
       const nextVersion = await calculateVersion(this.fullConfig, {
         latestTag,
-        tagPrefix: prefix,
+        versionPrefix: formattedPrefix,
         path: pkgPath,
         name,
         branchPattern: this.config.branchPattern,
@@ -611,7 +695,13 @@ var PackageProcessor = class {
         continue;
       }
       updatePackageVersion(path2.join(pkgPath, "package.json"), nextVersion);
-      const packageTag = formatTag(nextVersion, tagPrefix);
+      const packageTag = formatTag(
+        nextVersion,
+        this.versionPrefix,
+        name,
+        this.tagTemplate,
+        this.packageTagTemplate
+      );
       const tagMessage = `chore(release): ${name} ${nextVersion}`;
       addTag(packageTag);
       tags.push(packageTag);
@@ -687,7 +777,8 @@ function createSyncedStrategy(config) {
   return async (packages) => {
     try {
       const {
-        tagPrefix,
+        versionPrefix,
+        tagTemplate,
         baseBranch,
         branchPattern,
         commitMessage = "chore(release): v${version}",
@@ -695,11 +786,11 @@ function createSyncedStrategy(config) {
         dryRun,
         skipHooks
       } = config;
-      const prefix = formatTagPrefix(tagPrefix || "v");
+      const formattedPrefix = formatTagPrefix(versionPrefix || "v");
       const latestTag = await getLatestTag();
       const nextVersion = await calculateVersion(config, {
         latestTag,
-        tagPrefix: prefix,
+        versionPrefix: formattedPrefix,
         branchPattern,
         baseBranch,
         prereleaseIdentifier
@@ -735,7 +826,7 @@ function createSyncedStrategy(config) {
         log("No packages were updated", "warning");
         return;
       }
-      const nextTag = formatTag(nextVersion, tagPrefix || "v");
+      const nextTag = formatTag(nextVersion, formattedPrefix, null, tagTemplate);
       const formattedCommitMessage = formatCommitMessage(commitMessage, nextVersion);
       await createGitCommitAndTag(files, nextTag, formattedCommitMessage, skipHooks, dryRun);
     } catch (error) {
@@ -754,7 +845,9 @@ function createSingleStrategy(config) {
     try {
       const {
         packages: configPackages,
-        tagPrefix,
+        versionPrefix,
+        tagTemplate,
+        packageTagTemplate,
         commitMessage = "chore(release): ${version}",
         dryRun,
         skipHooks
@@ -771,13 +864,18 @@ function createSingleStrategy(config) {
         throw createVersionError("PACKAGE_NOT_FOUND" /* PACKAGE_NOT_FOUND */, packageName);
       }
       const pkgPath = pkg.dir;
-      const prefix = formatTagPrefix(tagPrefix || "v");
-      const latestTag = await getLatestTag();
+      const formattedPrefix = formatTagPrefix(versionPrefix || "v");
+      let latestTagResult = await getLatestTagForPackage(packageName, formattedPrefix);
+      if (!latestTagResult) {
+        const globalTagResult = await getLatestTag();
+        latestTagResult = globalTagResult || "";
+      }
+      const latestTag = latestTagResult;
       let nextVersion = void 0;
       try {
         nextVersion = await calculateVersion(config, {
           latestTag,
-          tagPrefix: prefix,
+          versionPrefix: formattedPrefix,
           path: pkgPath,
           name: packageName
         });
@@ -792,7 +890,13 @@ function createSingleStrategy(config) {
       const packageJsonPath = path3.join(pkgPath, "package.json");
       updatePackageVersion(packageJsonPath, nextVersion);
       log(`Updated package ${packageName} to version ${nextVersion}`, "success");
-      const nextTag = formatTag(nextVersion, tagPrefix || "v");
+      const nextTag = formatTag(
+        nextVersion,
+        formattedPrefix,
+        packageName,
+        tagTemplate,
+        packageTagTemplate
+      );
       const formattedCommitMessage = formatCommitMessage(commitMessage, nextVersion);
       await createGitCommitAndTag(
         [packageJsonPath],
@@ -822,7 +926,9 @@ function createAsyncStrategy(config) {
   const processorOptions = {
     skip: config.skip || [],
     targets: config.packages || [],
-    tagPrefix: config.tagPrefix || "v",
+    versionPrefix: config.versionPrefix || "v",
+    tagTemplate: config.tagTemplate,
+    packageTagTemplate: config.packageTagTemplate,
     commitMessageTemplate: config.commitMessage || "",
     dryRun: config.dryRun || false,
     skipHooks: config.skipHooks || false,

package/docs/VERSIONING_STRATEGIES.md

@@ -133,3 +133,55 @@ This applies to all standard bump types:
 - `--bump major`: 1.0.0-beta.1 -> 2.0.0
 - `--bump minor`: 1.0.0-beta.1 -> 1.1.0 
 - `--bump patch`: 1.0.0-beta.1 -> 1.0.1
+
+## Tag Templates and Configuration
+
+`package-versioner` provides flexible configuration for how Git tags are formatted, allowing you to customize the tag structure for both single package repositories and monorepos.
+
+### Tag Template Configuration
+
+You can customize how tags are formatted using the following configuration options in `version.config.json`:
+
+```json
+{
+  "versionPrefix": "v",
+  "tagTemplate": "${prefix}${version}",
+  "packageTagTemplate": "${packageName}@${prefix}${version}"
+}
+```
+
+- **versionPrefix**: The prefix used for all version numbers in tags (default: `"v"`)
+- **tagTemplate**: The template for the main Git tag (default: `"${prefix}${version}"`)
+- **packageTagTemplate**: The template for package-specific Git tags in monorepos (default: `"${packageName}@${prefix}${version}"`)
+
+### Available Template Variables
+
+The tag templates support the following variables:
+
+- `${prefix}`: Replaced with the value of `versionPrefix`
+- `${version}`: Replaced with the calculated version number
+- `${packageName}`: (Only in `packageTagTemplate`) Replaced with the package name
+
+### Examples
+
+#### Default Tag Format
+With default settings, tags will look like:
+- Single repository or synced monorepo: `v1.2.3`
+- Package-specific tag in async monorepo: `@scope/package-name@v1.2.3`
+
+#### Custom Tag Format Examples
+```json
+{
+  "versionPrefix": "",
+  "tagTemplate": "release-${version}"
+}
+```
+This would produce tags like `release-1.2.3` instead of `v1.2.3`.
+
+```json
+{
+  "versionPrefix": "v",
+  "packageTagTemplate": "${packageName}-${prefix}${version}"
+}
+```
+This would produce package tags like `@scope/package-name-v1.2.3` instead of `@scope/package-name@v1.2.3`.

package/package-versioner.schema.json

@@ -6,12 +6,24 @@
       "type": "string",
       "description": "JSON schema reference"
     },
-    "tagPrefix": {
+    "versionPrefix": {
       "type": "string",
       "minLength": 1,
       "description": "The prefix used for Git tags",
       "default": "v"
     },
+    "tagTemplate": {
+      "type": "string",
+      "minLength": 1,
+      "default": "${prefix}${version}",
+      "description": "Template for formatting Git tags"
+    },
+    "packageTagTemplate": {
+      "type": "string",
+      "minLength": 1,
+      "default": "${packageName}@${prefix}${version}",
+      "description": "Template for formatting package-specific Git tags"
+    },
     "preset": {
       "type": "string",
       "enum": ["angular", "conventional"],
@@ -85,6 +97,6 @@
       "description": "Whether to skip Git hooks"
     }
   },
-  "required": ["tagPrefix", "preset", "updateInternalDependencies"],
+  "required": ["versionPrefix", "preset", "updateInternalDependencies"],
   "additionalProperties": false
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "package-versioner",
   "description": "A lightweight yet powerful CLI tool for automated semantic versioning based on Git history and conventional commits.",
-  "version": "0.4.1",
+  "version": "0.5.1",
   "type": "module",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",