package-versioner 0.3.0 → 0.4.1

package/README.md

@@ -39,6 +39,10 @@ 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
 
@@ -70,7 +74,7 @@ When using the `--json` flag, normal console output is suppressed and the tool o
   ],
   "commitMessage": "chore(release): v1.2.3",
   "tags": [
-    "@scope/package-a@v1.2.3"
+    "v@scope/package-a@1.2.3"
   ]
 }
 ```

package/dist/index.cjs

@@ -410,13 +410,16 @@ 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 { latestTag, type, path: pkgPath, name, branchPattern, prereleaseIdentifier } = options;
   const originalPrefix = config.tagPrefix || "v";
   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}@`;
@@ -427,10 +430,24 @@ async function calculateVersion(config, options) {
   const escapedTagPattern = escapeRegExp(tagSearchPattern);
   let determinedReleaseType = type || null;
   if (determinedReleaseType) {
-    if (!latestTag) {
-      return initialVersion;
+    if (hasNoTags) {
+      return getPackageVersionFallback(
+        pkgPath,
+        name,
+        determinedReleaseType,
+        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)) {
+      log(
+        `Cleaning prerelease identifier from ${currentVersion} for ${determinedReleaseType} bump`,
+        "debug"
+      );
+      return import_semver.default.inc(currentVersion, determinedReleaseType) || "";
+    }
     return import_semver.default.inc(currentVersion, determinedReleaseType, prereleaseIdentifier) || "";
   }
   if (config.versionStrategy === "branchPattern" && (branchPattern == null ? void 0 : branchPattern.length)) {
@@ -445,8 +462,14 @@ async function calculateVersion(config, options) {
       }
     }
     if (determinedReleaseType) {
-      if (!latestTag) {
-        return initialVersion;
+      if (hasNoTags) {
+        return getPackageVersionFallback(
+          pkgPath,
+          name,
+          determinedReleaseType,
+          prereleaseIdentifier,
+          initialVersion
+        );
       }
       const currentVersion = import_semver.default.clean(latestTag.replace(new RegExp(`^${escapedTagPattern}`), "")) || "0.0.0";
       return import_semver.default.inc(currentVersion, determinedReleaseType, prereleaseIdentifier) || "";
@@ -457,10 +480,19 @@ async function calculateVersion(config, options) {
     bumper.loadPreset(config.preset);
     const recommendedBump = await bumper.bump();
     const releaseTypeFromCommits = recommendedBump.releaseType;
-    if (!latestTag) {
+    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(
@@ -488,6 +520,38 @@ 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"
+    );
+    const standardBumpTypes = ["major", "minor", "patch"];
+    if (standardBumpTypes.includes(releaseType) && import_semver.default.prerelease(packageJson.version)) {
+      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 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)}`
+    );
+  }
+}
 
 // src/package/packageProcessor.ts
 var PackageProcessor = class {

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 path3 from "node:path";
 
 // src/git/commands.ts
 import { cwd as cwd2 } from "node:process";
@@ -382,17 +382,20 @@ 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 { latestTag, type, path: pkgPath, name, branchPattern, prereleaseIdentifier } = options;
   const originalPrefix = config.tagPrefix || "v";
   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}@`;
@@ -403,10 +406,24 @@ async function calculateVersion(config, options) {
   const escapedTagPattern = escapeRegExp(tagSearchPattern);
   let determinedReleaseType = type || null;
   if (determinedReleaseType) {
-    if (!latestTag) {
-      return initialVersion;
+    if (hasNoTags) {
+      return getPackageVersionFallback(
+        pkgPath,
+        name,
+        determinedReleaseType,
+        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)) {
+      log(
+        `Cleaning prerelease identifier from ${currentVersion} for ${determinedReleaseType} bump`,
+        "debug"
+      );
+      return semver.inc(currentVersion, determinedReleaseType) || "";
+    }
     return semver.inc(currentVersion, determinedReleaseType, prereleaseIdentifier) || "";
   }
   if (config.versionStrategy === "branchPattern" && (branchPattern == null ? void 0 : branchPattern.length)) {
@@ -421,8 +438,14 @@ async function calculateVersion(config, options) {
       }
     }
     if (determinedReleaseType) {
-      if (!latestTag) {
-        return initialVersion;
+      if (hasNoTags) {
+        return getPackageVersionFallback(
+          pkgPath,
+          name,
+          determinedReleaseType,
+          prereleaseIdentifier,
+          initialVersion
+        );
       }
       const currentVersion = semver.clean(latestTag.replace(new RegExp(`^${escapedTagPattern}`), "")) || "0.0.0";
       return semver.inc(currentVersion, determinedReleaseType, prereleaseIdentifier) || "";
@@ -433,10 +456,19 @@ async function calculateVersion(config, options) {
     bumper.loadPreset(config.preset);
     const recommendedBump = await bumper.bump();
     const releaseTypeFromCommits = recommendedBump.releaseType;
-    if (!latestTag) {
+    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(
@@ -464,6 +496,38 @@ 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"
+    );
+    const standardBumpTypes = ["major", "minor", "patch"];
+    if (standardBumpTypes.includes(releaseType) && semver.prerelease(packageJson.version)) {
+      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 semver.inc(packageJson.version, releaseType, prereleaseIdentifier) || initialVersion;
+  } catch (err) {
+    throw new Error(
+      `Error reading package.json: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+}
 
 // src/package/packageProcessor.ts
 var PackageProcessor = class {
@@ -546,7 +610,7 @@ var PackageProcessor = class {
       if (!nextVersion) {
         continue;
       }
-      updatePackageVersion(path.join(pkgPath, "package.json"), nextVersion);
+      updatePackageVersion(path2.join(pkgPath, "package.json"), nextVersion);
       const packageTag = formatTag(nextVersion, tagPrefix);
       const tagMessage = `chore(release): ${name} ${nextVersion}`;
       addTag(packageTag);
@@ -571,7 +635,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";
@@ -647,8 +711,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");
@@ -660,7 +724,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);
@@ -725,7 +789,7 @@ 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");

package/docs/VERSIONING_STRATEGIES.md

@@ -94,3 +94,42 @@ This is the default if the `synced` flag is present and true.
     -   Finally, a **single commit** is created including all the updated `package.json` files, using a summary commit message (e.g., `chore(release): pkg-a, pkg-b 1.2.3 [skip-ci]`).
     -   **Important:** Only package-specific tags are created. The global tag (e.g., `v1.2.3`) is **not** automatically generated in this mode. If your release process (like GitHub Releases) depends on a global tag, you'll need to create it manually in your CI/CD script *after* `package-versioner` completes.
 -   **Use Case:** Releasing specific packages independently while still tagging each released package individually.
+
+## Prerelease Handling
+
+`package-versioner` provides flexible handling for prerelease versions, allowing both creation of prereleases and promotion to stable releases.
+
+### Creating Prereleases
+
+Use the `--prerelease` flag with an identifier to create a prerelease version:
+
+```bash
+# Create a beta prerelease
+npx package-versioner --bump minor --prerelease beta
+# Result: 1.0.0 -> 1.1.0-beta.0
+```
+
+You can also set a default prerelease identifier in your `version.config.json`:
+
+```json
+{
+  "prereleaseIdentifier": "beta"
+}
+```
+
+### Promoting Prereleases to Stable Releases
+
+When using standard bump types (`major`, `minor`, `patch`) with the `--bump` flag on a prerelease version, `package-versioner` will automatically clean the prerelease identifier:
+
+```bash
+# Starting from version 1.0.0-beta.1
+npx package-versioner --bump major
+# Result: 1.0.0-beta.1 -> 2.0.0 (not 2.0.0-beta.0)
+```
+
+This intuitive behavior means you don't need to use an empty prerelease identifier (`--prerelease ""`) to promote a prerelease to a stable version. Simply specify the standard bump type and the tool will automatically produce a clean version number.
+
+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

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.3.0",
+  "version": "0.4.1",
   "type": "module",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",