package-versioner 0.5.4 → 0.6.0

package/dist/index.js

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import * as fs6 from "node:fs";
-import path4 from "node:path";
+import * as fs7 from "node:fs";
+import path5 from "node:path";
 import { Command } from "commander";
 
 // src/config.ts
@@ -157,8 +157,8 @@ function log(message, level = "info") {
 }
 
 // src/core/versionStrategies.ts
-import fs5 from "node:fs";
-import * as path3 from "node:path";
+import fs6 from "node:fs";
+import * as path4 from "node:path";
 
 // src/git/commands.ts
 import { cwd as cwd2 } from "node:process";
@@ -440,14 +440,83 @@ async function getLatestTagForPackage(packageName, versionPrefix) {
 }
 
 // src/package/packageManagement.ts
+import fs3 from "node:fs";
+
+// src/cargo/cargoHandler.ts
 import fs2 from "node:fs";
+import path from "node:path";
+import * as TOML from "smol-toml";
+function getCargoInfo(cargoPath) {
+  var _a;
+  if (!fs2.existsSync(cargoPath)) {
+    log(`Cargo.toml file not found at: ${cargoPath}`, "error");
+    throw new Error(`Cargo.toml file not found at: ${cargoPath}`);
+  }
+  try {
+    const fileContent = fs2.readFileSync(cargoPath, "utf8");
+    const cargo = TOML.parse(fileContent);
+    if (!((_a = cargo.package) == null ? void 0 : _a.name)) {
+      log(`Package name not found in: ${cargoPath}`, "error");
+      throw new Error(`Package name not found in: ${cargoPath}`);
+    }
+    return {
+      name: cargo.package.name,
+      version: cargo.package.version || "0.0.0",
+      path: cargoPath,
+      dir: path.dirname(cargoPath),
+      content: cargo
+    };
+  } catch (error) {
+    log(`Error reading Cargo.toml: ${cargoPath}`, "error");
+    if (error instanceof Error) {
+      log(error.message, "error");
+      throw error;
+    }
+    throw new Error(`Failed to process Cargo.toml at ${cargoPath}`);
+  }
+}
+function isCargoToml(filePath) {
+  return path.basename(filePath) === "Cargo.toml";
+}
+function updateCargoVersion(cargoPath, version) {
+  var _a;
+  try {
+    const originalContent = fs2.readFileSync(cargoPath, "utf8");
+    const cargo = TOML.parse(originalContent);
+    const packageName = (_a = cargo.package) == null ? void 0 : _a.name;
+    if (!packageName) {
+      throw new Error(`No package name found in ${cargoPath}`);
+    }
+    if (!cargo.package) {
+      cargo.package = { name: packageName, version };
+    } else {
+      cargo.package.version = version;
+    }
+    const updatedContent = TOML.stringify(cargo);
+    fs2.writeFileSync(cargoPath, updatedContent);
+    addPackageUpdate(packageName, version, cargoPath);
+    log(`Updated Cargo.toml at ${cargoPath} to version ${version}`, "success");
+  } catch (error) {
+    log(`Failed to update Cargo.toml at ${cargoPath}`, "error");
+    if (error instanceof Error) {
+      log(error.message, "error");
+    }
+    throw error;
+  }
+}
+
+// src/package/packageManagement.ts
 function updatePackageVersion(packagePath, version) {
+  if (isCargoToml(packagePath)) {
+    updateCargoVersion(packagePath, version);
+    return;
+  }
   try {
-    const packageContent = fs2.readFileSync(packagePath, "utf8");
+    const packageContent = fs3.readFileSync(packagePath, "utf8");
     const packageJson = JSON.parse(packageContent);
     const packageName = packageJson.name;
     packageJson.version = version;
-    fs2.writeFileSync(packagePath, `${JSON.stringify(packageJson, null, 2)}
+    fs3.writeFileSync(packagePath, `${JSON.stringify(packageJson, null, 2)}
 `);
     addPackageUpdate(packageName, version, packagePath);
     log(`Updated package.json at ${packagePath} to version ${version}`, "success");
@@ -461,125 +530,217 @@ function updatePackageVersion(packagePath, version) {
 }
 
 // src/package/packageProcessor.ts
-import * as fs4 from "node:fs";
-import path2 from "node:path";
+import * as fs5 from "node:fs";
+import path3 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";
-var STANDARD_BUMP_TYPES = ["major", "minor", "patch"];
-async function calculateVersion(config, options) {
-  const { latestTag, type, path: pkgPath, name, branchPattern } = options;
-  const { preset } = config;
-  const originalPrefix = options.versionPrefix || "";
-  const prereleaseIdentifier = options.prereleaseIdentifier || config.prereleaseIdentifier;
-  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}@`;
+import semver2 from "semver";
+
+// src/utils/manifestHelpers.ts
+import fs4 from "node:fs";
+import path2 from "node:path";
+function getVersionFromManifests(packageDir) {
+  const packageJsonPath = path2.join(packageDir, "package.json");
+  const cargoTomlPath = path2.join(packageDir, "Cargo.toml");
+  if (fs4.existsSync(packageJsonPath)) {
+    try {
+      const packageJson = JSON.parse(fs4.readFileSync(packageJsonPath, "utf-8"));
+      if (packageJson.version) {
+        log(`Found version ${packageJson.version} in package.json`, "debug");
+        return {
+          version: packageJson.version,
+          manifestFound: true,
+          manifestPath: packageJsonPath,
+          manifestType: "package.json"
+        };
+      }
+      log("No version field found in package.json", "debug");
+    } catch (packageJsonError) {
+      const errMsg = packageJsonError instanceof Error ? packageJsonError.message : String(packageJsonError);
+      log(`Error reading package.json: ${errMsg}`, "warning");
     }
-    return prefix;
   }
-  const tagSearchPattern = determineTagSearchPattern(name, originalPrefix);
-  const escapedTagPattern = escapeRegExp(tagSearchPattern);
-  const specifiedType = type;
-  if (specifiedType) {
-    if (hasNoTags) {
-      return getPackageVersionFallback(
-        pkgPath,
-        name,
-        specifiedType,
-        prereleaseIdentifier,
-        initialVersion
-      );
-    }
-    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 ${specifiedType} bump`,
-        "debug"
-      );
-      return bumpVersion(currentVersion, specifiedType, prereleaseIdentifier);
+  if (fs4.existsSync(cargoTomlPath)) {
+    try {
+      const cargoInfo = getCargoInfo(cargoTomlPath);
+      if (cargoInfo.version) {
+        log(`Found version ${cargoInfo.version} in Cargo.toml`, "debug");
+        return {
+          version: cargoInfo.version,
+          manifestFound: true,
+          manifestPath: cargoTomlPath,
+          manifestType: "Cargo.toml"
+        };
+      }
+      log("No version field found in Cargo.toml", "debug");
+    } catch (cargoTomlError) {
+      const errMsg = cargoTomlError instanceof Error ? cargoTomlError.message : String(cargoTomlError);
+      log(`Error reading Cargo.toml: ${errMsg}`, "warning");
     }
-    return semver.inc(currentVersion, specifiedType, prereleaseIdentifier) || "";
   }
-  if (branchPattern && branchPattern.length > 0) {
-    const currentBranch = getCurrentBranch();
-    const baseBranch = options.baseBranch;
-    if (baseBranch) {
-      lastMergeBranchName(branchPattern, baseBranch);
+  return {
+    version: null,
+    manifestFound: false,
+    manifestPath: "",
+    manifestType: null
+  };
+}
+function throwIfNoManifestsFound(packageDir) {
+  const packageJsonPath = path2.join(packageDir, "package.json");
+  const cargoTomlPath = path2.join(packageDir, "Cargo.toml");
+  throw new Error(
+    `Neither package.json nor Cargo.toml found at ${packageDir}. Checked paths: ${packageJsonPath}, ${cargoTomlPath}. Cannot determine version.`
+  );
+}
+
+// src/utils/versionUtils.ts
+import semver from "semver";
+import * as TOML2 from "smol-toml";
+var STANDARD_BUMP_TYPES = ["major", "minor", "patch"];
+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}`;
     }
-    const branchToCheck = currentBranch;
-    let branchVersionType;
-    for (const pattern of branchPattern) {
-      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;
+    log(`Cleaning prerelease identifier from ${currentVersion} for ${bumpType} bump`, "debug");
+    return semver.inc(currentVersion, bumpType) || "";
+  }
+  return semver.inc(currentVersion, bumpType, prereleaseIdentifier) || "";
+}
+
+// src/core/versionCalculator.ts
+async function calculateVersion(config, options) {
+  const {
+    latestTag = "",
+    type,
+    versionPrefix = "",
+    branchPattern,
+    baseBranch,
+    prereleaseIdentifier,
+    path: pkgPath,
+    name
+  } = options;
+  const preset = config.preset || "conventional-commits";
+  const initialVersion = "0.1.0";
+  try {
+    let determineTagSearchPattern2 = function(packageName, prefix) {
+      if (packageName) {
+        const escapedPackageName = escapeRegExp(packageName);
+        const escapedPrefix = escapeRegExp(prefix);
+        return `${escapedPackageName}[@]?${escapedPrefix}`;
       }
-    }
-    if (branchVersionType) {
+      return escapeRegExp(prefix);
+    };
+    var determineTagSearchPattern = determineTagSearchPattern2;
+    const hasNoTags = !latestTag;
+    const originalPrefix = versionPrefix;
+    const tagSearchPattern = determineTagSearchPattern2(name, originalPrefix);
+    const escapedTagPattern = escapeRegExp(tagSearchPattern);
+    const specifiedType = type;
+    if (specifiedType) {
       if (hasNoTags) {
         return getPackageVersionFallback(
           pkgPath,
           name,
-          branchVersionType,
+          specifiedType,
           prereleaseIdentifier,
           initialVersion
         );
       }
-      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(preset);
-    const recommendedBump = await bumper.bump();
-    const releaseTypeFromCommits = recommendedBump == null ? void 0 : recommendedBump.releaseType;
-    if (hasNoTags) {
-      if (releaseTypeFromCommits) {
-        return getPackageVersionFallback(
-          pkgPath,
-          name,
-          releaseTypeFromCommits,
-          prereleaseIdentifier,
-          initialVersion
+      const cleanedTag = semver2.clean(latestTag) || latestTag;
+      const currentVersion = semver2.clean(cleanedTag.replace(new RegExp(`^${escapedTagPattern}`), "")) || "0.0.0";
+      if (STANDARD_BUMP_TYPES.includes(specifiedType) && semver2.prerelease(currentVersion)) {
+        log(
+          `Cleaning prerelease identifier from ${currentVersion} for ${specifiedType} bump`,
+          "debug"
         );
+        return bumpVersion(currentVersion, specifiedType, prereleaseIdentifier);
       }
-      return initialVersion;
+      return semver2.inc(currentVersion, specifiedType, prereleaseIdentifier) || "";
     }
-    const checkPath = pkgPath || cwd3();
-    const commitsLength = getCommitsLength(checkPath);
-    if (commitsLength === 0) {
-      log(
-        `No new commits found for ${name || "project"} since ${latestTag}, skipping version bump`,
-        "info"
-      );
-      return "";
+    if (branchPattern && branchPattern.length > 0) {
+      const currentBranch = getCurrentBranch();
+      if (baseBranch) {
+        lastMergeBranchName(branchPattern, baseBranch);
+      }
+      const branchToCheck = currentBranch;
+      let branchVersionType;
+      for (const pattern of branchPattern) {
+        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 (branchVersionType) {
+        if (hasNoTags) {
+          return getPackageVersionFallback(
+            pkgPath,
+            name,
+            branchVersionType,
+            prereleaseIdentifier,
+            initialVersion
+          );
+        }
+        const cleanedTag = semver2.clean(latestTag) || latestTag;
+        const currentVersion = semver2.clean(cleanedTag.replace(new RegExp(`^${escapedTagPattern}`), "")) || "0.0.0";
+        log(`Applying ${branchVersionType} bump based on branch pattern`, "debug");
+        return semver2.inc(currentVersion, branchVersionType, void 0) || "";
+      }
     }
-    if (!releaseTypeFromCommits) {
-      log(
-        `No relevant commits found for ${name || "project"} since ${latestTag}, skipping version bump`,
-        "info"
-      );
-      return "";
+    try {
+      const bumper = new Bumper();
+      bumper.loadPreset(preset);
+      const recommendedBump = await bumper.bump();
+      const releaseTypeFromCommits = recommendedBump == null ? void 0 : recommendedBump.releaseType;
+      if (hasNoTags) {
+        if (releaseTypeFromCommits) {
+          return getPackageVersionFallback(
+            pkgPath,
+            name,
+            releaseTypeFromCommits,
+            prereleaseIdentifier,
+            initialVersion
+          );
+        }
+        return initialVersion;
+      }
+      const checkPath = pkgPath || cwd3();
+      const commitsLength = getCommitsLength(checkPath);
+      if (commitsLength === 0) {
+        log(
+          `No new commits found for ${name || "project"} since ${latestTag}, skipping version bump`,
+          "info"
+        );
+        return "";
+      }
+      if (!releaseTypeFromCommits) {
+        log(
+          `No relevant commits found for ${name || "project"} since ${latestTag}, skipping version bump`,
+          "info"
+        );
+        return "";
+      }
+      const currentVersion = semver2.clean(latestTag.replace(new RegExp(`^${escapedTagPattern}`), "")) || "0.0.0";
+      return semver2.inc(currentVersion, releaseTypeFromCommits, prereleaseIdentifier) || "";
+    } catch (error) {
+      log(`Failed to calculate version for ${name || "project"}`, "error");
+      console.error(error);
+      if (error instanceof Error && error.message.includes("No names found")) {
+        log("No tags found, proceeding with initial version calculation (if applicable).", "info");
+        return initialVersion;
+      }
+      throw error;
     }
-    const currentVersion = semver.clean(latestTag.replace(new RegExp(`^${escapedTagPattern}`), "")) || "0.0.0";
-    return semver.inc(currentVersion, releaseTypeFromCommits, prereleaseIdentifier) || "";
   } catch (error) {
     log(`Failed to calculate version for ${name || "project"}`, "error");
     console.error(error);
@@ -592,51 +753,37 @@ async function calculateVersion(config, options) {
 }
 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;
-    }
+  const manifestResult = getVersionFromManifests(packageDir);
+  if (manifestResult.manifestFound && manifestResult.version) {
     log(
-      `No tags found for ${name || "package"}, using package.json version: ${packageJson.version} as base`,
+      `No tags found for ${name || "package"}, using ${manifestResult.manifestType} version: ${manifestResult.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)}`
+    return calculateNextVersion(
+      manifestResult.version,
+      manifestResult.manifestType || "manifest",
+      name,
+      releaseType,
+      prereleaseIdentifier,
+      initialVersion
     );
   }
+  throwIfNoManifestsFound(packageDir);
 }
-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}`;
+function calculateNextVersion(version, manifestType, name, releaseType, prereleaseIdentifier, initialVersion) {
+  log(
+    `No tags found for ${name || "package"}, using ${manifestType} version: ${version} as base`,
+    "info"
+  );
+  if (STANDARD_BUMP_TYPES.includes(releaseType) && semver2.prerelease(version)) {
+    if (version === "1.0.0-next.0" && releaseType === "major") {
+      log(`Cleaning prerelease identifier from ${version} for ${releaseType} bump`, "debug");
+      return "1.0.0";
     }
-    log(`Cleaning prerelease identifier from ${currentVersion} for ${bumpType} bump`, "debug");
-    return semver.inc(currentVersion, bumpType) || "";
+    log(`Cleaning prerelease identifier from ${version} for ${releaseType} bump`, "debug");
+    return bumpVersion(version, releaseType, prereleaseIdentifier);
   }
-  return semver.inc(currentVersion, bumpType, prereleaseIdentifier) || "";
+  return semver2.inc(version, releaseType, prereleaseIdentifier) || initialVersion;
 }
 
 // src/package/packageProcessor.ts
@@ -720,29 +867,22 @@ var PackageProcessor = class {
       }
       if (!latestTagResult) {
         try {
-          const packageJsonPath = path2.join(pkgPath, "package.json");
-          let usedPackageJsonFallback = false;
-          if (fs4.existsSync(packageJsonPath)) {
-            try {
-              const packageJson = JSON.parse(fs4.readFileSync(packageJsonPath, "utf-8"));
-              if (packageJson.version) {
-                log(
-                  `Using package.json version ${packageJson.version} for ${name} as no package-specific tags found`,
-                  "info"
-                );
-                log(
-                  "FALLBACK: Using package version from package.json instead of global tag",
-                  "debug"
-                );
-                latestTagResult = `${this.versionPrefix || ""}${packageJson.version}`;
-                usedPackageJsonFallback = true;
-              }
-            } catch (packageJsonError) {
-              const errMsg = packageJsonError instanceof Error ? packageJsonError.message : String(packageJsonError);
-              log(`Error reading package.json for ${name}: ${errMsg}`, "warning");
-            }
+          const packageDir = pkgPath;
+          let manifestFallbackUsed = false;
+          const manifestResult = getVersionFromManifests(packageDir);
+          if (manifestResult.manifestFound && manifestResult.version) {
+            log(
+              `Using ${manifestResult.manifestType} version ${manifestResult.version} for ${name} as no package-specific tags found`,
+              "info"
+            );
+            log(
+              `FALLBACK: Using package version from ${manifestResult.manifestType} instead of global tag`,
+              "debug"
+            );
+            latestTagResult = `${this.versionPrefix || ""}${manifestResult.version}`;
+            manifestFallbackUsed = true;
           }
-          if (!usedPackageJsonFallback) {
+          if (!manifestFallbackUsed) {
             const globalTagResult = await this.getLatestTag();
             if (globalTagResult) {
               latestTagResult = globalTagResult;
@@ -768,7 +908,14 @@ var PackageProcessor = class {
       if (!nextVersion) {
         continue;
       }
-      updatePackageVersion(path2.join(pkgPath, "package.json"), nextVersion);
+      const packageJsonPath = path3.join(pkgPath, "package.json");
+      const cargoTomlPath = path3.join(pkgPath, "Cargo.toml");
+      if (fs5.existsSync(packageJsonPath)) {
+        updatePackageVersion(packageJsonPath, nextVersion);
+      }
+      if (fs5.existsSync(cargoTomlPath)) {
+        updatePackageVersion(cargoTomlPath, nextVersion);
+      }
       const packageTag = formatTag(
         nextVersion,
         this.versionPrefix,
@@ -799,7 +946,7 @@ var PackageProcessor = class {
       log("No targeted packages required a version update.", "info");
       return { updatedPackages: [], tags };
     }
-    const filesToCommit = updatedPackagesInfo.map((info) => path2.join(info.path, "package.json"));
+    const filesToCommit = updatedPackagesInfo.map((info) => path3.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";
@@ -876,8 +1023,8 @@ function createSyncedStrategy(config) {
       const files = [];
       const updatedPackages = [];
       try {
-        const rootPkgPath = path3.join(packages.root, "package.json");
-        if (fs5.existsSync(rootPkgPath)) {
+        const rootPkgPath = path4.join(packages.root, "package.json");
+        if (fs6.existsSync(rootPkgPath)) {
           updatePackageVersion(rootPkgPath, nextVersion);
           files.push(rootPkgPath);
           updatedPackages.push("root");
@@ -889,7 +1036,7 @@ function createSyncedStrategy(config) {
         if (!shouldProcessPackage(pkg, config)) {
           continue;
         }
-        const packageJsonPath = path3.join(pkg.dir, "package.json");
+        const packageJsonPath = path4.join(pkg.dir, "package.json");
         updatePackageVersion(packageJsonPath, nextVersion);
         files.push(packageJsonPath);
         updatedPackages.push(pkg.packageJson.name);
@@ -962,7 +1109,7 @@ function createSingleStrategy(config) {
         log(`No version change needed for ${packageName}`, "info");
         return;
       }
-      const packageJsonPath = path3.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(
@@ -1140,11 +1287,11 @@ var VersionEngine = class {
 // src/index.ts
 function getPackageVersion() {
   try {
-    const packageJsonPath = path4.resolve(
-      path4.dirname(import.meta.url.replace("file:", "")),
+    const packageJsonPath = path5.resolve(
+      path5.dirname(import.meta.url.replace("file:", "")),
       "../package.json"
     );
-    const packageJsonContent = fs6.readFileSync(packageJsonPath, "utf-8");
+    const packageJsonContent = fs7.readFileSync(packageJsonPath, "utf-8");
     const packageJson = JSON.parse(packageJsonContent);
     return packageJson.version || "0.0.0";
   } catch (error) {
@@ -1174,7 +1321,7 @@ async function run() {
     if (options.synced) config.synced = true;
     if (options.bump) config.type = options.bump;
     if (options.prerelease)
-      config.prereleaseIdentifier = options.prerelease === true ? "rc" : options.prerelease;
+      config.prereleaseIdentifier = options.prerelease === true ? "next" : options.prerelease;
     const cliTargets = options.target ? options.target.split(",").map((t) => t.trim()) : [];
     const engine = new VersionEngine(config, !!options.json);
     if (config.synced) {

package/docs/VERSIONING_STRATEGIES.md

@@ -134,6 +134,35 @@ This applies to all standard bump types:
 - `--bump minor`: 1.0.0-beta.1 -> 1.1.0 
 - `--bump patch`: 1.0.0-beta.1 -> 1.0.1
 
+## Package Type Support
+
+`package-versioner` supports both JavaScript/TypeScript projects using `package.json` and Rust projects using `Cargo.toml`:
+
+### JavaScript/TypeScript Projects
+
+For JavaScript/TypeScript projects, the tool looks for and updates the `version` field in `package.json` files according to the versioning strategies described above.
+
+### Rust Projects
+
+For Rust projects, the tool looks for and updates the `package.version` field in `Cargo.toml` files using the same versioning strategies.
+
+When no tags are found for a project, `package-versioner` will:
+1. Look for the `version` in `package.json` if it exists
+2. Look for the `package.version` in `Cargo.toml` if it exists
+3. Fall back to the configured `initialVersion` (default: "0.1.0")
+
+### Mixed Projects with Both Manifests
+
+When both `package.json` and `Cargo.toml` exist in the same directory, `package-versioner` will:
+
+1. Update both manifest files independently with the same calculated version
+2. First check `package.json` for the current version (when no tags exist)
+3. Fall back to checking `Cargo.toml` only if `package.json` doesn't exist or doesn't have a version
+
+This allows you to maintain consistent versioning across JavaScript and Rust components in the same package.
+
+This dual support makes `package-versioner` suitable for both JavaScript/TypeScript and Rust repositories, as well as monorepos or projects containing both types of packages.
+
 ## 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.
@@ -184,4 +213,4 @@ This would produce tags like `release-1.2.3` instead of `v1.2.3`.
   "packageTagTemplate": "${packageName}-${prefix}${version}"
 }
 ```
-This would produce package tags like `@scope/package-name-v1.2.3` instead of `@scope/package-name@v1.2.3`.
+This would produce package tags like `@scope/package-name-v1.2.3` instead of `@scope/package-name@v1.2.3`.