@releasekit/version 0.3.0-next.3 → 0.3.0

package/dist/cli.cjs

@@ -1,2230 +0,0 @@
-#!/usr/bin/env node
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
-};
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/errors/baseError.ts
-var baseError_exports = {};
-__export(baseError_exports, {
-  BasePackageVersionerError: () => BaseVersionError,
-  BaseVersionError: () => BaseVersionError
-});
-var import_core, BaseVersionError;
-var init_baseError = __esm({
-  "src/errors/baseError.ts"() {
-    "use strict";
-    import_core = require("@releasekit/core");
-    BaseVersionError = class _BaseVersionError extends import_core.ReleaseKitError {
-      code;
-      suggestions;
-      constructor(message, code, suggestions) {
-        super(message);
-        this.code = code;
-        this.suggestions = suggestions ?? [];
-      }
-      static isVersionError(error) {
-        return error instanceof _BaseVersionError;
-      }
-    };
-  }
-});
-
-// src/git/commandExecutor.ts
-var commandExecutor_exports = {};
-__export(commandExecutor_exports, {
-  execAsync: () => execAsync,
-  execSync: () => execSync
-});
-var import_node_child_process, execAsync, execSync;
-var init_commandExecutor = __esm({
-  "src/git/commandExecutor.ts"() {
-    "use strict";
-    import_node_child_process = require("child_process");
-    execAsync = (file, args, options) => {
-      const defaultOptions = { maxBuffer: 1024 * 1024 * 10, ...options };
-      return new Promise((resolve2, reject) => {
-        (0, import_node_child_process.execFile)(file, args, defaultOptions, (error, stdout, stderr) => {
-          if (error) {
-            reject(error);
-          } else {
-            resolve2({ stdout: stdout.toString(), stderr: stderr.toString() });
-          }
-        });
-      });
-    };
-    execSync = (file, args, options) => (0, import_node_child_process.execFileSync)(file, args, { maxBuffer: 1024 * 1024 * 10, ...options });
-  }
-});
-
-// src/cli.ts
-var cli_exports = {};
-__export(cli_exports, {
-  run: () => run
-});
-module.exports = __toCommonJS(cli_exports);
-var fs7 = __toESM(require("fs"), 1);
-var import_node_path7 = __toESM(require("path"), 1);
-var import_commander = require("commander");
-
-// src/config.ts
-var import_config = require("@releasekit/config");
-
-// src/types.ts
-function toVersionConfig(config, gitConfig) {
-  if (!config) {
-    return {
-      tagTemplate: "v{version}",
-      packageSpecificTags: false,
-      preset: "conventional",
-      sync: true,
-      packages: [],
-      updateInternalDependencies: "minor",
-      versionPrefix: "",
-      baseBranch: gitConfig?.branch
-    };
-  }
-  return {
-    tagTemplate: config.tagTemplate ?? "v{version}",
-    packageSpecificTags: config.packageSpecificTags,
-    preset: config.preset ?? "conventional",
-    sync: config.sync ?? true,
-    packages: config.packages ?? [],
-    mainPackage: config.mainPackage,
-    updateInternalDependencies: config.updateInternalDependencies ?? "minor",
-    skip: config.skip,
-    commitMessage: config.commitMessage,
-    versionStrategy: config.versionStrategy,
-    branchPatterns: config.branchPatterns?.map((bp) => ({
-      pattern: bp.pattern,
-      releaseType: bp.releaseType
-    })),
-    defaultReleaseType: config.defaultReleaseType,
-    mismatchStrategy: config.mismatchStrategy,
-    versionPrefix: config.versionPrefix ?? "",
-    prereleaseIdentifier: config.prereleaseIdentifier,
-    baseBranch: gitConfig?.branch,
-    cargo: config.cargo
-  };
-}
-
-// src/config.ts
-function loadConfig(options) {
-  const fullConfig = (0, import_config.loadConfig)(options);
-  return toVersionConfig(fullConfig.version, fullConfig.git);
-}
-
-// src/core/versionEngine.ts
-var import_node_process2 = require("process");
-var import_get_packages = require("@manypkg/get-packages");
-
-// src/errors/gitError.ts
-init_baseError();
-var GitError = class extends BaseVersionError {
-};
-
-// src/errors/versionError.ts
-init_baseError();
-var VersionError = class extends BaseVersionError {
-};
-function createVersionError(code, details) {
-  const messages = {
-    ["CONFIG_REQUIRED" /* CONFIG_REQUIRED */]: "Configuration is required",
-    ["PACKAGES_NOT_FOUND" /* PACKAGES_NOT_FOUND */]: "Failed to get packages information",
-    ["WORKSPACE_ERROR" /* WORKSPACE_ERROR */]: "Failed to get workspace packages",
-    ["INVALID_CONFIG" /* INVALID_CONFIG */]: "Invalid configuration",
-    ["PACKAGE_NOT_FOUND" /* PACKAGE_NOT_FOUND */]: "Package not found",
-    ["VERSION_CALCULATION_ERROR" /* VERSION_CALCULATION_ERROR */]: "Failed to calculate version"
-  };
-  const suggestions = {
-    ["CONFIG_REQUIRED" /* CONFIG_REQUIRED */]: [
-      "Create a version.config.json file in your project root",
-      "Check the documentation for configuration examples"
-    ],
-    ["PACKAGES_NOT_FOUND" /* PACKAGES_NOT_FOUND */]: [
-      "Ensure package.json or Cargo.toml files exist in your project",
-      "Check workspace configuration (pnpm-workspace.yaml, etc.)",
-      "Verify file permissions and paths"
-    ],
-    ["WORKSPACE_ERROR" /* WORKSPACE_ERROR */]: [
-      "Verify workspace configuration files are valid",
-      "Check that workspace packages are accessible",
-      "Ensure proper monorepo structure"
-    ],
-    ["INVALID_CONFIG" /* INVALID_CONFIG */]: [
-      "Validate version.config.json syntax",
-      "Check configuration against schema",
-      "Review documentation for valid configuration options"
-    ],
-    ["PACKAGE_NOT_FOUND" /* PACKAGE_NOT_FOUND */]: [
-      "Verify package name spelling and case",
-      "Check if package exists in workspace",
-      "Review packages configuration in version.config.json"
-    ],
-    ["VERSION_CALCULATION_ERROR" /* VERSION_CALCULATION_ERROR */]: [
-      "Ensure git repository has commits",
-      "Check conventional commit message format",
-      "Verify git tags are properly formatted"
-    ]
-  };
-  const baseMessage = messages[code];
-  const fullMessage = details ? `${baseMessage}: ${details}` : baseMessage;
-  return new VersionError(fullMessage, code, suggestions[code]);
-}
-
-// src/utils/logging.ts
-var import_chalk = __toESM(require("chalk"), 1);
-var import_figlet = __toESM(require("figlet"), 1);
-
-// src/utils/jsonOutput.ts
-var _jsonOutputMode = false;
-var _jsonData = {
-  dryRun: false,
-  updates: [],
-  changelogs: [],
-  tags: []
-};
-function enableJsonOutput(dryRun = false) {
-  _jsonOutputMode = true;
-  _jsonData.dryRun = dryRun;
-  _jsonData.updates = [];
-  _jsonData.changelogs = [];
-  _jsonData.tags = [];
-  _jsonData.commitMessage = void 0;
-}
-function isJsonOutputMode() {
-  return _jsonOutputMode;
-}
-function addPackageUpdate(packageName, newVersion, filePath) {
-  if (!_jsonOutputMode) return;
-  _jsonData.updates.push({
-    packageName,
-    newVersion,
-    filePath
-  });
-}
-function addChangelogData(data) {
-  if (!_jsonOutputMode) return;
-  _jsonData.changelogs.push(data);
-}
-function addTag(tag) {
-  if (!_jsonOutputMode) return;
-  _jsonData.tags.push(tag);
-}
-function setCommitMessage(message) {
-  if (!_jsonOutputMode) return;
-  _jsonData.commitMessage = message;
-}
-function printJsonOutput() {
-  if (_jsonOutputMode) {
-    console.log(JSON.stringify(_jsonData, null, 2));
-  }
-}
-
-// src/utils/logging.ts
-function log(message, level = "info") {
-  const showDebug = process.env.DEBUG === "true" || process.env.DEBUG === "1";
-  if (level === "debug" && !showDebug) {
-    return;
-  }
-  let chalkFn;
-  switch (level) {
-    case "success":
-      chalkFn = import_chalk.default.green;
-      break;
-    case "warning":
-      chalkFn = import_chalk.default.yellow;
-      break;
-    case "error":
-      chalkFn = import_chalk.default.red;
-      break;
-    case "debug":
-      chalkFn = import_chalk.default.gray;
-      break;
-    default:
-      chalkFn = import_chalk.default.blue;
-  }
-  const formattedMessage = level === "debug" ? `[DEBUG] ${message}` : message;
-  if (isJsonOutputMode()) {
-    console.error(chalkFn(formattedMessage));
-    return;
-  }
-  if (level === "error") {
-    console.error(chalkFn(formattedMessage));
-  } else {
-    console.log(chalkFn(formattedMessage));
-  }
-}
-
-// src/utils/packageFiltering.ts
-var import_node_path = __toESM(require("path"), 1);
-var import_micromatch = __toESM(require("micromatch"), 1);
-function filterPackagesByConfig(packages, configTargets, workspaceRoot) {
-  if (configTargets.length === 0) {
-    log("No config targets specified, returning all packages", "debug");
-    return packages;
-  }
-  const matchedPackages = /* @__PURE__ */ new Set();
-  for (const target of configTargets) {
-    const dirMatches = filterByDirectoryPattern(packages, target, workspaceRoot);
-    const nameMatches = filterByPackageNamePattern(packages, target);
-    for (const pkg of dirMatches) {
-      matchedPackages.add(pkg);
-    }
-    for (const pkg of nameMatches) {
-      matchedPackages.add(pkg);
-    }
-  }
-  return Array.from(matchedPackages);
-}
-function filterByDirectoryPattern(packages, pattern, workspaceRoot) {
-  if (pattern === "./" || pattern === ".") {
-    return packages.filter((pkg) => pkg.dir === workspaceRoot);
-  }
-  const normalizedPattern = pattern.replace(/\\/g, "/");
-  return packages.filter((pkg) => {
-    const relativePath = import_node_path.default.relative(workspaceRoot, pkg.dir);
-    const normalizedRelativePath = relativePath.replace(/\\/g, "/");
-    if (normalizedPattern === normalizedRelativePath) {
-      return true;
-    }
-    try {
-      return import_micromatch.default.isMatch(normalizedRelativePath, normalizedPattern, {
-        dot: true,
-        noglobstar: false,
-        bash: true
-      });
-    } catch (error) {
-      log(
-        `Invalid directory pattern "${pattern}": ${error instanceof Error ? error.message : String(error)}`,
-        "warning"
-      );
-      return false;
-    }
-  });
-}
-function filterByPackageNamePattern(packages, pattern) {
-  return packages.filter((pkg) => {
-    if (!pkg.packageJson?.name || typeof pkg.packageJson.name !== "string") {
-      return false;
-    }
-    return matchesPackageNamePattern(pkg.packageJson.name, pattern);
-  });
-}
-function matchesPackageNamePattern(packageName, pattern) {
-  if (packageName === pattern) {
-    return true;
-  }
-  if (pattern.startsWith("@") && pattern.endsWith("/*") && !pattern.includes("**")) {
-    const scope = pattern.slice(0, -2);
-    return packageName.startsWith(`${scope}/`);
-  }
-  try {
-    return import_micromatch.default.isMatch(packageName, pattern, {
-      dot: true,
-      contains: false,
-      noglobstar: false,
-      bash: true
-    });
-  } catch (error) {
-    log(
-      `Invalid package name pattern "${pattern}": ${error instanceof Error ? error.message : String(error)}`,
-      "warning"
-    );
-    return false;
-  }
-}
-
-// src/core/versionStrategies.ts
-var import_node_fs6 = __toESM(require("fs"), 1);
-var path6 = __toESM(require("path"), 1);
-
-// src/changelog/commitParser.ts
-init_commandExecutor();
-var CONVENTIONAL_COMMIT_REGEX = /^(\w+)(?:\(([^)]+)\))?(!)?: (.+)(?:\n\n([\s\S]*))?/;
-var BREAKING_CHANGE_REGEX = /BREAKING CHANGE: ([\s\S]+?)(?:\n\n|$)/;
-function extractAllChangelogEntriesWithHash(projectDir, revisionRange) {
-  try {
-    const args = ["log", revisionRange, "--pretty=format:%H|||%B---COMMIT_DELIMITER---", "--no-merges"];
-    const output = execSync("git", args, { cwd: projectDir, encoding: "utf8" }).toString();
-    const commits = output.split("---COMMIT_DELIMITER---").filter((commit) => commit.trim() !== "");
-    return commits.map((commit) => {
-      const [hash, ...messageParts] = commit.split("|||");
-      const message = messageParts.join("|||").trim();
-      const entry = parseCommitMessage(message);
-      if (entry && hash) {
-        return { hash: hash.trim(), entry };
-      }
-      return null;
-    }).filter((item) => item !== null);
-  } catch (error) {
-    const errorMessage = error instanceof Error ? error.message : String(error);
-    log(`Error extracting all commits with hash: ${errorMessage}`, "error");
-    return [];
-  }
-}
-function commitTouchesAnyPackage(projectDir, commitHash, packageDirs, sharedPackageDirs = []) {
-  try {
-    const output = execSync("git", ["diff-tree", "--no-commit-id", "--name-only", "-r", commitHash], {
-      cwd: projectDir,
-      encoding: "utf8"
-    }).toString().trim();
-    if (!output) {
-      return false;
-    }
-    const changedFiles = output.split("\n");
-    return changedFiles.some((file) => {
-      return packageDirs.some((pkgDir) => {
-        if (sharedPackageDirs.some((sharedDir) => pkgDir.includes(sharedDir))) {
-          return false;
-        }
-        const normalizedFile = file.replace(/\\/g, "/");
-        const normalizedPkgDir = pkgDir.replace(/\\/g, "/").replace(/^\.\//, "");
-        return normalizedFile.startsWith(normalizedPkgDir);
-      });
-    });
-  } catch (error) {
-    log(
-      `Error checking if commit ${commitHash} touches packages: ${error instanceof Error ? error.message : String(error)}`,
-      "debug"
-    );
-    return false;
-  }
-}
-function extractRepoLevelChangelogEntries(projectDir, revisionRange, packageDirs, sharedPackageDirs = []) {
-  try {
-    const allCommits = extractAllChangelogEntriesWithHash(projectDir, revisionRange);
-    const repoLevelCommits = allCommits.filter((commit) => {
-      const touchesPackage = commitTouchesAnyPackage(projectDir, commit.hash, packageDirs, sharedPackageDirs);
-      return !touchesPackage;
-    });
-    if (repoLevelCommits.length > 0) {
-      log(
-        `Found ${repoLevelCommits.length} repo-level commit(s) (including shared packages: ${sharedPackageDirs.join(", ")})`,
-        "debug"
-      );
-    }
-    return repoLevelCommits.map((c) => c.entry);
-  } catch (error) {
-    log(`Error extracting repo-level commits: ${error instanceof Error ? error.message : String(error)}`, "warning");
-    return [];
-  }
-}
-function extractChangelogEntriesFromCommits(projectDir, revisionRange) {
-  return extractCommitsFromGitLog(projectDir, revisionRange, true);
-}
-function extractCommitsFromGitLog(projectDir, revisionRange, filterToPath) {
-  try {
-    const args = ["log", revisionRange, "--pretty=format:%B---COMMIT_DELIMITER---", "--no-merges"];
-    if (filterToPath) {
-      args.push("--", ".");
-    }
-    const output = execSync("git", args, { cwd: projectDir, encoding: "utf8" }).toString();
-    const commits = output.split("---COMMIT_DELIMITER---").filter((commit) => commit.trim() !== "");
-    return commits.map((commit) => parseCommitMessage(commit)).filter((entry) => entry !== null);
-  } catch (error) {
-    const errorMessage = error instanceof Error ? error.message : String(error);
-    if (errorMessage.includes("ambiguous argument") && errorMessage.includes("unknown revision")) {
-      const tagName = revisionRange.split("..")[0] || revisionRange;
-      if (tagName.startsWith("v") && !tagName.includes("@")) {
-        log(
-          `Error: Tag "${tagName}" not found. If you're using package-specific tags (like "package-name@v1.0.0"), you may need to configure "tagTemplate" in your version.config.json to use: \${packageName}@\${prefix}\${version}`,
-          "error"
-        );
-      } else {
-        log(
-          `Error: Tag or revision "${tagName}" not found in the repository. Please check if this tag exists or if you need to fetch it from the remote.`,
-          "error"
-        );
-      }
-    } else {
-      log(`Error extracting commits: ${errorMessage}`, "error");
-    }
-    return [];
-  }
-}
-function parseCommitMessage(message) {
-  const trimmedMessage = message.trim();
-  const match = trimmedMessage.match(CONVENTIONAL_COMMIT_REGEX);
-  if (match) {
-    const [, type, scope, breakingMark, subject, body = ""] = match;
-    const breakingFromMark = breakingMark === "!";
-    const breakingChangeMatch = body.match(BREAKING_CHANGE_REGEX);
-    const hasBreakingChange = breakingFromMark || breakingChangeMatch !== null;
-    const changelogType = mapCommitTypeToChangelogType(type);
-    if (!changelogType) {
-      return null;
-    }
-    const issueIds = extractIssueIds(body);
-    let description = subject;
-    if (hasBreakingChange) {
-      description = `**BREAKING** ${description}`;
-    }
-    return {
-      type: changelogType,
-      description,
-      scope: scope || void 0,
-      issueIds: issueIds.length > 0 ? issueIds : void 0,
-      originalType: type
-      // Store original type for custom formatting
-    };
-  }
-  if (!trimmedMessage.startsWith("Merge") && !trimmedMessage.match(/^v?\d+\.\d+\.\d+/)) {
-    const firstLine = trimmedMessage.split("\n")[0].trim();
-    return {
-      type: "changed",
-      description: firstLine
-    };
-  }
-  return null;
-}
-function mapCommitTypeToChangelogType(type) {
-  switch (type) {
-    case "feat":
-      return "added";
-    case "fix":
-      return "fixed";
-    case "docs":
-    case "style":
-    case "refactor":
-    case "perf":
-    case "build":
-    case "ci":
-      return "changed";
-    case "revert":
-      return "removed";
-    case "chore":
-      return "changed";
-    case "test":
-      return null;
-    default:
-      return "changed";
-  }
-}
-function extractIssueIds(body) {
-  const issueRegex = /(?:fix|fixes|close|closes|resolve|resolves)\s+#(\d+)/gi;
-  const issueIds = [];
-  let match = issueRegex.exec(body);
-  while (match !== null) {
-    issueIds.push(`#${match[1]}`);
-    match = issueRegex.exec(body);
-  }
-  return issueIds;
-}
-
-// src/core/versionStrategies.ts
-init_baseError();
-init_commandExecutor();
-
-// src/git/tagsAndBranches.ts
-var import_git_semver_tags = require("git-semver-tags");
-var import_semver = __toESM(require("semver"), 1);
-
-// src/utils/formatting.ts
-function escapeRegExp(string) {
-  return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-function formatVersionPrefix(prefix) {
-  return prefix.endsWith("/") ? prefix.slice(0, -1) : prefix;
-}
-function formatTag(version, prefix, packageName, template, packageSpecificTags) {
-  if (template?.includes("${packageName}") && !packageName) {
-    log(
-      `Warning: Your tagTemplate contains \${packageName} but no package name is available.
-This will result in an empty package name in the tag (e.g., "@v1.0.0" instead of "my-package@v1.0.0").
-
-To fix this:
-\u2022 If using sync mode: Set "packageSpecificTags": true in your config to enable package names in tags
-\u2022 If you want global tags: Remove \${packageName} from your tagTemplate (e.g., use "\${prefix}\${version}")
-\u2022 If using single/async mode: Ensure your package.json has a valid "name" field`,
-      "warning"
-    );
-  }
-  if (template) {
-    return template.replace(/\$\{version\}/g, version).replace(/\$\{prefix\}/g, prefix).replace(/\$\{packageName\}/g, packageName || "");
-  }
-  if (packageSpecificTags && packageName) {
-    return `${packageName}@${prefix}${version}`;
-  }
-  return `${prefix}${version}`;
-}
-function formatCommitMessage(template, version, packageName, additionalContext) {
-  if (template.includes("${packageName}") && !packageName) {
-    log(
-      `Warning: Your commitMessage template contains \${packageName} but no package name is available.
-This will result in an empty package name in the commit message (e.g., "Release @v1.0.0").
-
-To fix this:
-\u2022 If using sync mode: Set "packageSpecificTags": true to enable package names in commits
-\u2022 If you want generic commit messages: Remove \${packageName} from your commitMessage template
-\u2022 If using single/async mode: Ensure your package.json has a valid "name" field`,
-      "warning"
-    );
-  }
-  let result = template.replace(/\$\{version\}/g, version).replace(/\$\{packageName\}/g, packageName || "");
-  if (additionalContext) {
-    for (const [key, value] of Object.entries(additionalContext)) {
-      const placeholder = `${key ? `\${${key}}` : ""}`;
-      result = result.replace(new RegExp(escapeRegExp(placeholder), "g"), value);
-    }
-  }
-  return result;
-}
-
-// src/git/tagsAndBranches.ts
-init_commandExecutor();
-function getCommitsLength(pkgRoot, sinceTag) {
-  try {
-    let amount;
-    if (sinceTag && sinceTag.trim() !== "") {
-      amount = execSync("git", ["rev-list", "--count", `${sinceTag}..HEAD`, pkgRoot]).toString().trim();
-    } else {
-      const latestTag = execSync("git", ["describe", "--tags", "--abbrev=0"]).toString().trim();
-      amount = execSync("git", ["rev-list", "--count", "HEAD", `^${latestTag}`, pkgRoot]).toString().trim();
-    }
-    return Number(amount);
-  } catch (error) {
-    const errorMessage = error instanceof Error ? error.message : String(error);
-    log(`Failed to get number of commits since last tag: ${errorMessage}`, "error");
-    return 0;
-  }
-}
-async function getLatestTag(versionPrefix) {
-  try {
-    const tags = await (0, import_git_semver_tags.getSemverTags)({
-      tagPrefix: versionPrefix
-    });
-    if (tags.length === 0) {
-      return "";
-    }
-    const chronologicalLatest = tags[0];
-    const sortedTags = [...tags].sort((a, b) => {
-      const versionA = import_semver.default.clean(a) || "0.0.0";
-      const versionB = import_semver.default.clean(b) || "0.0.0";
-      return import_semver.default.rcompare(versionA, versionB);
-    });
-    const semanticLatest = sortedTags[0];
-    if (semanticLatest !== chronologicalLatest) {
-      log(
-        `Tag ordering differs: chronological latest is ${chronologicalLatest}, semantic latest is ${semanticLatest}`,
-        "debug"
-      );
-      log(`Using semantic latest (${semanticLatest}) to handle out-of-order tag creation`, "info");
-    }
-    return semanticLatest;
-  } catch (error) {
-    const errorMessage = error instanceof Error ? error.message : String(error);
-    log(`Failed to get latest tag: ${errorMessage}`, "error");
-    if (error instanceof Error && error.message.includes("No names found")) {
-      log("No tags found in the repository.", "info");
-    }
-    return "";
-  }
-}
-async function lastMergeBranchName(branches, baseBranch) {
-  try {
-    const escapedBranches = branches.map((branch) => escapeRegExp(branch));
-    const branchesRegex = `${escapedBranches.join("/(.*)|")}/(.*)`;
-    const { stdout } = await execAsync("git", [
-      "for-each-ref",
-      "--sort=-committerdate",
-      "--format=%(refname:short)",
-      "refs/heads",
-      `--merged=${baseBranch}`
-    ]);
-    const regex = new RegExp(branchesRegex, "i");
-    const matched = stdout.split("\n").map((l) => l.trim()).filter(Boolean).find((b) => regex.test(b));
-    return matched ?? null;
-  } catch (error) {
-    console.error("Error while getting the last branch name:", error instanceof Error ? error.message : String(error));
-    return null;
-  }
-}
-async function getLatestTagForPackage(packageName, versionPrefix, options) {
-  try {
-    const tagTemplate = options?.tagTemplate || `\${prefix}\${version}`;
-    const packageSpecificTags = options?.packageSpecificTags ?? false;
-    const escapedPackageName = escapeRegExp(packageName);
-    const escapedPrefix = versionPrefix ? escapeRegExp(versionPrefix) : "";
-    log(
-      `Looking for tags for package ${packageName} with prefix ${versionPrefix || "none"}, packageSpecificTags: ${packageSpecificTags}`,
-      "debug"
-    );
-    let allTags = [];
-    try {
-      const { execSync: execSync2 } = await Promise.resolve().then(() => (init_commandExecutor(), commandExecutor_exports));
-      const tagsOutput = execSync2("git", ["tag", "-l"], { cwd: process.cwd() });
-      allTags = tagsOutput.toString().trim().split("\n").filter((tag) => tag.length > 0);
-    } catch (err) {
-      log(`Error getting tags: ${err instanceof Error ? err.message : String(err)}`, "error");
-    }
-    log(`Retrieved ${allTags.length} tags`, "debug");
-    if (packageSpecificTags) {
-      const packageTagPattern = escapeRegExp(tagTemplate).replace(/\\\$\\\{packageName\\\}/g, `(?:${escapedPackageName})`).replace(/\\\$\\\{prefix\\\}/g, `(?:${escapedPrefix})`).replace(/\\\$\\\{version\\\}/g, "(?:[0-9]+\\.[0-9]+\\.[0-9]+(?:-[a-zA-Z0-9.-]+)?)");
-      log(`Using package tag pattern: ${packageTagPattern}`, "debug");
-      const packageTagRegex = new RegExp(`^${packageTagPattern}$`);
-      let packageTags = allTags.filter((tag) => packageTagRegex.test(tag));
-      log(`Found ${packageTags.length} matching tags for ${packageName}`, "debug");
-      if (packageTags.length > 0) {
-        const chronologicalFirst = packageTags[0];
-        void chronologicalFirst;
-        const sortedPackageTags2 = [...packageTags].sort((a, b) => {
-          let versionA = "";
-          let versionB = "";
-          if (a.includes("@")) {
-            const parts = a.split("@");
-            const afterAt = parts[parts.length - 1] || "";
-            versionA = afterAt.replace(new RegExp(`^${escapeRegExp(versionPrefix || "")}`), "");
-          } else {
-            versionA = a.replace(new RegExp(`^${escapeRegExp(packageName)}`), "").replace(new RegExp(`^${escapeRegExp(versionPrefix || "")}`), "");
-          }
-          if (b.includes("@")) {
-            const parts = b.split("@");
-            const afterAtB = parts[parts.length - 1] || "";
-            versionB = afterAtB.replace(new RegExp(`^${escapeRegExp(versionPrefix || "")}`), "");
-          } else {
-            versionB = b.replace(new RegExp(`^${escapeRegExp(packageName)}`), "").replace(new RegExp(`^${escapeRegExp(versionPrefix || "")}`), "");
-          }
-          const cleanVersionA = import_semver.default.clean(versionA) || "0.0.0";
-          const cleanVersionB = import_semver.default.clean(versionB) || "0.0.0";
-          return import_semver.default.rcompare(cleanVersionA, cleanVersionB);
-        });
-        log(`Found ${packageTags.length} package tags using configured pattern`, "debug");
-        log(`Using semantically latest tag: ${sortedPackageTags2[0]}`, "debug");
-        return sortedPackageTags2[0];
-      }
-      if (versionPrefix) {
-        const pattern1 = new RegExp(`^${escapedPackageName}@${escapeRegExp(versionPrefix)}`);
-        packageTags = allTags.filter((tag) => pattern1.test(tag));
-        if (packageTags.length > 0) {
-          const sortedPackageTags2 = [...packageTags].sort((a, b) => {
-            const aParts = a.split("@");
-            const afterAt = aParts[aParts.length - 1] || "";
-            const versionA = afterAt.replace(new RegExp(`^${escapeRegExp(versionPrefix || "")}`), "");
-            const bParts = b.split("@");
-            const afterAtB = bParts[bParts.length - 1] || "";
-            const versionB = afterAtB.replace(new RegExp(`^${escapeRegExp(versionPrefix || "")}`), "");
-            const cleanVersionA = import_semver.default.clean(versionA) || "0.0.0";
-            const cleanVersionB = import_semver.default.clean(versionB) || "0.0.0";
-            return import_semver.default.rcompare(cleanVersionA, cleanVersionB);
-          });
-          log(`Found ${packageTags.length} package tags using pattern: packageName@${versionPrefix}...`, "debug");
-          log(`Using semantically latest tag: ${sortedPackageTags2[0]}`, "debug");
-          return sortedPackageTags2[0];
-        }
-      }
-      if (versionPrefix) {
-        const pattern2 = new RegExp(`^${escapeRegExp(versionPrefix)}${escapedPackageName}@`);
-        packageTags = allTags.filter((tag) => pattern2.test(tag));
-        if (packageTags.length > 0) {
-          const sortedPackageTags2 = [...packageTags].sort((a, b) => {
-            const aParts = a.split("@");
-            const versionA = import_semver.default.clean(aParts[aParts.length - 1] || "") || "0.0.0";
-            const bParts = b.split("@");
-            const versionB = import_semver.default.clean(bParts[bParts.length - 1] || "") || "0.0.0";
-            return import_semver.default.rcompare(versionA, versionB);
-          });
-          log(`Found ${packageTags.length} package tags using pattern: ${versionPrefix}packageName@...`, "debug");
-          log(`Using semantically latest tag: ${sortedPackageTags2[0]}`, "debug");
-          return sortedPackageTags2[0];
-        }
-      }
-      const pattern3 = new RegExp(`^${escapedPackageName}@`);
-      packageTags = allTags.filter((tag) => pattern3.test(tag));
-      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");
-        }
-        return "";
-      }
-      const sortedPackageTags = [...packageTags].sort((a, b) => {
-        const aParts = a.split("@");
-        const versionA = import_semver.default.clean(aParts[aParts.length - 1] || "") || "0.0.0";
-        const bParts = b.split("@");
-        const versionB = import_semver.default.clean(bParts[bParts.length - 1] || "") || "0.0.0";
-        return import_semver.default.rcompare(versionA, versionB);
-      });
-      log(`Found ${packageTags.length} package tags for ${packageName}`, "debug");
-      log(`Using semantically latest tag: ${sortedPackageTags[0]}`, "debug");
-      return sortedPackageTags[0];
-    }
-    log(`Package-specific tags disabled for ${packageName}, falling back to global tags`, "debug");
-    return "";
-  } catch (error) {
-    const errorMessage = error instanceof Error ? error.message : String(error);
-    log(`Failed to get latest tag for package ${packageName}: ${errorMessage}`, "error");
-    if (error instanceof Error && error.message.includes("No names found")) {
-      log(`No tags found for package ${packageName}.`, "info");
-    }
-    return "";
-  }
-}
-
-// src/package/packageManagement.ts
-var import_node_fs2 = __toESM(require("fs"), 1);
-var import_node_path3 = __toESM(require("path"), 1);
-
-// src/cargo/cargoHandler.ts
-var import_node_fs = __toESM(require("fs"), 1);
-var import_node_path2 = __toESM(require("path"), 1);
-var import_config2 = require("@releasekit/config");
-var TOML = __toESM(require("smol-toml"), 1);
-function getCargoInfo(cargoPath) {
-  if (!import_node_fs.default.existsSync(cargoPath)) {
-    log(`Cargo.toml file not found at: ${cargoPath}`, "error");
-    throw new Error(`Cargo.toml file not found at: ${cargoPath}`);
-  }
-  try {
-    const cargo = (0, import_config2.parseCargoToml)(cargoPath);
-    if (!cargo.package?.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 updateCargoVersion(cargoPath, version, dryRun = false) {
-  try {
-    const cargo = (0, import_config2.parseCargoToml)(cargoPath);
-    const packageName = cargo.package?.name;
-    if (!packageName) {
-      throw new Error(`No package name found in ${cargoPath}`);
-    }
-    if (!dryRun) {
-      if (!cargo.package) {
-        cargo.package = { name: packageName, version };
-      } else {
-        cargo.package.version = version;
-      }
-      const updatedContent = TOML.stringify(cargo);
-      import_node_fs.default.writeFileSync(cargoPath, updatedContent);
-    }
-    addPackageUpdate(packageName, version, cargoPath);
-    log(`${dryRun ? "[DRY RUN] Would update" : "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, dryRun = false) {
-  if ((0, import_config2.isCargoToml)(packagePath)) {
-    updateCargoVersion(packagePath, version, dryRun);
-    return;
-  }
-  try {
-    const packageContent = import_node_fs2.default.readFileSync(packagePath, "utf8");
-    const packageJson = JSON.parse(packageContent);
-    const packageName = packageJson.name;
-    if (!dryRun) {
-      packageJson.version = version;
-      import_node_fs2.default.writeFileSync(packagePath, `${JSON.stringify(packageJson, null, 2)}
-`);
-    }
-    addPackageUpdate(packageName, version, packagePath);
-    log(
-      `${dryRun ? "[DRY RUN] Would update" : "Updated"} package.json at ${packagePath} to version ${version}`,
-      "success"
-    );
-  } catch (error) {
-    log(`Failed to update package.json at ${packagePath}`, "error");
-    if (error instanceof Error) {
-      log(error.message, "error");
-    }
-    throw error;
-  }
-}
-
-// src/package/packageProcessor.ts
-var fs5 = __toESM(require("fs"), 1);
-var import_node_path6 = __toESM(require("path"), 1);
-
-// src/core/versionCalculator.ts
-var import_node_process = require("process");
-var import_conventional_recommended_bump = require("conventional-recommended-bump");
-var import_semver3 = __toESM(require("semver"), 1);
-
-// src/git/repository.ts
-var import_node_fs3 = require("fs");
-var import_node_path4 = require("path");
-init_commandExecutor();
-function getCurrentBranch() {
-  const result = execSync("git", ["rev-parse", "--abbrev-ref", "HEAD"]);
-  return result.toString().trim();
-}
-
-// src/utils/manifestHelpers.ts
-var import_node_fs4 = __toESM(require("fs"), 1);
-var import_node_path5 = __toESM(require("path"), 1);
-function getVersionFromManifests(packageDir) {
-  const packageJsonPath = import_node_path5.default.join(packageDir, "package.json");
-  const cargoTomlPath = import_node_path5.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");
-    }
-  }
-  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 {
-    version: null,
-    manifestFound: false,
-    manifestPath: "",
-    manifestType: null
-  };
-}
-
-// src/utils/versionUtils.ts
-var import_node_fs5 = __toESM(require("fs"), 1);
-var import_config3 = require("@releasekit/config");
-var import_semver2 = __toESM(require("semver"), 1);
-
-// src/git/tagVerification.ts
-init_commandExecutor();
-function verifyTag(tagName, cwd3) {
-  if (!tagName || tagName.trim() === "") {
-    return { exists: false, reachable: false, error: "Empty tag name" };
-  }
-  try {
-    execSync("git", ["rev-parse", "--verify", tagName], {
-      cwd: cwd3,
-      stdio: "ignore"
-    });
-    return { exists: true, reachable: true };
-  } catch (error) {
-    const errorMessage = error instanceof Error ? error.message : String(error);
-    if (errorMessage.includes("unknown revision") || errorMessage.includes("bad revision") || errorMessage.includes("No such ref")) {
-      return {
-        exists: false,
-        reachable: false,
-        error: `Tag '${tagName}' not found in repository`
-      };
-    }
-    return {
-      exists: false,
-      reachable: false,
-      error: `Git error: ${errorMessage}`
-    };
-  }
-}
-
-// src/utils/versionUtils.ts
-var STANDARD_BUMP_TYPES = ["major", "minor", "patch"];
-function normalizePrereleaseIdentifier(prereleaseIdentifier, config) {
-  if (prereleaseIdentifier === true) {
-    return config?.prereleaseIdentifier || "next";
-  }
-  if (typeof prereleaseIdentifier === "string") {
-    return prereleaseIdentifier;
-  }
-  return void 0;
-}
-function bumpVersion(currentVersion, bumpType, prereleaseIdentifier) {
-  if (prereleaseIdentifier && STANDARD_BUMP_TYPES.includes(bumpType) && !import_semver2.default.prerelease(currentVersion)) {
-    const preBumpType = `pre${bumpType}`;
-    log(`Creating prerelease version with identifier '${prereleaseIdentifier}' using ${preBumpType}`, "debug");
-    return import_semver2.default.inc(currentVersion, preBumpType, prereleaseIdentifier) || "";
-  }
-  if (import_semver2.default.prerelease(currentVersion) && STANDARD_BUMP_TYPES.includes(bumpType)) {
-    const parsed = import_semver2.default.parse(currentVersion);
-    if (!parsed) {
-      return import_semver2.default.inc(currentVersion, bumpType) || "";
-    }
-    if (bumpType === "major" && parsed.minor === 0 && parsed.patch === 0 || bumpType === "minor" && parsed.patch === 0 || bumpType === "patch") {
-      log(`Cleaning prerelease identifier from ${currentVersion} for ${bumpType} bump`, "debug");
-      return `${parsed.major}.${parsed.minor}.${parsed.patch}`;
-    }
-    log(`Standard increment for ${currentVersion} with ${bumpType} bump`, "debug");
-    return import_semver2.default.inc(currentVersion, bumpType) || "";
-  }
-  if (prereleaseIdentifier) {
-    return import_semver2.default.inc(currentVersion, bumpType, prereleaseIdentifier) || "";
-  }
-  return import_semver2.default.inc(currentVersion, bumpType) || "";
-}
-function detectVersionMismatch(tagVersion, packageVersion) {
-  const tagIsPrerelease = import_semver2.default.prerelease(tagVersion) !== null;
-  const packageIsPrerelease = import_semver2.default.prerelease(packageVersion) !== null;
-  const tagParsed = import_semver2.default.parse(tagVersion);
-  const packageParsed = import_semver2.default.parse(packageVersion);
-  if (!tagParsed || !packageParsed) {
-    return { isMismatch: false, severity: "minor", message: "" };
-  }
-  if (!tagIsPrerelease && packageIsPrerelease && tagParsed.major === packageParsed.major) {
-    return {
-      isMismatch: true,
-      severity: "major",
-      message: `Git tag ${tagVersion} (stable) is ahead of package ${packageVersion} (prerelease). This may indicate a reverted release. Consider deleting tag ${tagVersion} or updating package.json.`
-    };
-  }
-  const tagHigher = import_semver2.default.gt(tagVersion, packageVersion);
-  if (tagHigher) {
-    const diff = import_semver2.default.diff(packageVersion, tagVersion);
-    if (diff === "major" || diff === "minor") {
-      return {
-        isMismatch: true,
-        severity: "major",
-        message: `Git tag ${tagVersion} is significantly ahead (${diff}) of package ${packageVersion}. This may cause unexpected version bumps.`
-      };
-    }
-  }
-  if (tagIsPrerelease && !packageIsPrerelease) {
-    return {
-      isMismatch: true,
-      severity: "minor",
-      message: `Git tag ${tagVersion} is a prerelease but package ${packageVersion} is stable. Consider aligning your versioning.`
-    };
-  }
-  return { isMismatch: false, severity: "minor", message: "" };
-}
-var VersionMismatchError = class extends Error {
-  constructor(message, severity) {
-    super(message);
-    this.severity = severity;
-    this.name = "VersionMismatchError";
-  }
-};
-async function getBestVersionSource(tagName, packageVersion, cwd3, mismatchStrategy = "error", strictReachable = false) {
-  if (!tagName?.trim()) {
-    return packageVersion ? { source: "package", version: packageVersion, reason: "No git tag provided" } : { source: "initial", version: "0.1.0", reason: "No git tag or package version available" };
-  }
-  const verification = verifyTag(tagName, cwd3);
-  if (!verification.exists || !verification.reachable) {
-    if (strictReachable) {
-      throw new Error(
-        `Git tag '${tagName}' is not reachable from the current commit. The tag exists but cannot be reached from HEAD, which usually means you're on a different branch or the tag is orphaned. To allow fallback to package version, set strictReachable to false in your configuration.`
-      );
-    }
-    if (packageVersion) {
-      log(
-        `Git tag '${tagName}' unreachable (${verification.error}), using package version: ${packageVersion}`,
-        "warning"
-      );
-      return { source: "package", version: packageVersion, reason: "Git tag unreachable" };
-    }
-    log(`Git tag '${tagName}' unreachable and no package version available, using initial version`, "warning");
-    return {
-      source: "initial",
-      version: "0.1.0",
-      reason: "Git tag unreachable, no package version"
-    };
-  }
-  if (!packageVersion) {
-    return {
-      source: "git",
-      version: tagName,
-      reason: "Git tag exists, no package version to compare"
-    };
-  }
-  try {
-    const cleanTagVersion = tagName.replace(/^.*?([0-9])/, "$1");
-    const cleanPackageVersion = packageVersion;
-    const mismatch = detectVersionMismatch(cleanTagVersion, cleanPackageVersion);
-    const mismatchInfo = mismatch.isMismatch ? { detected: true, severity: mismatch.severity, message: mismatch.message } : void 0;
-    if (mismatch.isMismatch) {
-      switch (mismatchStrategy) {
-        case "error":
-          throw new VersionMismatchError(
-            `Version mismatch detected: ${mismatch.message}
-To resolve: delete the conflicting tag, update package.json, or change mismatchStrategy to 'warn' or 'ignore'`,
-            mismatch.severity
-          );
-        case "warn":
-          log(mismatch.message, "warning");
-          log(
-            `Continuing with git tag ${tagName}. To use package version instead, set mismatchStrategy to 'prefer-package'`,
-            "warning"
-          );
-          break;
-        case "ignore":
-          break;
-        case "prefer-package":
-          log(mismatch.message, "warning");
-          log(`Using package version ${packageVersion} due to mismatchStrategy='prefer-package'`, "info");
-          return {
-            source: "package",
-            version: packageVersion,
-            reason: "Mismatch detected, using package version per strategy",
-            mismatch: mismatchInfo
-          };
-        case "prefer-git":
-          log(mismatch.message, "warning");
-          log(`Using git tag ${tagName} due to mismatchStrategy='prefer-git'`, "info");
-          return {
-            source: "git",
-            version: tagName,
-            reason: "Mismatch detected, using git tag per strategy",
-            mismatch: mismatchInfo
-          };
-      }
-    }
-    if (import_semver2.default.gt(cleanPackageVersion, cleanTagVersion)) {
-      log(`Package version ${packageVersion} is newer than git tag ${tagName}, using package version`, "info");
-      return {
-        source: "package",
-        version: packageVersion,
-        reason: "Package version is newer",
-        mismatch: mismatchInfo
-      };
-    }
-    if (import_semver2.default.gt(cleanTagVersion, cleanPackageVersion)) {
-      log(`Git tag ${tagName} is newer than package version ${packageVersion}, using git tag`, "info");
-      return {
-        source: "git",
-        version: tagName,
-        reason: "Git tag is newer",
-        mismatch: mismatchInfo
-      };
-    }
-    return {
-      source: "git",
-      version: tagName,
-      reason: "Versions equal, using git tag",
-      mismatch: mismatchInfo
-    };
-  } catch (error) {
-    if (error instanceof VersionMismatchError) {
-      throw error;
-    }
-    log(`Failed to compare versions, defaulting to git tag: ${error}`, "warning");
-    return { source: "git", version: tagName, reason: "Version comparison failed" };
-  }
-}
-
-// src/core/versionCalculator.ts
-async function calculateVersion(config, options) {
-  const {
-    type: configType,
-    preset = "angular",
-    versionPrefix,
-    prereleaseIdentifier: configPrereleaseIdentifier,
-    branchPattern,
-    baseBranch,
-    mismatchStrategy,
-    strictReachable
-  } = config;
-  const {
-    latestTag,
-    name,
-    path: pkgPath,
-    type: optionsType,
-    prereleaseIdentifier: optionsPrereleaseIdentifier
-  } = options;
-  const type = optionsType || configType;
-  const prereleaseIdentifier = optionsPrereleaseIdentifier || configPrereleaseIdentifier;
-  const initialVersion = "0.1.0";
-  const hasNoTags = !latestTag || latestTag.trim() === "";
-  const normalizedPrereleaseId = normalizePrereleaseIdentifier(prereleaseIdentifier, config);
-  try {
-    let determineTagSearchPattern2 = function(packageName, prefix) {
-      if (!packageName) {
-        return prefix;
-      }
-      return `${packageName}@${prefix}`;
-    }, escapeRegExp3 = function(string) {
-      return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-    }, getCurrentVersionFromSource2 = function() {
-      if (!versionSource) {
-        if (hasNoTags) {
-          return initialVersion;
-        }
-        const cleanedTag = import_semver3.default.clean(latestTag) || latestTag;
-        return import_semver3.default.clean(cleanedTag.replace(new RegExp(`^${escapedTagPattern}`), "")) || "0.0.0";
-      }
-      if (versionSource.source === "git") {
-        const cleanedTag = import_semver3.default.clean(versionSource.version) || versionSource.version;
-        return import_semver3.default.clean(cleanedTag.replace(new RegExp(`^${escapedTagPattern}`), "")) || "0.0.0";
-      }
-      return versionSource.version;
-    };
-    var determineTagSearchPattern = determineTagSearchPattern2, escapeRegExp2 = escapeRegExp3, getCurrentVersionFromSource = getCurrentVersionFromSource2;
-    const originalPrefix = versionPrefix || "";
-    const tagSearchPattern = determineTagSearchPattern2(name, originalPrefix);
-    const escapedTagPattern = escapeRegExp3(tagSearchPattern);
-    let versionSource;
-    if (pkgPath) {
-      const packageDir = pkgPath || (0, import_node_process.cwd)();
-      const manifestResult = getVersionFromManifests(packageDir);
-      const packageVersion = manifestResult.manifestFound && manifestResult.version ? manifestResult.version : void 0;
-      versionSource = await getBestVersionSource(
-        latestTag,
-        packageVersion,
-        packageDir,
-        mismatchStrategy,
-        strictReachable
-      );
-      log(`Using version source: ${versionSource.source} (${versionSource.reason})`, "info");
-    }
-    const specifiedType = type;
-    if (specifiedType) {
-      const currentVersion = getCurrentVersionFromSource2();
-      const isCurrentPrerelease = import_semver3.default.prerelease(currentVersion);
-      const explicitlyRequestedPrerelease = config.isPrerelease;
-      if (STANDARD_BUMP_TYPES.includes(specifiedType) && (isCurrentPrerelease || explicitlyRequestedPrerelease)) {
-        const prereleaseId2 = explicitlyRequestedPrerelease || isCurrentPrerelease ? normalizedPrereleaseId : void 0;
-        log(
-          explicitlyRequestedPrerelease ? `Creating prerelease version with identifier '${prereleaseId2}' using ${specifiedType}` : `Cleaning prerelease identifier from ${currentVersion} for ${specifiedType} bump`,
-          "debug"
-        );
-        return bumpVersion(currentVersion, specifiedType, prereleaseId2);
-      }
-      const isPrereleaseBumpType = ["prerelease", "premajor", "preminor", "prepatch"].includes(specifiedType);
-      const prereleaseId = config.isPrerelease || isPrereleaseBumpType ? normalizedPrereleaseId : void 0;
-      return bumpVersion(currentVersion, specifiedType, prereleaseId);
-    }
-    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) {
-        const currentVersion = getCurrentVersionFromSource2();
-        log(`Applying ${branchVersionType} bump based on branch pattern`, "debug");
-        const isPrereleaseBumpType = ["prerelease", "premajor", "preminor", "prepatch"].includes(branchVersionType);
-        const prereleaseId = config.isPrerelease || isPrereleaseBumpType ? normalizedPrereleaseId : void 0;
-        return bumpVersion(currentVersion, branchVersionType, prereleaseId);
-      }
-    }
-    try {
-      const bumper = new import_conventional_recommended_bump.Bumper();
-      bumper.loadPreset(preset);
-      const recommendedBump = await bumper.bump();
-      const releaseTypeFromCommits = recommendedBump && "releaseType" in recommendedBump ? recommendedBump.releaseType : void 0;
-      const currentVersion = getCurrentVersionFromSource2();
-      if (versionSource && versionSource.source === "git") {
-        const checkPath = pkgPath || (0, import_node_process.cwd)();
-        const commitsLength = getCommitsLength(checkPath, versionSource.version);
-        if (commitsLength === 0) {
-          log(
-            `No new commits found for ${name || "project"} since ${versionSource.version}, skipping version bump`,
-            "info"
-          );
-          return "";
-        }
-      } else if (versionSource && versionSource.source === "package") {
-        log(
-          `Using package version ${versionSource.version} as base, letting conventional commits determine bump necessity`,
-          "debug"
-        );
-      }
-      if (!releaseTypeFromCommits) {
-        if (latestTag && latestTag.trim() !== "") {
-          log(`No relevant commits found for ${name || "project"} since ${latestTag}, skipping version bump`, "info");
-        } else {
-          log(`No relevant commits found for ${name || "project"}, skipping version bump`, "info");
-        }
-        return "";
-      }
-      const isPrereleaseBumpType = ["prerelease", "premajor", "preminor", "prepatch"].includes(releaseTypeFromCommits);
-      const prereleaseId = config.isPrerelease || isPrereleaseBumpType ? normalizedPrereleaseId : void 0;
-      return bumpVersion(currentVersion, releaseTypeFromCommits, prereleaseId);
-    } 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;
-    }
-  } 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;
-  }
-}
-
-// src/utils/packageMatching.ts
-var import_micromatch2 = __toESM(require("micromatch"), 1);
-function matchesPackageTarget(packageName, target) {
-  if (packageName === target) {
-    return true;
-  }
-  if (target.startsWith("@") && target.endsWith("/*") && !target.includes("**")) {
-    const scope = target.slice(0, -2);
-    return packageName.startsWith(`${scope}/`);
-  }
-  try {
-    return import_micromatch2.default.isMatch(packageName, target, {
-      dot: true,
-      contains: false,
-      // Changed to false to ensure full pattern matching
-      noglobstar: false,
-      bash: true
-    });
-  } catch (error) {
-    log(`Invalid pattern "${target}": ${error instanceof Error ? error.message : String(error)}`, "warning");
-    return false;
-  }
-}
-function shouldMatchPackageTargets(packageName, targets) {
-  return targets.some((target) => matchesPackageTarget(packageName, target));
-}
-function shouldProcessPackage(packageName, skip = []) {
-  if (skip.length === 0) {
-    return true;
-  }
-  return !shouldMatchPackageTargets(packageName, skip);
-}
-
-// src/package/packageProcessor.ts
-var PackageProcessor = class {
-  skip;
-  versionPrefix;
-  tagTemplate;
-  commitMessageTemplate;
-  dryRun;
-  getLatestTag;
-  config;
-  // Config for version calculation
-  fullConfig;
-  constructor(options) {
-    this.skip = options.skip || [];
-    this.versionPrefix = options.versionPrefix || "v";
-    this.tagTemplate = options.tagTemplate;
-    this.commitMessageTemplate = options.commitMessageTemplate || "";
-    this.dryRun = options.dryRun || false;
-    this.getLatestTag = options.getLatestTag;
-    this.config = options.config;
-    this.fullConfig = options.fullConfig;
-  }
-  /**
-   * Process packages based on skip list only (targeting handled at discovery time)
-   */
-  async processPackages(packages) {
-    const tags = [];
-    const updatedPackagesInfo = [];
-    if (!packages || !Array.isArray(packages)) {
-      log("Invalid packages data provided. Expected array of packages.", "error");
-      return { updatedPackages: [], tags: [] };
-    }
-    const pkgsToConsider = packages.filter((pkg) => {
-      const pkgName = pkg.packageJson.name;
-      const shouldProcess = shouldProcessPackage(pkgName, this.skip);
-      if (!shouldProcess) {
-        log(`Skipping package ${pkgName} as it's in the skip list.`, "info");
-      }
-      return shouldProcess;
-    });
-    log(`Found ${pkgsToConsider.length} package(s) to process after filtering.`, "info");
-    if (pkgsToConsider.length === 0) {
-      log("No packages found to process.", "info");
-      return { updatedPackages: [], tags: [] };
-    }
-    for (const pkg of pkgsToConsider) {
-      const name = pkg.packageJson.name;
-      const pkgPath = pkg.dir;
-      log(`Processing package ${name} at path: ${pkgPath}`, "info");
-      const formattedPrefix = formatVersionPrefix(this.versionPrefix);
-      let latestTagResult = "";
-      try {
-        latestTagResult = await getLatestTagForPackage(name, this.versionPrefix, {
-          tagTemplate: this.tagTemplate,
-          packageSpecificTags: this.fullConfig.packageSpecificTags
-        });
-      } catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        log(`Error getting package-specific tag for ${name}, falling back to global tag: ${errorMessage}`, "warning");
-      }
-      if (!latestTagResult) {
-        try {
-          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 fallback version, using empty tag value: ${errorMessage}`, "warning");
-        }
-      }
-      const latestTag = latestTagResult;
-      const nextVersion = await calculateVersion(this.fullConfig, {
-        latestTag,
-        versionPrefix: formattedPrefix,
-        path: pkgPath,
-        name,
-        branchPattern: this.config.branchPattern,
-        baseBranch: this.config.baseBranch,
-        prereleaseIdentifier: this.config.prereleaseIdentifier,
-        type: this.config.type
-      });
-      if (!nextVersion) {
-        continue;
-      }
-      let changelogEntries = [];
-      let revisionRange = "HEAD";
-      try {
-        if (latestTag) {
-          const verification = verifyTag(latestTag, pkgPath);
-          if (verification.exists && verification.reachable) {
-            revisionRange = `${latestTag}..HEAD`;
-          } else {
-            if (this.config.strictReachable) {
-              throw new Error(
-                `Cannot generate changelog: tag '${latestTag}' is not reachable from the current commit. When strictReachable is enabled, all tags must be reachable. To allow fallback to all commits, set strictReachable to false.`
-              );
-            }
-            log(`Tag ${latestTag} is unreachable (${verification.error}), using all commits for changelog`, "debug");
-            revisionRange = "HEAD";
-          }
-        } else {
-          revisionRange = "HEAD";
-        }
-        changelogEntries = extractChangelogEntriesFromCommits(pkgPath, revisionRange);
-        const allPackageDirs = packages.map((p) => p.dir);
-        const sharedPackageNames = ["config", "core", "@releasekit/config", "@releasekit/core"];
-        const sharedPackageDirs = packages.filter((p) => sharedPackageNames.includes(p.packageJson.name)).map((p) => p.dir);
-        const repoLevelEntries = extractRepoLevelChangelogEntries(
-          pkgPath,
-          revisionRange,
-          allPackageDirs,
-          sharedPackageDirs
-        );
-        if (repoLevelEntries.length > 0) {
-          log(`Adding ${repoLevelEntries.length} repo-level commit(s) to ${name} changelog`, "debug");
-          changelogEntries = [...repoLevelEntries, ...changelogEntries];
-        }
-        if (changelogEntries.length === 0) {
-          changelogEntries = [
-            {
-              type: "changed",
-              description: `Update version to ${nextVersion}`
-            }
-          ];
-        }
-      } catch (error) {
-        log(`Error extracting changelog entries: ${error instanceof Error ? error.message : String(error)}`, "warning");
-        changelogEntries = [
-          {
-            type: "changed",
-            description: `Update version to ${nextVersion}`
-          }
-        ];
-      }
-      let repoUrl;
-      try {
-        const packageJsonPath2 = import_node_path6.default.join(pkgPath, "package.json");
-        if (fs5.existsSync(packageJsonPath2)) {
-          const packageJson = JSON.parse(fs5.readFileSync(packageJsonPath2, "utf8"));
-          if (packageJson.repository) {
-            if (typeof packageJson.repository === "string") {
-              repoUrl = packageJson.repository;
-            } else if (packageJson.repository.url) {
-              repoUrl = packageJson.repository.url;
-            }
-            if (repoUrl?.startsWith("git+") && repoUrl?.endsWith(".git")) {
-              repoUrl = repoUrl.substring(4, repoUrl.length - 4);
-            }
-          }
-        }
-      } catch (error) {
-        log(
-          `Could not determine repository URL for changelog links: ${error instanceof Error ? error.message : String(error)}`,
-          "warning"
-        );
-      }
-      addChangelogData({
-        packageName: name,
-        version: nextVersion,
-        previousVersion: latestTag || null,
-        revisionRange,
-        repoUrl: repoUrl || null,
-        entries: changelogEntries
-      });
-      const packageJsonPath = import_node_path6.default.join(pkgPath, "package.json");
-      if (fs5.existsSync(packageJsonPath)) {
-        updatePackageVersion(packageJsonPath, nextVersion, this.dryRun);
-      }
-      const cargoEnabled = this.fullConfig.cargo?.enabled !== false;
-      log(`Cargo enabled for ${name}: ${cargoEnabled}, config: ${JSON.stringify(this.fullConfig.cargo)}`, "debug");
-      if (cargoEnabled) {
-        const cargoPaths = this.fullConfig.cargo?.paths;
-        log(`Cargo paths config for ${name}: ${JSON.stringify(cargoPaths)}`, "debug");
-        if (cargoPaths && cargoPaths.length > 0) {
-          for (const cargoPath of cargoPaths) {
-            const resolvedCargoPath = import_node_path6.default.resolve(pkgPath, cargoPath, "Cargo.toml");
-            log(`Checking cargo path for ${name}: ${resolvedCargoPath}`, "debug");
-            if (fs5.existsSync(resolvedCargoPath)) {
-              log(`Found Cargo.toml for ${name} at ${resolvedCargoPath}, updating...`, "debug");
-              updatePackageVersion(resolvedCargoPath, nextVersion, this.dryRun);
-            } else {
-              log(`Cargo.toml not found at ${resolvedCargoPath}`, "debug");
-            }
-          }
-        } else {
-          const cargoTomlPath = import_node_path6.default.join(pkgPath, "Cargo.toml");
-          log(`Checking default cargo path for ${name}: ${cargoTomlPath}`, "debug");
-          if (fs5.existsSync(cargoTomlPath)) {
-            log(`Found Cargo.toml for ${name} at ${cargoTomlPath}, updating...`, "debug");
-            updatePackageVersion(cargoTomlPath, nextVersion, this.dryRun);
-          } else {
-            log(`Cargo.toml not found for ${name} at ${cargoTomlPath}`, "debug");
-          }
-        }
-      } else {
-        log(`Cargo disabled for ${name}`, "debug");
-      }
-      const packageTag = formatTag(
-        nextVersion,
-        this.versionPrefix,
-        name,
-        this.tagTemplate,
-        this.fullConfig.packageSpecificTags
-      );
-      addTag(packageTag);
-      tags.push(packageTag);
-      if (this.dryRun) {
-        log(`[DRY RUN] Would create tag: ${packageTag}`, "info");
-      } else {
-        log(`Version ${nextVersion} prepared (tag: ${packageTag})`, "success");
-      }
-      updatedPackagesInfo.push({ name, version: nextVersion, path: pkgPath });
-    }
-    if (updatedPackagesInfo.length === 0) {
-      log("No packages required a version update.", "info");
-      return { updatedPackages: [], tags };
-    }
-    const packageNames = updatedPackagesInfo.map((p) => p.name).join(", ");
-    const representativeVersion = updatedPackagesInfo[0]?.version || "multiple";
-    let commitMessage = this.commitMessageTemplate || "chore(release): publish packages";
-    const MAX_COMMIT_MSG_LENGTH = 1e4;
-    if (commitMessage.length > MAX_COMMIT_MSG_LENGTH) {
-      log("Commit message template too long, truncating", "warning");
-      commitMessage = commitMessage.slice(0, MAX_COMMIT_MSG_LENGTH);
-    }
-    const placeholderRegex = /\$\{[^{}$]{1,1000}\}/;
-    if (updatedPackagesInfo.length === 1 && placeholderRegex.test(commitMessage)) {
-      const packageName = updatedPackagesInfo[0].name;
-      commitMessage = formatCommitMessage(commitMessage, representativeVersion, packageName);
-    } else {
-      commitMessage = `chore(release): ${packageNames} ${representativeVersion}`;
-    }
-    setCommitMessage(commitMessage);
-    if (this.dryRun) {
-      log(`[DRY RUN] Would commit with message: "${commitMessage}"`, "info");
-    }
-    return {
-      updatedPackages: updatedPackagesInfo,
-      commitMessage,
-      tags
-    };
-  }
-};
-
-// src/core/versionStrategies.ts
-function shouldProcessPackage2(pkg, config) {
-  const pkgName = pkg.packageJson.name;
-  return shouldProcessPackage(pkgName, config.skip);
-}
-function updateCargoFiles(packageDir, version, cargoConfig, dryRun = false) {
-  const updatedFiles = [];
-  const cargoEnabled = cargoConfig?.enabled !== false;
-  if (!cargoEnabled) {
-    return updatedFiles;
-  }
-  const cargoPaths = cargoConfig?.paths;
-  if (cargoPaths && cargoPaths.length > 0) {
-    for (const cargoPath of cargoPaths) {
-      const resolvedCargoPath = path6.resolve(packageDir, cargoPath, "Cargo.toml");
-      if (import_node_fs6.default.existsSync(resolvedCargoPath)) {
-        updatePackageVersion(resolvedCargoPath, version, dryRun);
-        updatedFiles.push(resolvedCargoPath);
-      }
-    }
-  } else {
-    const cargoTomlPath = path6.join(packageDir, "Cargo.toml");
-    if (import_node_fs6.default.existsSync(cargoTomlPath)) {
-      updatePackageVersion(cargoTomlPath, version, dryRun);
-      updatedFiles.push(cargoTomlPath);
-    }
-  }
-  return updatedFiles;
-}
-function createSyncStrategy(config) {
-  return async (packages) => {
-    try {
-      const {
-        versionPrefix,
-        tagTemplate,
-        baseBranch,
-        branchPattern,
-        commitMessage = `chore(release): v\${version}`,
-        prereleaseIdentifier,
-        dryRun,
-        mainPackage
-      } = config;
-      const formattedPrefix = formatVersionPrefix(versionPrefix || "v");
-      let latestTag = await getLatestTag();
-      let mainPkgPath = packages.root;
-      let mainPkgName;
-      if (mainPackage) {
-        const mainPkg = packages.packages.find((p) => p.packageJson.name === mainPackage);
-        if (mainPkg) {
-          mainPkgPath = mainPkg.dir;
-          mainPkgName = mainPkg.packageJson.name;
-          log(`Using ${mainPkgName} as primary package for version determination`, "info");
-        } else {
-          log(`Main package '${mainPackage}' not found. Using root package for version determination.`, "warning");
-        }
-      }
-      if (!mainPkgPath) {
-        mainPkgPath = process.cwd();
-        log(`No valid package path found, using current working directory: ${mainPkgPath}`, "warning");
-      }
-      if (mainPkgName) {
-        const packageSpecificTag = await getLatestTagForPackage(mainPkgName, formattedPrefix, {
-          tagTemplate,
-          packageSpecificTags: config.packageSpecificTags
-        });
-        if (packageSpecificTag) {
-          latestTag = packageSpecificTag;
-          log(`Using package-specific tag for ${mainPkgName}: ${latestTag}`, "debug");
-        } else {
-          log(`No package-specific tag found for ${mainPkgName}, using global tag: ${latestTag}`, "debug");
-        }
-      }
-      const nextVersion = await calculateVersion(config, {
-        latestTag,
-        versionPrefix: formattedPrefix,
-        branchPattern,
-        baseBranch,
-        prereleaseIdentifier,
-        path: mainPkgPath,
-        name: mainPkgName,
-        type: config.type
-      });
-      if (!nextVersion) {
-        const msg = mainPkgName ? `No version change needed for ${mainPkgName}` : "No version change needed";
-        log(msg, "info");
-        return;
-      }
-      const files = [];
-      const updatedPackages = [];
-      const processedPaths = /* @__PURE__ */ new Set();
-      try {
-        if (packages.root) {
-          const rootPkgPath = path6.join(packages.root, "package.json");
-          if (import_node_fs6.default.existsSync(rootPkgPath)) {
-            updatePackageVersion(rootPkgPath, nextVersion, dryRun);
-            files.push(rootPkgPath);
-            updatedPackages.push("root");
-            processedPaths.add(rootPkgPath);
-            const rootCargoFiles = updateCargoFiles(packages.root, nextVersion, config.cargo, dryRun);
-            files.push(...rootCargoFiles);
-          }
-        } else {
-          log("Root package path is undefined, skipping root package.json update", "warning");
-        }
-      } catch (error) {
-        const errMessage = error instanceof Error ? error.message : String(error);
-        log(`Failed to update root package.json: ${errMessage}`, "error");
-      }
-      for (const pkg of packages.packages) {
-        if (!shouldProcessPackage2(pkg, config)) {
-          continue;
-        }
-        const packageJsonPath = path6.join(pkg.dir, "package.json");
-        if (processedPaths.has(packageJsonPath)) {
-          continue;
-        }
-        updatePackageVersion(packageJsonPath, nextVersion, dryRun);
-        files.push(packageJsonPath);
-        updatedPackages.push(pkg.packageJson.name);
-        processedPaths.add(packageJsonPath);
-        const pkgCargoFiles = updateCargoFiles(pkg.dir, nextVersion, config.cargo, dryRun);
-        files.push(...pkgCargoFiles);
-      }
-      if (updatedPackages.length > 0) {
-        log(`Updated ${updatedPackages.length} package(s) to version ${nextVersion}`, "success");
-      } else {
-        log("No packages were updated", "warning");
-        return;
-      }
-      let changelogEntries = [];
-      let revisionRange = "HEAD";
-      try {
-        if (latestTag) {
-          try {
-            execSync("git", ["rev-parse", "--verify", latestTag], {
-              cwd: mainPkgPath,
-              stdio: "ignore"
-            });
-            revisionRange = `${latestTag}..HEAD`;
-          } catch {
-            if (config.strictReachable) {
-              throw new Error(
-                `Cannot generate changelog: tag '${latestTag}' is not reachable from the current commit. When strictReachable is enabled, all tags must be reachable. To allow fallback to all commits, set strictReachable to false.`
-              );
-            }
-            log(`Tag ${latestTag} doesn't exist, using all commits for changelog`, "debug");
-            revisionRange = "HEAD";
-          }
-        }
-        changelogEntries = extractChangelogEntriesFromCommits(mainPkgPath, revisionRange);
-        if (changelogEntries.length === 0) {
-          changelogEntries = [
-            {
-              type: "changed",
-              description: `Update version to ${nextVersion}`
-            }
-          ];
-        }
-      } catch (error) {
-        log(`Error extracting changelog entries: ${error instanceof Error ? error.message : String(error)}`, "warning");
-        changelogEntries = [
-          {
-            type: "changed",
-            description: `Update version to ${nextVersion}`
-          }
-        ];
-      }
-      addChangelogData({
-        packageName: mainPkgName || "monorepo",
-        version: nextVersion,
-        previousVersion: latestTag || null,
-        revisionRange,
-        repoUrl: null,
-        entries: changelogEntries
-      });
-      let tagPackageName = null;
-      let commitPackageName;
-      if (config.packageSpecificTags && packages.packages.length === 1) {
-        tagPackageName = packages.packages[0].packageJson.name;
-        commitPackageName = packages.packages[0].packageJson.name;
-      }
-      const nextTag = formatTag(
-        nextVersion,
-        formattedPrefix,
-        tagPackageName,
-        tagTemplate,
-        config.packageSpecificTags || false
-      );
-      const formattedCommitMessage = formatCommitMessage(commitMessage, nextVersion, commitPackageName, void 0);
-      addTag(nextTag);
-      setCommitMessage(formattedCommitMessage);
-      if (!dryRun) {
-        log(`Version ${nextVersion} prepared (tag: ${nextTag})`, "success");
-      } else {
-        log(`Would create tag: ${nextTag}`, "info");
-      }
-    } catch (error) {
-      if (BaseVersionError.isVersionError(error)) {
-        log(`Synced Strategy failed: ${error.message} (${error.code})`, "error");
-      } else {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        log(`Synced Strategy failed: ${errorMessage}`, "error");
-      }
-      throw error;
-    }
-  };
-}
-function createSingleStrategy(config) {
-  return async (packages) => {
-    try {
-      const { mainPackage, versionPrefix, tagTemplate, commitMessage = `chore(release): \${version}`, dryRun } = config;
-      let packageName;
-      if (mainPackage) {
-        packageName = mainPackage;
-      } else if (packages.packages.length === 1) {
-        packageName = packages.packages[0].packageJson.name;
-      } else {
-        throw createVersionError(
-          "INVALID_CONFIG" /* INVALID_CONFIG */,
-          "Single mode requires either mainPackage or exactly one resolved package"
-        );
-      }
-      const pkg = packages.packages.find((p) => p.packageJson.name === packageName);
-      if (!pkg) {
-        throw createVersionError("PACKAGE_NOT_FOUND" /* PACKAGE_NOT_FOUND */, packageName);
-      }
-      const pkgPath = pkg.dir;
-      const formattedPrefix = formatVersionPrefix(versionPrefix || "v");
-      let latestTagResult = await getLatestTagForPackage(packageName, formattedPrefix, {
-        tagTemplate,
-        packageSpecificTags: config.packageSpecificTags
-      });
-      if (!latestTagResult) {
-        const globalTagResult = await getLatestTag();
-        latestTagResult = globalTagResult || "";
-      }
-      const latestTag = latestTagResult;
-      let nextVersion;
-      nextVersion = await calculateVersion(config, {
-        latestTag,
-        versionPrefix: formattedPrefix,
-        branchPattern: config.branchPattern,
-        baseBranch: config.baseBranch,
-        prereleaseIdentifier: config.prereleaseIdentifier,
-        path: pkgPath,
-        name: packageName,
-        type: config.type
-      });
-      if (!nextVersion) {
-        log(`No version change needed for ${packageName}`, "info");
-        return;
-      }
-      let changelogEntries = [];
-      let revisionRange = "HEAD";
-      try {
-        if (latestTag) {
-          try {
-            execSync("git", ["rev-parse", "--verify", latestTag], {
-              cwd: pkgPath,
-              stdio: "ignore"
-            });
-            revisionRange = `${latestTag}..HEAD`;
-          } catch {
-            if (config.strictReachable) {
-              throw new Error(
-                `Cannot generate changelog: tag '${latestTag}' is not reachable from the current commit. When strictReachable is enabled, all tags must be reachable. To allow fallback to all commits, set strictReachable to false.`
-              );
-            }
-            log(`Tag ${latestTag} doesn't exist, using all commits for changelog`, "debug");
-            revisionRange = "HEAD";
-          }
-        } else {
-          revisionRange = "HEAD";
-        }
-        changelogEntries = extractChangelogEntriesFromCommits(pkgPath, revisionRange);
-        if (changelogEntries.length === 0) {
-          changelogEntries = [
-            {
-              type: "changed",
-              description: `Update version to ${nextVersion}`
-            }
-          ];
-        }
-      } catch (error) {
-        log(`Error extracting changelog entries: ${error instanceof Error ? error.message : String(error)}`, "warning");
-        changelogEntries = [
-          {
-            type: "changed",
-            description: `Update version to ${nextVersion}`
-          }
-        ];
-      }
-      let repoUrl;
-      try {
-        const packageJsonPath2 = path6.join(pkgPath, "package.json");
-        if (import_node_fs6.default.existsSync(packageJsonPath2)) {
-          const packageJson = JSON.parse(import_node_fs6.default.readFileSync(packageJsonPath2, "utf8"));
-          if (packageJson.repository) {
-            if (typeof packageJson.repository === "string") {
-              repoUrl = packageJson.repository;
-            } else if (packageJson.repository.url) {
-              repoUrl = packageJson.repository.url;
-            }
-            if (repoUrl?.startsWith("git+") && repoUrl?.endsWith(".git")) {
-              repoUrl = repoUrl.substring(4, repoUrl.length - 4);
-            }
-          }
-        }
-      } catch (error) {
-        log(
-          `Could not determine repository URL for changelog links: ${error instanceof Error ? error.message : String(error)}`,
-          "warning"
-        );
-      }
-      addChangelogData({
-        packageName,
-        version: nextVersion,
-        previousVersion: latestTag || null,
-        revisionRange,
-        repoUrl: repoUrl || null,
-        entries: changelogEntries
-      });
-      const packageJsonPath = path6.join(pkgPath, "package.json");
-      updatePackageVersion(packageJsonPath, nextVersion, dryRun);
-      const filesToCommit = [packageJsonPath];
-      const cargoFiles = updateCargoFiles(pkgPath, nextVersion, config.cargo, dryRun);
-      filesToCommit.push(...cargoFiles);
-      log(`Updated package ${packageName} to version ${nextVersion}`, "success");
-      const tagName = formatTag(nextVersion, formattedPrefix, packageName, tagTemplate, config.packageSpecificTags);
-      const commitMsg = formatCommitMessage(commitMessage, nextVersion, packageName);
-      addTag(tagName);
-      setCommitMessage(commitMsg);
-      if (!dryRun) {
-        log(`Version ${nextVersion} prepared (tag: ${tagName})`, "success");
-      } else {
-        log(`Would create tag: ${tagName}`, "info");
-      }
-    } catch (error) {
-      if (BaseVersionError.isVersionError(error)) {
-        log(`Single Strategy failed: ${error.message} (${error.code})`, "error");
-      } else {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        log(`Single Strategy failed: ${errorMessage}`, "error");
-      }
-      throw error;
-    }
-  };
-}
-function createAsyncStrategy(config) {
-  const dependencies = {
-    getLatestTag
-  };
-  const processorOptions = {
-    skip: config.skip || [],
-    versionPrefix: config.versionPrefix || "v",
-    tagTemplate: config.tagTemplate,
-    commitMessageTemplate: config.commitMessage || "",
-    dryRun: config.dryRun || false,
-    getLatestTag: dependencies.getLatestTag,
-    fullConfig: config,
-    // Extract common version configuration properties
-    config: {
-      branchPattern: config.branchPattern || [],
-      baseBranch: config.baseBranch || "main",
-      prereleaseIdentifier: config.prereleaseIdentifier,
-      type: config.type
-    }
-  };
-  const packageProcessor = new PackageProcessor(processorOptions);
-  return async (packages, targets = []) => {
-    try {
-      let packagesToProcess = packages.packages;
-      if (targets.length > 0) {
-        const beforeCount = packagesToProcess.length;
-        packagesToProcess = packagesToProcess.filter((pkg) => targets.includes(pkg.packageJson.name));
-        log(
-          `Runtime targets filter: ${beforeCount} \u2192 ${packagesToProcess.length} packages (${targets.join(", ")})`,
-          "info"
-        );
-      }
-      log(`Processing ${packagesToProcess.length} packages`, "info");
-      const result = await packageProcessor.processPackages(packagesToProcess);
-      if (result.updatedPackages.length === 0) {
-        log("No packages required a version update.", "info");
-      } else {
-        const packageNames = result.updatedPackages.map((p) => p.name).join(", ");
-        log(`Updated ${result.updatedPackages.length} package(s): ${packageNames}`, "success");
-        if (result.tags.length > 0) {
-          log(`Created ${result.tags.length} tag(s): ${result.tags.join(", ")}`, "success");
-        }
-        if (result.commitMessage) {
-          log(`Created commit with message: "${result.commitMessage}"`, "success");
-        }
-      }
-    } catch (error) {
-      if (BaseVersionError.isVersionError(error)) {
-        log(`Async Strategy failed: ${error.message} (${error.code})`, "error");
-      } else {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        log(`Async Strategy failed: ${errorMessage}`, "error");
-      }
-      throw error;
-    }
-  };
-}
-function createStrategy(config) {
-  if (config.sync) {
-    return createSyncStrategy(config);
-  }
-  return createAsyncStrategy(config);
-}
-function createStrategyMap(config) {
-  return {
-    sync: createSyncStrategy(config),
-    single: createSingleStrategy(config),
-    async: createAsyncStrategy(config)
-  };
-}
-
-// src/core/versionEngine.ts
-var VersionEngine = class {
-  config;
-  workspaceCache = null;
-  strategies;
-  currentStrategy;
-  constructor(config, _jsonMode = false) {
-    if (!config) {
-      throw createVersionError("CONFIG_REQUIRED" /* CONFIG_REQUIRED */);
-    }
-    if (!config.preset) {
-      config.preset = "conventional-commits";
-      log("No preset specified, using default: conventional-commits", "warning");
-    }
-    this.config = config;
-    this.strategies = createStrategyMap(config);
-    this.currentStrategy = createStrategy(config);
-  }
-  /**
-   * Get workspace packages information - with caching for performance
-   */
-  async getWorkspacePackages() {
-    try {
-      if (this.workspaceCache) {
-        return this.workspaceCache;
-      }
-      const pkgsResult = (0, import_get_packages.getPackagesSync)((0, import_node_process2.cwd)());
-      if (!pkgsResult || !pkgsResult.packages) {
-        throw createVersionError("PACKAGES_NOT_FOUND" /* PACKAGES_NOT_FOUND */);
-      }
-      if (!pkgsResult.root) {
-        log("Root path is undefined in packages result, setting to current working directory", "warning");
-        pkgsResult.root = (0, import_node_process2.cwd)();
-      }
-      if (this.config.packages && this.config.packages.length > 0) {
-        const originalCount = pkgsResult.packages.length;
-        const filteredPackages = filterPackagesByConfig(pkgsResult.packages, this.config.packages, pkgsResult.root);
-        pkgsResult.packages = filteredPackages;
-        log(
-          `Filtered ${originalCount} workspace packages to ${filteredPackages.length} based on packages config`,
-          "info"
-        );
-        if (filteredPackages.length === 0) {
-          log("Warning: No packages matched the specified patterns in config.packages", "warning");
-        }
-      }
-      this.workspaceCache = pkgsResult;
-      return pkgsResult;
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      log(`Failed to get packages information: ${errorMessage}`, "error");
-      console.error(error);
-      throw createVersionError("WORKSPACE_ERROR" /* WORKSPACE_ERROR */, errorMessage);
-    }
-  }
-  /**
-   * Run the current strategy
-   * @param packages Workspace packages to process
-   * @param targets Optional package targets to process (only used by async strategy)
-   */
-  async run(packages, targets = []) {
-    try {
-      return this.currentStrategy(packages, targets);
-    } catch (error) {
-      if (error instanceof VersionError || error instanceof GitError) {
-        log(`Version engine failed: ${error.message} (${error.code || "UNKNOWN"})`, "error");
-        if (error instanceof GitError) {
-          console.error("Git error details:");
-          if (error.message.includes("Command failed:")) {
-            const cmdOutput = error.message.split("Command failed:")[1];
-            if (cmdOutput) {
-              console.error("Command output:", cmdOutput.trim());
-            }
-          }
-        }
-      } else {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        log(`Version engine failed: ${errorMessage}`, "error");
-        if (error instanceof Error && error.stack) {
-          console.error("Error stack trace:");
-          console.error(error.stack);
-        }
-      }
-      throw error;
-    }
-  }
-  /**
-   * Change the current strategy
-   * @param strategyType The strategy type to use: 'sync', 'single', or 'async'
-   */
-  setStrategy(strategyType) {
-    this.currentStrategy = this.strategies[strategyType];
-  }
-};
-
-// src/cli.ts
-var import_meta = {};
-function getPackageVersion() {
-  try {
-    const packageJsonPath = import_node_path7.default.resolve(import_node_path7.default.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 main() {
-  const program = new import_commander.Command();
-  program.name("releasekit-version").description("Version a package or packages based on conventional commits").version(getPackageVersion()).command("version", { isDefault: true }).description("Version a package or packages based on configuration").option("-c, --config <path>", "Path to config file (defaults to releasekit.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, --sync", "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").option("--project-dir <path>", "Project directory to run commands in", process.cwd()).action(async (options) => {
-    if (options.json) {
-      enableJsonOutput(options.dryRun);
-    }
-    try {
-      const originalCwd = process.cwd();
-      if (options.projectDir && options.projectDir !== originalCwd) {
-        try {
-          process.chdir(options.projectDir);
-          log(`Changed working directory to: ${options.projectDir}`, "debug");
-        } catch (error) {
-          throw new Error(
-            `Failed to change to directory "${options.projectDir}": ${error instanceof Error ? error.message : String(error)}`
-          );
-        }
-      }
-      const config = loadConfig({ cwd: options.projectDir, configPath: options.config });
-      log(`Loaded configuration from ${options.config || "releasekit.config.json"}`, "info");
-      if (options.dryRun) config.dryRun = true;
-      if (options.sync) config.sync = true;
-      if (options.bump) config.type = options.bump;
-      if (options.prerelease) {
-        config.prereleaseIdentifier = options.prerelease === true ? "next" : options.prerelease;
-        config.isPrerelease = true;
-      }
-      const cliTargets = options.target ? options.target.split(",").map((t) => t.trim()) : [];
-      if (cliTargets.length > 0) {
-        config.packages = cliTargets;
-        log(`CLI targets specified: ${cliTargets.join(", ")}`, "info");
-      }
-      const engine = new VersionEngine(config, !!options.json);
-      const pkgsResult = await engine.getWorkspacePackages();
-      const resolvedCount = pkgsResult.packages.length;
-      log(`Resolved ${resolvedCount} packages from workspace`, "debug");
-      log(`Config packages: ${JSON.stringify(config.packages)}`, "debug");
-      log(`Config sync: ${config.sync}`, "debug");
-      if (config.sync) {
-        log("Using sync versioning strategy.", "info");
-        engine.setStrategy("sync");
-        await engine.run(pkgsResult);
-      } else if (resolvedCount === 1) {
-        log("Using single package versioning strategy.", "info");
-        if (cliTargets.length > 0) {
-          log("--target flag is ignored for single package strategy.", "warning");
-        }
-        engine.setStrategy("single");
-        await engine.run(pkgsResult);
-      } else if (resolvedCount === 0) {
-        throw new Error("No packages found in workspace");
-      } else {
-        log("Using async versioning strategy.", "info");
-        if (cliTargets.length > 0) {
-          log(`Targeting specific packages: ${cliTargets.join(", ")}`, "info");
-        }
-        engine.setStrategy("async");
-        await engine.run(pkgsResult, cliTargets);
-      }
-      log("Versioning process completed.", "success");
-      printJsonOutput();
-    } catch (error) {
-      const { BaseVersionError: BaseVersionError2 } = await Promise.resolve().then(() => (init_baseError(), baseError_exports));
-      if (BaseVersionError2.isVersionError(error)) {
-        error.logError();
-      } else {
-        log(`Error: ${error instanceof Error ? error.message : String(error)}`, "error");
-      }
-      process.exit(1);
-    }
-  });
-  program.parse();
-}
-async function run() {
-  await main();
-}
-main();
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  run
-});