package-versioner 0.5.3 → 0.6.0

package/dist/index.js

@@ -1,6 +1,8 @@
 #!/usr/bin/env node
 
 // src/index.ts
+import * as fs7 from "node:fs";
+import path5 from "node:path";
 import { Command } from "commander";
 
 // src/config.ts
@@ -117,9 +119,13 @@ function printJsonOutput() {
 }
 
 // src/utils/logging.ts
-function log(message, status = "info") {
+function log(message, level = "info") {
+  const showDebug = process.env.DEBUG === "true" || process.env.DEBUG === "1";
+  if (level === "debug" && !showDebug) {
+    return;
+  }
   let chalkFn;
-  switch (status) {
+  switch (level) {
     case "success":
       chalkFn = chalk.green;
       break;
@@ -136,22 +142,23 @@ function log(message, status = "info") {
       chalkFn = chalk.blue;
   }
   if (isJsonOutputMode()) {
-    if (status === "error") {
+    if (level === "error") {
       chalkFn(message);
       console.error(message);
     }
     return;
   }
-  if (status === "error") {
-    console.error(chalkFn(message));
+  const formattedMessage = level === "debug" ? `[DEBUG] ${message}` : message;
+  if (level === "error") {
+    console.error(chalkFn(formattedMessage));
   } else {
-    console.log(chalkFn(message));
+    console.log(chalkFn(formattedMessage));
   }
 }
 
 // src/core/versionStrategies.ts
-import fs4 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";
@@ -374,11 +381,53 @@ async function lastMergeBranchName(branches, baseBranch) {
 }
 async function getLatestTagForPackage(packageName, versionPrefix) {
   try {
+    const escapedPackageName = escapeRegExp(packageName);
+    log(
+      `Looking for tags for package ${packageName} with prefix ${versionPrefix || "none"}`,
+      "debug"
+    );
     const allTags = await getSemverTags({
       tagPrefix: versionPrefix
     });
-    const packageTagPattern = versionPrefix ? new RegExp(`^${escapeRegExp(versionPrefix)}${escapeRegExp(packageName)}@`) : new RegExp(`^${escapeRegExp(packageName)}@`);
-    const packageTags = allTags.filter((tag) => packageTagPattern.test(tag));
+    log(`Retrieved ${allTags.length} tags: ${allTags.join(", ")}`, "debug");
+    let packageTags = [];
+    if (versionPrefix) {
+      const pattern1 = new RegExp(`^${escapedPackageName}@${escapeRegExp(versionPrefix)}`);
+      packageTags = allTags.filter((tag) => pattern1.test(tag));
+      if (packageTags.length > 0) {
+        log(
+          `Found ${packageTags.length} package tags using pattern: packageName@${versionPrefix}...`,
+          "debug"
+        );
+        log(`Using tag: ${packageTags[0]}`, "debug");
+        return packageTags[0];
+      }
+    }
+    if (versionPrefix) {
+      const pattern2 = new RegExp(`^${escapeRegExp(versionPrefix)}${escapedPackageName}@`);
+      packageTags = allTags.filter((tag) => pattern2.test(tag));
+      if (packageTags.length > 0) {
+        log(
+          `Found ${packageTags.length} package tags using pattern: ${versionPrefix}packageName@...`,
+          "debug"
+        );
+        log(`Using tag: ${packageTags[0]}`, "debug");
+        return packageTags[0];
+      }
+    }
+    const pattern3 = new RegExp(`^${escapedPackageName}@`);
+    packageTags = allTags.filter((tag) => pattern3.test(tag));
+    log(`Found ${packageTags.length} package tags for ${packageName}`, "debug");
+    if (packageTags.length === 0) {
+      log("No matching tags found for pattern: packageName@version", "debug");
+      if (allTags.length > 0) {
+        log(`Available tags: ${allTags.join(", ")}`, "debug");
+      } else {
+        log("No tags available in the repository", "debug");
+      }
+    } else {
+      log(`Using tag: ${packageTags[0]}`, "debug");
+    }
     return packageTags[0] || "";
   } catch (error) {
     const errorMessage = error instanceof Error ? error.message : String(error);
@@ -391,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");
@@ -412,124 +530,217 @@ function updatePackageVersion(packagePath, version) {
 }
 
 // src/package/packageProcessor.ts
-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);
@@ -542,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
@@ -670,14 +867,31 @@ var PackageProcessor = class {
       }
       if (!latestTagResult) {
         try {
-          const globalTagResult = await this.getLatestTag();
-          latestTagResult = globalTagResult || "";
-          if (globalTagResult) {
-            log(`Using global tag ${globalTagResult} as fallback for package ${name}`, "info");
+          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 (!manifestFallbackUsed) {
+            const globalTagResult = await this.getLatestTag();
+            if (globalTagResult) {
+              latestTagResult = globalTagResult;
+              log(`Using global tag ${globalTagResult} as fallback for package ${name}`, "info");
+            }
           }
         } catch (error) {
           const errorMessage = error instanceof Error ? error.message : String(error);
-          log(`Error getting global tag, using empty tag value: ${errorMessage}`, "warning");
+          log(`Error getting fallback version, using empty tag value: ${errorMessage}`, "warning");
         }
       }
       const latestTag = latestTagResult;
@@ -694,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,
@@ -725,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";
@@ -802,8 +1023,8 @@ function createSyncedStrategy(config) {
       const files = [];
       const updatedPackages = [];
       try {
-        const rootPkgPath = path3.join(packages.root, "package.json");
-        if (fs4.existsSync(rootPkgPath)) {
+        const rootPkgPath = path4.join(packages.root, "package.json");
+        if (fs6.existsSync(rootPkgPath)) {
           updatePackageVersion(rootPkgPath, nextVersion);
           files.push(rootPkgPath);
           updatedPackages.push("root");
@@ -815,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);
@@ -888,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(
@@ -1064,11 +1285,28 @@ var VersionEngine = class {
 };
 
 // src/index.ts
+function getPackageVersion() {
+  try {
+    const packageJsonPath = path5.resolve(
+      path5.dirname(import.meta.url.replace("file:", "")),
+      "../package.json"
+    );
+    const packageJsonContent = fs7.readFileSync(packageJsonPath, "utf-8");
+    const packageJson = JSON.parse(packageJsonContent);
+    return packageJson.version || "0.0.0";
+  } catch (error) {
+    console.error("Failed to read package version:", error);
+    return "0.0.0";
+  }
+}
 async function run() {
+  const buildTimestamp = (/* @__PURE__ */ new Date()).toISOString();
+  const packageVersion = getPackageVersion();
+  log(`package-versioner v${packageVersion} (Build: ${buildTimestamp})`, "debug");
   const program = new Command();
   program.name("package-versioner").description(
     "A lightweight yet powerful CLI tool for automated semantic versioning based on Git history and conventional commits."
-  ).version(process.env.npm_package_version || "0.0.0").option(
+  ).version(packageVersion).option(
     "-c, --config <path>",
     "Path to config file (defaults to version.config.json in current directory)"
   ).option("-d, --dry-run", "Dry run (no changes made)", false).option("-b, --bump <type>", "Specify bump type (patch|minor|major)").option("-p, --prerelease [identifier]", "Create prerelease version").option("-s, --synced", "Use synchronized versioning across all packages").option("-j, --json", "Output results as JSON", false).option("-t, --target <packages>", "Comma-delimited list of package names to target").parse(process.argv);
@@ -1083,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) {
@@ -1116,3 +1354,6 @@ run().catch((error) => {
   console.error("Fatal error:", error);
   process.exit(1);
 });
+export {
+  run
+};