package-versioner 0.5.4 → 0.6.1

package/dist/index.cjs

@@ -34,8 +34,8 @@ __export(index_exports, {
   run: () => run
 });
 module.exports = __toCommonJS(index_exports);
-var fs6 = __toESM(require("fs"), 1);
-var import_node_path4 = __toESM(require("path"), 1);
+var fs8 = __toESM(require("fs"), 1);
+var import_node_path6 = __toESM(require("path"), 1);
 var import_commander = require("commander");
 
 // src/config.ts
@@ -190,8 +190,8 @@ function log(message, level = "info") {
 }
 
 // src/core/versionStrategies.ts
-var import_node_fs3 = __toESM(require("fs"), 1);
-var path4 = __toESM(require("path"), 1);
+var import_node_fs6 = __toESM(require("fs"), 1);
+var path5 = __toESM(require("path"), 1);
 
 // src/git/commands.ts
 var import_node_process2 = require("process");
@@ -473,15 +473,84 @@ async function getLatestTagForPackage(packageName, versionPrefix) {
 }
 
 // src/package/packageManagement.ts
+var import_node_fs3 = __toESM(require("fs"), 1);
+var import_node_path3 = __toESM(require("path"), 1);
+
+// src/cargo/cargoHandler.ts
 var import_node_fs2 = __toESM(require("fs"), 1);
 var import_node_path2 = __toESM(require("path"), 1);
+var TOML = __toESM(require("smol-toml"), 1);
+function getCargoInfo(cargoPath) {
+  var _a;
+  if (!import_node_fs2.default.existsSync(cargoPath)) {
+    log(`Cargo.toml file not found at: ${cargoPath}`, "error");
+    throw new Error(`Cargo.toml file not found at: ${cargoPath}`);
+  }
+  try {
+    const fileContent = import_node_fs2.default.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: import_node_path2.default.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 import_node_path2.default.basename(filePath) === "Cargo.toml";
+}
+function updateCargoVersion(cargoPath, version) {
+  var _a;
+  try {
+    const originalContent = import_node_fs2.default.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);
+    import_node_fs2.default.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 = import_node_fs2.default.readFileSync(packagePath, "utf8");
+    const packageContent = import_node_fs3.default.readFileSync(packagePath, "utf8");
     const packageJson = JSON.parse(packageContent);
     const packageName = packageJson.name;
     packageJson.version = version;
-    import_node_fs2.default.writeFileSync(packagePath, `${JSON.stringify(packageJson, null, 2)}
+    import_node_fs3.default.writeFileSync(packagePath, `${JSON.stringify(packageJson, null, 2)}
 `);
     addPackageUpdate(packageName, version, packagePath);
     log(`Updated package.json at ${packagePath} to version ${version}`, "success");
@@ -495,125 +564,218 @@ function updatePackageVersion(packagePath, version) {
 }
 
 // src/package/packageProcessor.ts
-var fs4 = __toESM(require("fs"), 1);
-var import_node_path3 = __toESM(require("path"), 1);
+var fs6 = __toESM(require("fs"), 1);
+var import_node_path5 = __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);
-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}@`;
+var import_semver2 = __toESM(require("semver"), 1);
+
+// src/utils/manifestHelpers.ts
+var import_node_fs4 = __toESM(require("fs"), 1);
+var import_node_path4 = __toESM(require("path"), 1);
+function getVersionFromManifests(packageDir) {
+  const packageJsonPath = import_node_path4.default.join(packageDir, "package.json");
+  const cargoTomlPath = import_node_path4.default.join(packageDir, "Cargo.toml");
+  if (import_node_fs4.default.existsSync(packageJsonPath)) {
+    try {
+      const packageJson = JSON.parse(import_node_fs4.default.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 = 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 ${specifiedType} bump`,
-        "debug"
-      );
-      return bumpVersion(currentVersion, specifiedType, prereleaseIdentifier);
+  if (import_node_fs4.default.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 import_semver.default.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 = import_node_path4.default.join(packageDir, "package.json");
+  const cargoTomlPath = import_node_path4.default.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
+var import_node_fs5 = __toESM(require("fs"), 1);
+var import_semver = __toESM(require("semver"), 1);
+var TOML2 = __toESM(require("smol-toml"), 1);
+var STANDARD_BUMP_TYPES = ["major", "minor", "patch"];
+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}`;
     }
-    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 import_semver.default.inc(currentVersion, bumpType) || "";
+  }
+  return import_semver.default.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 = 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(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 = import_semver2.default.clean(latestTag) || latestTag;
+      const currentVersion = import_semver2.default.clean(cleanedTag.replace(new RegExp(`^${escapedTagPattern}`), "")) || "0.0.0";
+      if (STANDARD_BUMP_TYPES.includes(specifiedType) && import_semver2.default.prerelease(currentVersion)) {
+        log(
+          `Cleaning prerelease identifier from ${currentVersion} for ${specifiedType} bump`,
+          "debug"
         );
+        return bumpVersion(currentVersion, specifiedType, prereleaseIdentifier);
       }
-      return initialVersion;
+      return import_semver2.default.inc(currentVersion, specifiedType, prereleaseIdentifier) || "";
     }
-    const checkPath = pkgPath || (0, import_node_process3.cwd)();
-    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 = import_semver2.default.clean(latestTag) || latestTag;
+        const currentVersion = import_semver2.default.clean(cleanedTag.replace(new RegExp(`^${escapedTagPattern}`), "")) || "0.0.0";
+        log(`Applying ${branchVersionType} bump based on branch pattern`, "debug");
+        return import_semver2.default.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 import_conventional_recommended_bump.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 || (0, import_node_process3.cwd)();
+      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 = import_semver2.default.clean(latestTag.replace(new RegExp(`^${escapedTagPattern}`), "")) || "0.0.0";
+      return import_semver2.default.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 = import_semver.default.clean(latestTag.replace(new RegExp(`^${escapedTagPattern}`), "")) || "0.0.0";
-    return import_semver.default.inc(currentVersion, releaseTypeFromCommits, prereleaseIdentifier) || "";
   } catch (error) {
     log(`Failed to calculate version for ${name || "project"}`, "error");
     console.error(error);
@@ -626,51 +788,37 @@ async function calculateVersion(config, options) {
 }
 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;
-    }
+  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) && 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)}`
+    return calculateNextVersion(
+      manifestResult.version,
+      manifestResult.manifestType || "manifest",
+      name,
+      releaseType,
+      prereleaseIdentifier,
+      initialVersion
     );
   }
+  throwIfNoManifestsFound(packageDir);
 }
-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}`;
+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) && import_semver2.default.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 import_semver.default.inc(currentVersion, bumpType) || "";
+    log(`Cleaning prerelease identifier from ${version} for ${releaseType} bump`, "debug");
+    return bumpVersion(version, releaseType, prereleaseIdentifier);
   }
