@releasekit/version 0.1.0 → 0.1.1-next.0

package/dist/chunk-KZDV4EBO.js

@@ -1,2170 +0,0 @@
-import {
-  BaseVersionError
-} from "./chunk-GQLJ7JQY.js";
-
-// src/config.ts
-import { loadVersionConfig } from "@releasekit/config";
-
-// src/types.ts
-function toVersionConfig(config) {
-  if (!config) {
-    return {
-      tagTemplate: "v{version}",
-      packageSpecificTags: false,
-      preset: "conventional",
-      sync: true,
-      packages: [],
-      updateInternalDependencies: "minor",
-      versionPrefix: ""
-    };
-  }
-  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,
-    skipHooks: config.skipHooks,
-    mismatchStrategy: config.mismatchStrategy,
-    versionPrefix: config.versionPrefix ?? "",
-    prereleaseIdentifier: config.prereleaseIdentifier,
-    baseBranch: config.baseBranch,
-    cargo: config.cargo
-  };
-}
-
-// src/config.ts
-function loadConfig(options) {
-  const versionConfig = loadVersionConfig(options);
-  return toVersionConfig(versionConfig);
-}
-
-// src/errors/versionError.ts
-var VersionError = class extends BaseVersionError {
-};
-var VersionErrorCode = /* @__PURE__ */ ((VersionErrorCode2) => {
-  VersionErrorCode2["CONFIG_REQUIRED"] = "CONFIG_REQUIRED";
-  VersionErrorCode2["PACKAGES_NOT_FOUND"] = "PACKAGES_NOT_FOUND";
-  VersionErrorCode2["WORKSPACE_ERROR"] = "WORKSPACE_ERROR";
-  VersionErrorCode2["INVALID_CONFIG"] = "INVALID_CONFIG";
-  VersionErrorCode2["PACKAGE_NOT_FOUND"] = "PACKAGE_NOT_FOUND";
-  VersionErrorCode2["VERSION_CALCULATION_ERROR"] = "VERSION_CALCULATION_ERROR";
-  return VersionErrorCode2;
-})(VersionErrorCode || {});
-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/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 getJsonData() {
-  return { ..._jsonData };
-}
-function printJsonOutput() {
-  if (_jsonOutputMode) {
-    console.log(JSON.stringify(_jsonData, null, 2));
-  }
-}
-
-// src/utils/logging.ts
-import chalk from "chalk";
-import figlet from "figlet";
-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 = chalk.green;
-      break;
-    case "warning":
-      chalkFn = chalk.yellow;
-      break;
-    case "error":
-      chalkFn = chalk.red;
-      break;
-    case "debug":
-      chalkFn = chalk.gray;
-      break;
-    default:
-      chalkFn = chalk.blue;
-  }
-  if (isJsonOutputMode()) {
-    if (level === "error") {
-      chalkFn(message);
-      console.error(message);
-    }
-    return;
-  }
-  const formattedMessage = level === "debug" ? `[DEBUG] ${message}` : message;
-  if (level === "error") {
-    console.error(chalkFn(formattedMessage));
-  } else {
-    console.log(chalkFn(formattedMessage));
-  }
-}
-
-// src/core/versionCalculator.ts
-import { cwd } from "process";
-import { Bumper } from "conventional-recommended-bump";
-import semver3 from "semver";
-
-// src/git/repository.ts
-import { existsSync, statSync } from "fs";
-import { join } from "path";
-
-// src/git/commandExecutor.ts
-import { execFile, execFileSync } from "child_process";
-var execAsync = (file, args, options) => {
-  const defaultOptions = { maxBuffer: 1024 * 1024 * 10, ...options };
-  return new Promise((resolve2, reject) => {
-    execFile(file, args, defaultOptions, (error, stdout, stderr) => {
-      if (error) {
-        reject(error);
-      } else {
-        resolve2({ stdout: stdout.toString(), stderr: stderr.toString() });
-      }
-    });
-  });
-};
-var execSync = (file, args, options) => execFileSync(file, args, { maxBuffer: 1024 * 1024 * 10, ...options });
-
-// src/git/repository.ts
-function isGitRepository(directory) {
-  const gitDir = join(directory, ".git");
-  if (!existsSync(gitDir)) {
-    return false;
-  }
-  const stats = statSync(gitDir);
-  if (!stats.isDirectory()) {
-    return false;
-  }
-  try {
-    execSync("git", ["rev-parse", "--is-inside-work-tree"], { cwd: directory });
-    return true;
-  } catch (_error) {
-    return false;
-  }
-}
-function getCurrentBranch() {
-  const result = execSync("git", ["rev-parse", "--abbrev-ref", "HEAD"]);
-  return result.toString().trim();
-}
-
-// src/git/tagsAndBranches.ts
-import { getSemverTags } from "git-semver-tags";
-import semver from "semver";
-
-// 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}}`;
-      result = result.replace(new RegExp(placeholder.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), "g"), value);
-    }
-  }
-  return result;
-}
-
-// src/git/tagsAndBranches.ts
-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 getSemverTags({
-      tagPrefix: versionPrefix
-    });
-    if (tags.length === 0) {
-      return "";
-    }
-    const chronologicalLatest = tags[0];
-    const sortedTags = [...tags].sort((a, b) => {
-      const versionA = semver.clean(a) || "0.0.0";
-      const versionB = semver.clean(b) || "0.0.0";
-      return semver.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"
-    );
-    const allTags = await getSemverTags({
-      tagPrefix: versionPrefix
-    });
-    log(`Retrieved ${allTags.length} tags: ${allTags.join(", ")}`, "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));
-      if (packageTags.length > 0) {
-        const chronologicalFirst = packageTags[0];
-        const sortedPackageTags2 = [...packageTags].sort((a, b) => {
-          let versionA = "";
-          let versionB = "";
-          if (a.includes("@")) {
-            const afterAt = a.split("@")[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 afterAtB = b.split("@")[1] || "";
-            versionB = afterAtB.replace(new RegExp(`^${escapeRegExp(versionPrefix || "")}`), "");
-          } else {
-            versionB = b.replace(new RegExp(`^${escapeRegExp(packageName)}`), "").replace(new RegExp(`^${escapeRegExp(versionPrefix || "")}`), "");
-          }
-          const cleanVersionA = semver.clean(versionA) || "0.0.0";
-          const cleanVersionB = semver.clean(versionB) || "0.0.0";
-          return semver.rcompare(cleanVersionA, cleanVersionB);
-        });
-        log(`Found ${packageTags.length} package tags using configured pattern`, "debug");
-        log(`Using semantically latest tag: ${sortedPackageTags2[0]}`, "debug");
-        if (sortedPackageTags2[0] !== chronologicalFirst) {
-          log(
-            `Package tag ordering differs: chronological first is ${chronologicalFirst}, semantic latest is ${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 afterAt = a.split("@")[1] || "";
-            const versionA = afterAt.replace(new RegExp(`^${escapeRegExp(versionPrefix || "")}`), "");
-            const afterAtB = b.split("@")[1] || "";
-            const versionB = afterAtB.replace(new RegExp(`^${escapeRegExp(versionPrefix || "")}`), "");
-            const cleanVersionA = semver.clean(versionA) || "0.0.0";
-            const cleanVersionB = semver.clean(versionB) || "0.0.0";
-            return semver.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 versionA = semver.clean(a.split("@")[1] || "") || "0.0.0";
-            const versionB = semver.clean(b.split("@")[1] || "") || "0.0.0";
-            return semver.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 versionA = semver.clean(a.split("@")[1] || "") || "0.0.0";
-        const versionB = semver.clean(b.split("@")[1] || "") || "0.0.0";
-        return semver.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/utils/manifestHelpers.ts
-import fs2 from "fs";
-import path2 from "path";
-
-// src/cargo/cargoHandler.ts
-import fs from "fs";
-import path from "path";
-import { isCargoToml, parseCargoToml } from "@releasekit/config";
-import * as TOML from "smol-toml";
-function getCargoInfo(cargoPath) {
-  if (!fs.existsSync(cargoPath)) {
-    log(`Cargo.toml file not found at: ${cargoPath}`, "error");
-    throw new Error(`Cargo.toml file not found at: ${cargoPath}`);
-  }
-  try {
-    const cargo = 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: 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 updateCargoVersion(cargoPath, version) {
-  try {
-    const cargo = parseCargoToml(cargoPath);
-    const packageName = cargo.package?.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);
-    fs.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/utils/manifestHelpers.ts
-function getVersionFromManifests(packageDir) {
-  const packageJsonPath = path2.join(packageDir, "package.json");
-  const cargoTomlPath = path2.join(packageDir, "Cargo.toml");
-  if (fs2.existsSync(packageJsonPath)) {
-    try {
-      const packageJson = JSON.parse(fs2.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 (fs2.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
-import fs3 from "fs";
-import { parseCargoToml as parseCargoToml2 } from "@releasekit/config";
-import semver2 from "semver";
-
-// src/git/tagVerification.ts
-function verifyTag(tagName, cwd4) {
-  if (!tagName || tagName.trim() === "") {
-    return { exists: false, reachable: false, error: "Empty tag name" };
-  }
-  try {
-    execSync("git", ["rev-parse", "--verify", tagName], {
-      cwd: cwd4,
-      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) && !semver2.prerelease(currentVersion)) {
-    const preBumpType = `pre${bumpType}`;
-    log(`Creating prerelease version with identifier '${prereleaseIdentifier}' using ${preBumpType}`, "debug");
-    return semver2.inc(currentVersion, preBumpType, prereleaseIdentifier) || "";
-  }
-  if (semver2.prerelease(currentVersion) && STANDARD_BUMP_TYPES.includes(bumpType)) {
-    const parsed = semver2.parse(currentVersion);
-    if (!parsed) {
-      return semver2.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 semver2.inc(currentVersion, bumpType) || "";
-  }
-  if (prereleaseIdentifier) {
-    return semver2.inc(currentVersion, bumpType, prereleaseIdentifier) || "";
-  }
-  return semver2.inc(currentVersion, bumpType) || "";
-}
-function detectVersionMismatch(tagVersion, packageVersion) {
-  const tagIsPrerelease = semver2.prerelease(tagVersion) !== null;
-  const packageIsPrerelease = semver2.prerelease(packageVersion) !== null;
-  const tagParsed = semver2.parse(tagVersion);
-  const packageParsed = semver2.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 = semver2.gt(tagVersion, packageVersion);
-  if (tagHigher) {
-    const diff = semver2.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, cwd4, mismatchStrategy = "error") {
-  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, cwd4);
-  if (!verification.exists || !verification.reachable) {
-    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 (semver2.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 (semver2.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
-  } = 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 = semver3.clean(latestTag) || latestTag;
-        return semver3.clean(cleanedTag.replace(new RegExp(`^${escapedTagPattern}`), "")) || "0.0.0";
-      }
-      if (versionSource.source === "git") {
-        const cleanedTag = semver3.clean(versionSource.version) || versionSource.version;
-        return semver3.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 || cwd();
-      const manifestResult = getVersionFromManifests(packageDir);
-      const packageVersion = manifestResult.manifestFound && manifestResult.version ? manifestResult.version : void 0;
-      versionSource = await getBestVersionSource(latestTag, packageVersion, packageDir, mismatchStrategy);
-      log(`Using version source: ${versionSource.source} (${versionSource.reason})`, "info");
-    }
-    const specifiedType = type;
-    if (specifiedType) {
-      const currentVersion = getCurrentVersionFromSource2();
-      const isCurrentPrerelease = semver3.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 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 || 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/package/packageProcessor.ts
-import * as fs5 from "fs";
-import path4 from "path";
-import { exit } from "process";
-
-// src/changelog/commitParser.ts
-var CONVENTIONAL_COMMIT_REGEX = /^(\w+)(?:\(([^)]+)\))?(!)?: (.+)(?:\n\n([\s\S]*))?/;
-var BREAKING_CHANGE_REGEX = /BREAKING CHANGE: ([\s\S]+?)(?:\n\n|$)/;
-function extractChangelogEntriesFromCommits(projectDir, revisionRange) {
-  try {
-    const output = execSync("git", ["log", revisionRange, "--pretty=format:%B---COMMIT_DELIMITER---", "--no-merges"], {
-      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/git/commands.ts
-import { cwd as cwd2 } from "process";
-
-// src/errors/gitError.ts
-var GitError = class extends BaseVersionError {
-};
-function createGitError(code, details) {
-  const messages = {
-    ["NOT_GIT_REPO" /* NOT_GIT_REPO */]: "Not a git repository",
-    ["GIT_PROCESS_ERROR" /* GIT_PROCESS_ERROR */]: "Failed to create new version",
-    ["NO_FILES" /* NO_FILES */]: "No files specified for commit",
-    ["NO_COMMIT_MESSAGE" /* NO_COMMIT_MESSAGE */]: "Commit message is required",
-    ["GIT_ERROR" /* GIT_ERROR */]: "Git operation failed",
-    ["TAG_ALREADY_EXISTS" /* TAG_ALREADY_EXISTS */]: "Git tag already exists"
-  };
-  const suggestions = {
-    ["NOT_GIT_REPO" /* NOT_GIT_REPO */]: [
-      "Initialize git repository with: git init",
-      "Ensure you are in the correct directory"
-    ],
-    ["TAG_ALREADY_EXISTS" /* TAG_ALREADY_EXISTS */]: [
-      "Delete the existing tag: git tag -d <tag-name>",
-      "Use a different version by incrementing manually",
-      "Check if this version was already released"
-    ],
-    ["GIT_PROCESS_ERROR" /* GIT_PROCESS_ERROR */]: void 0,
-    ["NO_FILES" /* NO_FILES */]: void 0,
-    ["NO_COMMIT_MESSAGE" /* NO_COMMIT_MESSAGE */]: void 0,
-    ["GIT_ERROR" /* GIT_ERROR */]: void 0
-  };
-  const baseMessage = messages[code];
-  const fullMessage = details ? `${baseMessage}: ${details}` : baseMessage;
-  return new GitError(fullMessage, code, suggestions[code]);
-}
-
-// src/git/commands.ts
-async function gitAdd(files) {
-  return execAsync("git", ["add", ...files]);
-}
-async function gitCommit(options) {
-  const args = ["commit"];
-  if (options.amend) {
-    args.push("--amend");
-  }
-  if (options.author) {
-    args.push("--author", options.author);
-  }
-  if (options.date) {
-    args.push("--date", options.date);
-  }
-  if (options.skipHooks) {
-    args.push("--no-verify");
-  }
-  args.push("-m", options.message);
-  return execAsync("git", args);
-}
-async function createGitTag(options) {
-  const { tag, message = "" } = options;
-  const args = ["tag", "-a", "-m", message, tag];
-  try {
-    return await execAsync("git", args);
-  } catch (error) {
-    const errorMessage = error instanceof Error ? error.message : String(error);
-    if (errorMessage.includes("already exists")) {
-      throw createGitError(
-        "TAG_ALREADY_EXISTS" /* TAG_ALREADY_EXISTS */,
-        `Tag '${tag}' already exists in the repository. Please use a different version or delete the existing tag first.`
-      );
-    }
-    throw createGitError("GIT_ERROR" /* GIT_ERROR */, errorMessage);
-  }
-}
-async function gitProcess(options) {
-  const { files, nextTag, commitMessage, skipHooks, dryRun } = options;
-  if (!isGitRepository(cwd2())) {
-    throw createGitError("NOT_GIT_REPO" /* NOT_GIT_REPO */);
-  }
-  try {
-    if (!dryRun) {
-      await gitAdd(files);
-      await gitCommit({
-        message: commitMessage,
-        skipHooks
-      });
-      if (nextTag) {
-        const tagMessage = `New Version ${nextTag} generated at ${(/* @__PURE__ */ new Date()).toISOString()}`;
-        await createGitTag({
-          tag: nextTag,
-          message: tagMessage
-        });
-      }
-    } else {
-      log("[DRY RUN] Would add files:", "info");
-      for (const file of files) {
-        log(`  - ${file}`, "info");
-      }
-      log(`[DRY RUN] Would commit with message: "${commitMessage}"`, "info");
-      if (nextTag) {
-        log(`[DRY RUN] Would create tag: ${nextTag}`, "info");
-      }
-    }
-  } catch (err) {
-    const errorMessage = err instanceof Error ? err.message : String(err);
-    if (errorMessage.includes("already exists") && nextTag) {
-      log(`Tag '${nextTag}' already exists in the repository.`, "error");
-      throw createGitError(
-        "TAG_ALREADY_EXISTS" /* TAG_ALREADY_EXISTS */,
-        `Tag '${nextTag}' already exists in the repository. Please use a different version or delete the existing tag first.`
-      );
-    }
-    log(`Git process error: ${errorMessage}`, "error");
-    if (err instanceof Error && err.stack) {
-      console.error("Git process stack trace:");
-      console.error(err.stack);
-    }
-    throw createGitError("GIT_PROCESS_ERROR" /* GIT_PROCESS_ERROR */, errorMessage);
-  }
-}
-async function createGitCommitAndTag(files, nextTag, commitMessage, skipHooks, dryRun) {
-  try {
-    if (!files || files.length === 0) {
-      throw createGitError("NO_FILES" /* NO_FILES */);
-    }
-    if (!commitMessage) {
-      throw createGitError("NO_COMMIT_MESSAGE" /* NO_COMMIT_MESSAGE */);
-    }
-    setCommitMessage(commitMessage);
-    if (nextTag) {
-      addTag(nextTag);
-    }
-    await gitProcess({
-      files,
-      nextTag,
-      commitMessage,
-      skipHooks,
-      dryRun
-    });
-    if (!dryRun) {
-      log(`Created tag: ${nextTag}`, "success");
-    }
-  } catch (error) {
-    if (error instanceof GitError) {
-      throw error;
-    }
-    const errorMessage = error instanceof Error ? error.message : String(error);
-    log(`Failed to create git commit and tag: ${errorMessage}`, "error");
-    if (error instanceof Error) {
-      console.error("Git operation error details:");
-      console.error(error.stack || error.message);
-      if (errorMessage.includes("Command failed:")) {
-        const cmdOutput = errorMessage.split("Command failed:")[1];
-        if (cmdOutput) {
-          console.error("Git command output:", cmdOutput.trim());
-        }
-      }
-    } else {
-      console.error("Unknown git error:", error);
-    }
-    throw new GitError(`Git operation failed: ${errorMessage}`, "GIT_ERROR" /* GIT_ERROR */);
-  }
-}
-
-// src/utils/packageMatching.ts
-import micromatch from "micromatch";
-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 micromatch.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/packageManagement.ts
-import fs4 from "fs";
-import path3 from "path";
-function updatePackageVersion(packagePath, version) {
-  if (isCargoToml(packagePath)) {
-    updateCargoVersion(packagePath, version);
-    return;
-  }
-  try {
-    const packageContent = fs4.readFileSync(packagePath, "utf8");
-    const packageJson = JSON.parse(packageContent);
-    const packageName = packageJson.name;
-    packageJson.version = version;
-    fs4.writeFileSync(packagePath, `${JSON.stringify(packageJson, null, 2)}
-`);
-    addPackageUpdate(packageName, version, packagePath);
-    log(`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 PackageProcessor = class {
-  skip;
-  versionPrefix;
-  tagTemplate;
-  commitMessageTemplate;
-  dryRun;
-  skipHooks;
-  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.skipHooks = options.skipHooks || 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 {
-            log(`Tag ${latestTag} is unreachable (${verification.error}), 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 = path4.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 = path4.join(pkgPath, "package.json");
-      if (fs5.existsSync(packageJsonPath)) {
-        updatePackageVersion(packageJsonPath, nextVersion);
-      }
-      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 = path4.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);
-            } else {
-              log(`Cargo.toml not found at ${resolvedCargoPath}`, "debug");
-            }
-          }
-        } else {
-          const cargoTomlPath = path4.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);
-          } 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
-      );
-      const tagMessage = `chore(release): ${name} ${nextVersion}`;
-      addTag(packageTag);
-      tags.push(packageTag);
-      if (!this.dryRun) {
-        try {
-          await createGitTag({ tag: packageTag, message: tagMessage });
-          log(`Created tag: ${packageTag}`, "success");
-        } catch (tagError) {
-          log(`Failed to create tag ${packageTag} for ${name}: ${tagError.message}`, "error");
-          log(tagError.stack || "No stack trace available", "error");
-        }
-      } else {
-        log(`[DRY RUN] Would create tag: ${packageTag}`, "info");
-      }
-      updatedPackagesInfo.push({ name, version: nextVersion, path: pkgPath });
-    }
-    if (updatedPackagesInfo.length === 0) {
-      log("No packages required a version update.", "info");
-      return { updatedPackages: [], tags };
-    }
-    const filesToCommit = [];
-    for (const info of updatedPackagesInfo) {
-      const packageJsonPath = path4.join(info.path, "package.json");
-      if (fs5.existsSync(packageJsonPath)) {
-        filesToCommit.push(packageJsonPath);
-      }
-      const cargoEnabled = this.fullConfig.cargo?.enabled !== false;
-      if (cargoEnabled) {
-        const cargoPaths = this.fullConfig.cargo?.paths;
-        if (cargoPaths && cargoPaths.length > 0) {
-          for (const cargoPath of cargoPaths) {
-            const resolvedCargoPath = path4.resolve(info.path, cargoPath, "Cargo.toml");
-            if (fs5.existsSync(resolvedCargoPath)) {
-              filesToCommit.push(resolvedCargoPath);
-            }
-          }
-        } else {
-          const cargoTomlPath = path4.join(info.path, "Cargo.toml");
-          if (fs5.existsSync(cargoTomlPath)) {
-            filesToCommit.push(cargoTomlPath);
-          }
-        }
-      }
-    }
-    const packageNames = updatedPackagesInfo.map((p) => p.name).join(", ");
-    const representativeVersion = updatedPackagesInfo[0]?.version || "multiple";
-    let commitMessage = this.commitMessageTemplate || "chore(release): publish packages";
-    const placeholderRegex = /\$\{[^}]+\}/;
-    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) {
-      try {
-        await gitAdd(filesToCommit);
-        await gitCommit({ message: commitMessage, skipHooks: this.skipHooks });
-        log(`Created commit for targeted release: ${packageNames}`, "success");
-      } catch (commitError) {
-        log("Failed to create commit for targeted release.", "error");
-        console.error(commitError);
-        exit(1);
-      }
-    } else {
-      log("[DRY RUN] Would add files:", "info");
-      for (const file of filesToCommit) {
-        log(`  - ${file}`, "info");
-      }
-      log(`[DRY RUN] Would commit with message: "${commitMessage}"`, "info");
-    }
-    return {
-      updatedPackages: updatedPackagesInfo,
-      commitMessage,
-      tags
-    };
-  }
-};
-
-// src/core/versionStrategies.ts
-import fs6 from "fs";
-import * as path5 from "path";
-function shouldProcessPackage2(pkg, config) {
-  const pkgName = pkg.packageJson.name;
-  return shouldProcessPackage(pkgName, config.skip);
-}
-function updateCargoFiles(packageDir, version, cargoConfig) {
-  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 = path5.resolve(packageDir, cargoPath, "Cargo.toml");
-      if (fs6.existsSync(resolvedCargoPath)) {
-        updatePackageVersion(resolvedCargoPath, version);
-        updatedFiles.push(resolvedCargoPath);
-      }
-    }
-  } else {
-    const cargoTomlPath = path5.join(packageDir, "Cargo.toml");
-    if (fs6.existsSync(cargoTomlPath)) {
-      updatePackageVersion(cargoTomlPath, version);
-      updatedFiles.push(cargoTomlPath);
-    }
-  }
-  return updatedFiles;
-}
-function createSyncStrategy(config) {
-  return async (packages) => {
-    try {
-      const {
-        versionPrefix,
-        tagTemplate,
-        baseBranch,
-        branchPattern,
-        commitMessage = `chore(release): v\${version}`,
-        prereleaseIdentifier,
-        dryRun,
-        skipHooks,
-        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 = path5.join(packages.root, "package.json");
-          if (fs6.existsSync(rootPkgPath)) {
-            updatePackageVersion(rootPkgPath, nextVersion);
-            files.push(rootPkgPath);
-            updatedPackages.push("root");
-            processedPaths.add(rootPkgPath);
-            const rootCargoFiles = updateCargoFiles(packages.root, nextVersion, config.cargo);
-            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 = path5.join(pkg.dir, "package.json");
-        if (processedPaths.has(packageJsonPath)) {
-          continue;
-        }
-        updatePackageVersion(packageJsonPath, nextVersion);
-        files.push(packageJsonPath);
-        updatedPackages.push(pkg.packageJson.name);
-        processedPaths.add(packageJsonPath);
-        const pkgCargoFiles = updateCargoFiles(pkg.dir, nextVersion, config.cargo);
-        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 {
-            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);
-      await createGitCommitAndTag(files, nextTag, formattedCommitMessage, skipHooks, dryRun);
-    } 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,
-        skipHooks
-      } = 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 {
-            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 = path5.join(pkgPath, "package.json");
-        if (fs6.existsSync(packageJsonPath2)) {
-          const packageJson = JSON.parse(fs6.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 = path5.join(pkgPath, "package.json");
-      updatePackageVersion(packageJsonPath, nextVersion);
-      const filesToCommit = [packageJsonPath];
-      const cargoFiles = updateCargoFiles(pkgPath, nextVersion, config.cargo);
-      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);
-      if (!dryRun) {
-        await createGitCommitAndTag(filesToCommit, tagName, commitMsg, skipHooks, dryRun);
-        log(`Created 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,
-    skipHooks: config.skipHooks || 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
-import { cwd as cwd3 } from "process";
-import { getPackagesSync } from "@manypkg/get-packages";
-
-// src/utils/packageFiltering.ts
-import path6 from "path";
-import micromatch2 from "micromatch";
-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 = path6.relative(workspaceRoot, pkg.dir);
-    const normalizedRelativePath = relativePath.replace(/\\/g, "/");
-    if (normalizedPattern === normalizedRelativePath) {
-      return true;
-    }
-    try {
-      return micromatch2.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 micromatch2.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/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 = getPackagesSync(cwd3());
-      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 = cwd3();
-      }
-      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];
-  }
-};
-
-export {
-  loadConfig,
-  VersionErrorCode,
-  createVersionError,
-  enableJsonOutput,
-  getJsonData,
-  printJsonOutput,
-  log,
-  calculateVersion,
-  PackageProcessor,
-  createSyncStrategy,
-  createSingleStrategy,
-  createAsyncStrategy,
-  VersionEngine
-};