package-versioner 0.4.0 → 0.5.0

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

@@ -166,7 +166,7 @@ function log(message, status = "info") {
 
 // 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 +317,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 +387,22 @@ async function lastMergeBranchName(branches, baseBranch) {
     return null;
   }
 }
+async function getLatestTagForPackage(packageName, tagPrefix) {
+  try {
+    const tags = await (0, import_git_semver_tags.getSemverTags)({
+      package: packageName,
+      tagPrefix
+    });
+    return tags[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);
@@ -410,65 +431,103 @@ var import_node_path3 = __toESM(require("path"), 1);
 var import_node_process4 = require("process");
 
 // src/core/versionCalculator.ts
+var fs3 = __toESM(require("fs"), 1);
+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: path4, 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) {
-    if (!latestTag) {
-      return initialVersion;
+  const specifiedType = forcedType || type;
+  if (specifiedType) {
+    if (hasNoTags) {
+      return getPackageVersionFallback(
+        pkgPath,
+        name,
+        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 (!latestTag) {
-        return initialVersion;
+    if (branchVersionType) {
+      if (hasNoTags) {
+        return getPackageVersionFallback(
+          pkgPath,
+          name,
+          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;
-    if (!latestTag) {
+    const releaseTypeFromCommits = recommendedBump == null ? void 0 : recommendedBump.releaseType;
+    if (hasNoTags) {
+      if (releaseTypeFromCommits) {
+        return getPackageVersionFallback(
+          pkgPath,
+          name,
+          releaseTypeFromCommits,
+          prereleaseIdentifier,
+          initialVersion
+        );
+      }
       return initialVersion;
     }
-    const checkPath = path4 || (0, import_node_process3.cwd)();
+    const checkPath = pkgPath || (0, import_node_process3.cwd)();
     const commitsLength = getCommitsLength(checkPath);
     if (commitsLength === 0) {
       log(
@@ -496,12 +555,62 @@ async function calculateVersion(config, options) {
     throw error;
   }
 }
+function getPackageVersionFallback(pkgPath, name, releaseType, prereleaseIdentifier, initialVersion) {
+  const packageDir = pkgPath || (0, import_node_process3.cwd)();
+  const packageJsonPath = path2.join(packageDir, "package.json");
+  if (!fs3.existsSync(packageJsonPath)) {
+    throw new Error(`package.json not found at ${packageJsonPath}. Cannot determine version.`);
+  }
+  try {
+    const packageJson = JSON.parse(fs3.readFileSync(packageJsonPath, "utf-8"));
+    if (!packageJson.version) {
+      log(`No version found in package.json. Using initial version ${initialVersion}`, "info");
+      return initialVersion;
+    }
+    log(
+      `No tags found for ${name || "package"}, using package.json version: ${packageJson.version} as base`,
+      "info"
+    );
+    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"
+      );
+      return bumpVersion(packageJson.version, releaseType, prereleaseIdentifier);
+    }
+    return import_semver.default.inc(packageJson.version, releaseType, prereleaseIdentifier) || initialVersion;
+  } catch (err) {
+    throw new Error(
+      `Error reading package.json: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+}
+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;
@@ -512,7 +621,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;
@@ -533,7 +644,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: [] };
@@ -562,12 +672,16 @@ 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 = await getLatestTagForPackage(name, this.versionPrefix);
+      if (!latestTagResult) {
+        const globalTagResult = await this.getLatestTag();
+        latestTagResult = globalTagResult || "";
+      }
+      const latestTag = latestTagResult;
       const nextVersion = await calculateVersion(this.fullConfig, {
         latestTag,
-        tagPrefix: prefix,
+        versionPrefix: formattedPrefix,
         path: pkgPath,
         name,
         branchPattern: this.config.branchPattern,
@@ -579,7 +693,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);
@@ -655,7 +775,8 @@ function createSyncedStrategy(config) {
   return async (packages) => {
     try {
       const {
-        tagPrefix,
+        versionPrefix,
+        tagTemplate,
         baseBranch,
         branchPattern,
         commitMessage = "chore(release): v${version}",
@@ -663,11 +784,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
@@ -679,7 +800,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);
@@ -692,7 +813,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);
@@ -703,7 +824,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) {
@@ -722,7 +843,9 @@ function createSingleStrategy(config) {
     try {
       const {
         packages: configPackages,
-        tagPrefix,
+        versionPrefix,
+        tagTemplate,
+        packageTagTemplate,
         commitMessage = "chore(release): ${version}",
         dryRun,
         skipHooks
@@ -739,13 +862,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
         });
@@ -757,10 +885,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],
@@ -790,7 +924,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

@@ -142,8 +142,8 @@ function log(message, status = "info") {
 }
 
 // src/core/versionStrategies.ts
-import fs3 from "node:fs";
-import path2 from "node:path";
+import fs4 from "node:fs";
+import * as path3 from "node:path";
 
 // src/git/commands.ts
 import { cwd as cwd2 } from "node:process";
@@ -294,17 +294,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 +364,22 @@ async function lastMergeBranchName(branches, baseBranch) {
     return null;
   }
 }
+async function getLatestTagForPackage(packageName, tagPrefix) {
+  try {
+    const tags = await getSemverTags({
+      package: packageName,
+      tagPrefix
+    });
+    return tags[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";
@@ -382,69 +403,107 @@ function updatePackageVersion(packagePath, version) {
 }
 
 // src/package/packageProcessor.ts
-import path from "node:path";
+import path2 from "node:path";
 import { exit } from "node:process";
 
 // src/core/versionCalculator.ts
+import * as fs3 from "node:fs";
+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: path3, 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) {
-    if (!latestTag) {
-      return initialVersion;
+  const specifiedType = forcedType || type;
+  if (specifiedType) {
+    if (hasNoTags) {
+      return getPackageVersionFallback(
+        pkgPath,
+        name,
+        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 (!latestTag) {
-        return initialVersion;
+    if (branchVersionType) {
+      if (hasNoTags) {
+        return getPackageVersionFallback(
+          pkgPath,
+          name,
+          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;
-    if (!latestTag) {
+    const releaseTypeFromCommits = recommendedBump == null ? void 0 : recommendedBump.releaseType;
+    if (hasNoTags) {
+      if (releaseTypeFromCommits) {
+        return getPackageVersionFallback(
+          pkgPath,
+          name,
+          releaseTypeFromCommits,
+          prereleaseIdentifier,
+          initialVersion
+        );
+      }
       return initialVersion;
     }
-    const checkPath = path3 || cwd3();
+    const checkPath = pkgPath || cwd3();
     const commitsLength = getCommitsLength(checkPath);
     if (commitsLength === 0) {
       log(
@@ -472,12 +531,62 @@ async function calculateVersion(config, options) {
     throw error;
   }
 }
+function getPackageVersionFallback(pkgPath, name, releaseType, prereleaseIdentifier, initialVersion) {
+  const packageDir = pkgPath || cwd3();
+  const packageJsonPath = path.join(packageDir, "package.json");
+  if (!fs3.existsSync(packageJsonPath)) {
+    throw new Error(`package.json not found at ${packageJsonPath}. Cannot determine version.`);
+  }
+  try {
+    const packageJson = JSON.parse(fs3.readFileSync(packageJsonPath, "utf-8"));
+    if (!packageJson.version) {
+      log(`No version found in package.json. Using initial version ${initialVersion}`, "info");
+      return initialVersion;
+    }
+    log(
+      `No tags found for ${name || "package"}, using package.json version: ${packageJson.version} as base`,
+      "info"
+    );
+    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"
+      );
+      return bumpVersion(packageJson.version, releaseType, prereleaseIdentifier);
+    }
+    return semver.inc(packageJson.version, releaseType, prereleaseIdentifier) || initialVersion;
+  } catch (err) {
+    throw new Error(
+      `Error reading package.json: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+}
+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;
@@ -488,7 +597,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;
@@ -509,7 +620,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: [] };
@@ -538,12 +648,16 @@ 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 = await getLatestTagForPackage(name, this.versionPrefix);
+      if (!latestTagResult) {
+        const globalTagResult = await this.getLatestTag();
+        latestTagResult = globalTagResult || "";
+      }
+      const latestTag = latestTagResult;
       const nextVersion = await calculateVersion(this.fullConfig, {
         latestTag,
-        tagPrefix: prefix,
+        versionPrefix: formattedPrefix,
         path: pkgPath,
         name,
         branchPattern: this.config.branchPattern,
@@ -554,8 +668,14 @@ var PackageProcessor = class {
       if (!nextVersion) {
         continue;
       }
-      updatePackageVersion(path.join(pkgPath, "package.json"), nextVersion);
-      const packageTag = formatTag(nextVersion, tagPrefix);
+      updatePackageVersion(path2.join(pkgPath, "package.json"), nextVersion);
+      const packageTag = formatTag(
+        nextVersion,
+        this.versionPrefix,
+        name,
+        this.tagTemplate,
+        this.packageTagTemplate
+      );
       const tagMessage = `chore(release): ${name} ${nextVersion}`;
       addTag(packageTag);
       tags.push(packageTag);
@@ -579,7 +699,7 @@ var PackageProcessor = class {
       log("No targeted packages required a version update.", "info");
       return { updatedPackages: [], tags };
     }
-    const filesToCommit = updatedPackagesInfo.map((info) => path.join(info.path, "package.json"));
+    const filesToCommit = updatedPackagesInfo.map((info) => path2.join(info.path, "package.json"));
     const packageNames = updatedPackagesInfo.map((p) => p.name).join(", ");
     const representativeVersion = ((_a = updatedPackagesInfo[0]) == null ? void 0 : _a.version) || "multiple";
     let commitMessage = this.commitMessageTemplate || "chore(release): publish packages";
@@ -631,7 +751,8 @@ function createSyncedStrategy(config) {
   return async (packages) => {
     try {
       const {
-        tagPrefix,
+        versionPrefix,
+        tagTemplate,
         baseBranch,
         branchPattern,
         commitMessage = "chore(release): v${version}",
@@ -639,11 +760,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
@@ -655,8 +776,8 @@ function createSyncedStrategy(config) {
       const files = [];
       const updatedPackages = [];
       try {
-        const rootPkgPath = path2.join(packages.root, "package.json");
-        if (fs3.existsSync(rootPkgPath)) {
+        const rootPkgPath = path3.join(packages.root, "package.json");
+        if (fs4.existsSync(rootPkgPath)) {
           updatePackageVersion(rootPkgPath, nextVersion);
           files.push(rootPkgPath);
           updatedPackages.push("root");
@@ -668,7 +789,7 @@ function createSyncedStrategy(config) {
         if (!shouldProcessPackage(pkg, config)) {
           continue;
         }
-        const packageJsonPath = path2.join(pkg.dir, "package.json");
+        const packageJsonPath = path3.join(pkg.dir, "package.json");
         updatePackageVersion(packageJsonPath, nextVersion);
         files.push(packageJsonPath);
         updatedPackages.push(pkg.packageJson.name);
@@ -679,7 +800,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) {
@@ -698,7 +819,9 @@ function createSingleStrategy(config) {
     try {
       const {
         packages: configPackages,
-        tagPrefix,
+        versionPrefix,
+        tagTemplate,
+        packageTagTemplate,
         commitMessage = "chore(release): ${version}",
         dryRun,
         skipHooks
@@ -715,13 +838,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
         });
@@ -733,10 +861,16 @@ function createSingleStrategy(config) {
         log(`No version change needed for ${packageName}`, "info");
         return;
       }
-      const packageJsonPath = path2.join(pkgPath, "package.json");
+      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],
@@ -766,7 +900,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.0",
+  "version": "0.5.0",
   "type": "module",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",