-  return import_semver.default.inc(currentVersion, bumpType, prereleaseIdentifier) || "";
+  return import_semver2.default.inc(version, releaseType, prereleaseIdentifier) || initialVersion;
 }
 
 // src/package/packageProcessor.ts
@@ -754,29 +902,22 @@ var PackageProcessor = class {
       }
       if (!latestTagResult) {
         try {
-          const packageJsonPath = import_node_path3.default.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;
@@ -802,7 +943,14 @@ var PackageProcessor = class {
       if (!nextVersion) {
         continue;
       }
-      updatePackageVersion(import_node_path3.default.join(pkgPath, "package.json"), nextVersion);
+      const packageJsonPath = import_node_path5.default.join(pkgPath, "package.json");
+      const cargoTomlPath = import_node_path5.default.join(pkgPath, "Cargo.toml");
+      if (fs6.existsSync(packageJsonPath)) {
+        updatePackageVersion(packageJsonPath, nextVersion);
+      }
+      if (fs6.existsSync(cargoTomlPath)) {
+        updatePackageVersion(cargoTomlPath, nextVersion);
+      }
       const packageTag = formatTag(
         nextVersion,
         this.versionPrefix,
@@ -833,7 +981,7 @@ var PackageProcessor = class {
       log("No targeted packages required a version update.", "info");
       return { updatedPackages: [], tags };
     }
-    const filesToCommit = updatedPackagesInfo.map((info) => import_node_path3.default.join(info.path, "package.json"));
+    const filesToCommit = updatedPackagesInfo.map((info) => import_node_path5.default.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";
@@ -910,8 +1058,8 @@ function createSyncedStrategy(config) {
       const files = [];
       const updatedPackages = [];
       try {
-        const rootPkgPath = path4.join(packages.root, "package.json");
-        if (import_node_fs3.default.existsSync(rootPkgPath)) {
+        const rootPkgPath = path5.join(packages.root, "package.json");
+        if (import_node_fs6.default.existsSync(rootPkgPath)) {
           updatePackageVersion(rootPkgPath, nextVersion);
           files.push(rootPkgPath);
           updatedPackages.push("root");
@@ -923,7 +1071,7 @@ function createSyncedStrategy(config) {
         if (!shouldProcessPackage(pkg, config)) {
           continue;
         }
-        const packageJsonPath = path4.join(pkg.dir, "package.json");
+        const packageJsonPath = path5.join(pkg.dir, "package.json");
         updatePackageVersion(packageJsonPath, nextVersion);
         files.push(packageJsonPath);
         updatedPackages.push(pkg.packageJson.name);
@@ -996,7 +1144,7 @@ function createSingleStrategy(config) {
         log(`No version change needed for ${packageName}`, "info");
         return;
       }
-      const packageJsonPath = path4.join(pkgPath, "package.json");
+      const packageJsonPath = path5.join(pkgPath, "package.json");
       updatePackageVersion(packageJsonPath, nextVersion);
       log(`Updated package ${packageName} to version ${nextVersion}`, "success");
       const nextTag = formatTag(
@@ -1175,11 +1323,11 @@ var VersionEngine = class {
 var import_meta = {};
 function getPackageVersion() {
   try {
-    const packageJsonPath = import_node_path4.default.resolve(
-      import_node_path4.default.dirname(import_meta.url.replace("file:", "")),
+    const packageJsonPath = import_node_path6.default.resolve(
+      import_node_path6.default.dirname(import_meta.url.replace("file:", "")),
       "../package.json"
     );
-    const packageJsonContent = fs6.readFileSync(packageJsonPath, "utf-8");
+    const packageJsonContent = fs8.readFileSync(packageJsonPath, "utf-8");
     const packageJson = JSON.parse(packageJsonContent);
     return packageJson.version || "0.0.0";
   } catch (error) {
@@ -1209,7 +1357,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) {