@releasekit/version 0.3.0 → 0.4.0

package/dist/chunk-ZTFI7TXV.js

@@ -0,0 +1,2442 @@
+import {
+  BaseVersionError,
+  ReleaseKitError
+} from "./chunk-2MN2VLZF.js";
+import {
+  execAsync,
+  execSync
+} from "./chunk-LMPZV35Z.js";
+
+// ../config/dist/index.js
+import * as fs from "fs";
+import * as path from "path";
+import * as TOML from "smol-toml";
+import * as fs3 from "fs";
+import * as path3 from "path";
+import { z as z2 } from "zod";
+import { z } from "zod";
+import * as fs2 from "fs";
+import * as os from "os";
+import * as path2 from "path";
+function parseCargoToml(cargoPath) {
+  const content = fs.readFileSync(cargoPath, "utf-8");
+  return TOML.parse(content);
+}
+function isCargoToml(filePath) {
+  return path.basename(filePath) === "Cargo.toml";
+}
+var ConfigError = class extends ReleaseKitError {
+  code = "CONFIG_ERROR";
+  suggestions;
+  constructor(message, suggestions) {
+    super(message);
+    this.suggestions = suggestions ?? [
+      "Check that releasekit.config.json exists and is valid JSON",
+      "Run with --verbose for more details"
+    ];
+  }
+};
+var MAX_JSONC_LENGTH = 1e5;
+function parseJsonc(content) {
+  if (content.length > MAX_JSONC_LENGTH) {
+    throw new Error(`JSONC content too long: ${content.length} characters (max ${MAX_JSONC_LENGTH})`);
+  }
+  try {
+    return JSON.parse(content);
+  } catch {
+    const cleaned = content.replace(/\/\/[^\r\n]{0,10000}$/gm, "").replace(/\/\*[\s\S]{0,50000}?\*\//g, "").trim();
+    return JSON.parse(cleaned);
+  }
+}
+var GitConfigSchema = z.object({
+  remote: z.string().default("origin"),
+  branch: z.string().default("main"),
+  pushMethod: z.enum(["auto", "ssh", "https"]).default("auto"),
+  /**
+   * Optional env var name containing a GitHub token for HTTPS pushes.
+   * When set, publish steps can use this token without mutating git remotes.
+   */
+  httpsTokenEnv: z.string().optional(),
+  push: z.boolean().optional(),
+  skipHooks: z.boolean().optional()
+});
+var MonorepoConfigSchema = z.object({
+  mode: z.enum(["root", "packages", "both"]).optional(),
+  rootPath: z.string().optional(),
+  packagesPath: z.string().optional(),
+  mainPackage: z.string().optional()
+});
+var BranchPatternSchema = z.object({
+  pattern: z.string(),
+  releaseType: z.enum(["major", "minor", "patch", "prerelease"])
+});
+var VersionCargoConfigSchema = z.object({
+  enabled: z.boolean().default(true),
+  paths: z.array(z.string()).optional()
+});
+var VersionConfigSchema = z.object({
+  tagTemplate: z.string().default("v{version}"),
+  packageSpecificTags: z.boolean().default(false),
+  preset: z.string().default("conventional"),
+  sync: z.boolean().default(true),
+  packages: z.array(z.string()).default([]),
+  mainPackage: z.string().optional(),
+  updateInternalDependencies: z.enum(["major", "minor", "patch", "no-internal-update"]).default("minor"),
+  skip: z.array(z.string()).optional(),
+  commitMessage: z.string().optional(),
+  versionStrategy: z.enum(["branchPattern", "commitMessage"]).default("commitMessage"),
+  branchPatterns: z.array(BranchPatternSchema).optional(),
+  defaultReleaseType: z.enum(["major", "minor", "patch", "prerelease"]).optional(),
+  mismatchStrategy: z.enum(["error", "warn", "ignore", "prefer-package", "prefer-git"]).default("warn"),
+  versionPrefix: z.string().default(""),
+  prereleaseIdentifier: z.string().optional(),
+  strictReachable: z.boolean().default(false),
+  cargo: VersionCargoConfigSchema.optional()
+});
+var NpmConfigSchema = z.object({
+  enabled: z.boolean().default(true),
+  auth: z.enum(["auto", "oidc", "token"]).default("auto"),
+  provenance: z.boolean().default(true),
+  access: z.enum(["public", "restricted"]).default("public"),
+  registry: z.string().default("https://registry.npmjs.org"),
+  copyFiles: z.array(z.string()).default(["LICENSE"]),
+  tag: z.string().default("latest")
+});
+var CargoPublishConfigSchema = z.object({
+  enabled: z.boolean().default(false),
+  noVerify: z.boolean().default(false),
+  publishOrder: z.array(z.string()).default([]),
+  clean: z.boolean().default(false)
+});
+var PublishGitConfigSchema = z.object({
+  push: z.boolean().default(true),
+  pushMethod: z.enum(["auto", "ssh", "https"]).optional(),
+  remote: z.string().optional(),
+  branch: z.string().optional(),
+  httpsTokenEnv: z.string().optional(),
+  skipHooks: z.boolean().optional()
+});
+var GitHubReleaseConfigSchema = z.object({
+  enabled: z.boolean().default(true),
+  draft: z.boolean().default(true),
+  perPackage: z.boolean().default(true),
+  prerelease: z.union([z.literal("auto"), z.boolean()]).default("auto"),
+  /**
+   * Controls the source for the GitHub release body.
+   * - 'auto': Use release notes if enabled, else changelog, else GitHub auto-generated.
+   * - 'releaseNotes': Use LLM-generated release notes (requires notes.releaseNotes.enabled: true).
+   * - 'changelog': Use formatted changelog entries.
+   * - 'generated': Use GitHub's auto-generated notes.
+   * - 'none': No body.
+   */
+  body: z.enum(["auto", "releaseNotes", "changelog", "generated", "none"]).default("auto")
+});
+var VerifyRegistryConfigSchema = z.object({
+  enabled: z.boolean().default(true),
+  maxAttempts: z.number().int().positive().default(5),
+  initialDelay: z.number().int().positive().default(15e3),
+  backoffMultiplier: z.number().positive().default(2)
+});
+var VerifyConfigSchema = z.object({
+  npm: VerifyRegistryConfigSchema.default({
+    enabled: true,
+    maxAttempts: 5,
+    initialDelay: 15e3,
+    backoffMultiplier: 2
+  }),
+  cargo: VerifyRegistryConfigSchema.default({
+    enabled: true,
+    maxAttempts: 10,
+    initialDelay: 3e4,
+    backoffMultiplier: 2
+  })
+});
+var PublishConfigSchema = z.object({
+  git: PublishGitConfigSchema.optional(),
+  npm: NpmConfigSchema.default({
+    enabled: true,
+    auth: "auto",
+    provenance: true,
+    access: "public",
+    registry: "https://registry.npmjs.org",
+    copyFiles: ["LICENSE"],
+    tag: "latest"
+  }),
+  cargo: CargoPublishConfigSchema.default({
+    enabled: false,
+    noVerify: false,
+    publishOrder: [],
+    clean: false
+  }),
+  githubRelease: GitHubReleaseConfigSchema.default({
+    enabled: true,
+    draft: true,
+    perPackage: true,
+    prerelease: "auto",
+    body: "auto"
+  }),
+  verify: VerifyConfigSchema.default({
+    npm: {
+      enabled: true,
+      maxAttempts: 5,
+      initialDelay: 15e3,
+      backoffMultiplier: 2
+    },
+    cargo: {
+      enabled: true,
+      maxAttempts: 10,
+      initialDelay: 3e4,
+      backoffMultiplier: 2
+    }
+  })
+});
+var TemplateConfigSchema = z.object({
+  path: z.string().optional(),
+  engine: z.enum(["handlebars", "liquid", "ejs"]).optional()
+});
+var LocationModeSchema = z.enum(["root", "packages", "both"]);
+var ChangelogConfigSchema = z.object({
+  mode: LocationModeSchema.optional(),
+  file: z.string().optional(),
+  templates: TemplateConfigSchema.optional()
+});
+var LLMOptionsSchema = z.object({
+  timeout: z.number().optional(),
+  maxTokens: z.number().optional(),
+  temperature: z.number().optional()
+});
+var LLMRetryConfigSchema = z.object({
+  maxAttempts: z.number().int().positive().optional(),
+  initialDelay: z.number().nonnegative().optional(),
+  maxDelay: z.number().positive().optional(),
+  backoffFactor: z.number().positive().optional()
+});
+var LLMTasksConfigSchema = z.object({
+  summarize: z.boolean().optional(),
+  enhance: z.boolean().optional(),
+  categorize: z.boolean().optional(),
+  releaseNotes: z.boolean().optional()
+});
+var LLMCategorySchema = z.object({
+  name: z.string(),
+  description: z.string(),
+  scopes: z.array(z.string()).optional()
+});
+var ScopeRulesSchema = z.object({
+  allowed: z.array(z.string()).optional(),
+  caseSensitive: z.boolean().default(false),
+  invalidScopeAction: z.enum(["remove", "keep", "fallback"]).default("remove"),
+  fallbackScope: z.string().optional()
+});
+var ScopeConfigSchema = z.object({
+  mode: z.enum(["restricted", "packages", "none", "unrestricted"]).default("unrestricted"),
+  rules: ScopeRulesSchema.optional()
+});
+var LLMPromptOverridesSchema = z.object({
+  enhance: z.string().optional(),
+  categorize: z.string().optional(),
+  enhanceAndCategorize: z.string().optional(),
+  summarize: z.string().optional(),
+  releaseNotes: z.string().optional()
+});
+var LLMPromptsConfigSchema = z.object({
+  instructions: LLMPromptOverridesSchema.optional(),
+  templates: LLMPromptOverridesSchema.optional()
+});
+var LLMConfigSchema = z.object({
+  provider: z.string(),
+  model: z.string(),
+  baseURL: z.string().optional(),
+  apiKey: z.string().optional(),
+  options: LLMOptionsSchema.optional(),
+  concurrency: z.number().int().positive().optional(),
+  retry: LLMRetryConfigSchema.optional(),
+  tasks: LLMTasksConfigSchema.optional(),
+  categories: z.array(LLMCategorySchema).optional(),
+  style: z.string().optional(),
+  scopes: ScopeConfigSchema.optional(),
+  prompts: LLMPromptsConfigSchema.optional()
+});
+var ReleaseNotesConfigSchema = z.object({
+  mode: LocationModeSchema.optional(),
+  file: z.string().optional(),
+  templates: TemplateConfigSchema.optional(),
+  llm: LLMConfigSchema.optional()
+});
+var NotesInputConfigSchema = z.object({
+  source: z.string().optional(),
+  file: z.string().optional()
+});
+var NotesConfigSchema = z.object({
+  changelog: z.union([z.literal(false), ChangelogConfigSchema]).optional(),
+  releaseNotes: z.union([z.literal(false), ReleaseNotesConfigSchema]).optional(),
+  updateStrategy: z.enum(["prepend", "regenerate"]).optional()
+});
+var CILabelsConfigSchema = z.object({
+  stable: z.string().default("release:stable"),
+  prerelease: z.string().default("release:prerelease"),
+  skip: z.string().default("release:skip"),
+  major: z.string().default("release:major"),
+  minor: z.string().default("release:minor"),
+  patch: z.string().default("release:patch")
+});
+var CIConfigSchema = z.object({
+  releaseStrategy: z.enum(["manual", "direct", "standing-pr", "scheduled"]).default("direct"),
+  releaseTrigger: z.enum(["commit", "label"]).default("label"),
+  prPreview: z.boolean().default(true),
+  autoRelease: z.boolean().default(false),
+  /**
+   * Commit message prefixes that should not trigger a release.
+   * Defaults to `['chore: release ']` to match the release commit template
+   * (`chore: release ${packageName} v${version}`) and provide a
+   * secondary loop-prevention guard alongside `[skip ci]`.
+   */
+  skipPatterns: z.array(z.string()).default(["chore: release "]),
+  minChanges: z.number().int().positive().default(1),
+  labels: CILabelsConfigSchema.default({
+    stable: "release:stable",
+    prerelease: "release:prerelease",
+    skip: "release:skip",
+    major: "release:major",
+    minor: "release:minor",
+    patch: "release:patch"
+  })
+});
+var ReleaseCIConfigSchema = z.object({
+  skipPatterns: z.array(z.string().min(1)).optional(),
+  minChanges: z.number().int().positive().optional(),
+  /** Set to `false` to disable GitHub release creation in CI. */
+  githubRelease: z.literal(false).optional(),
+  /** Set to `false` to disable changelog generation in CI. */
+  notes: z.literal(false).optional()
+});
+var ReleaseConfigSchema = z.object({
+  /**
+   * Optional steps to enable. The version step always runs; only 'notes' and
+   * 'publish' can be opted out. Omitting a step is equivalent to --skip-<step>.
+   */
+  steps: z.array(z.enum(["notes", "publish"])).min(1).optional(),
+  ci: ReleaseCIConfigSchema.optional()
+});
+var ReleaseKitConfigSchema = z.object({
+  git: GitConfigSchema.optional(),
+  monorepo: MonorepoConfigSchema.optional(),
+  version: VersionConfigSchema.optional(),
+  publish: PublishConfigSchema.optional(),
+  notes: NotesConfigSchema.optional(),
+  ci: CIConfigSchema.optional(),
+  release: ReleaseConfigSchema.optional()
+});
+var MAX_INPUT_LENGTH = 1e4;
+function substituteVariables(value) {
+  if (value.length > MAX_INPUT_LENGTH) {
+    throw new Error(`Input too long: ${value.length} characters (max ${MAX_INPUT_LENGTH})`);
+  }
+  const envPattern = /\{env:([^}]{1,1000})\}/g;
+  const filePattern = /\{file:([^}]{1,1000})\}/g;
+  let result = value;
+  result = result.replace(envPattern, (_, varName) => {
+    return process.env[varName] ?? "";
+  });
+  result = result.replace(filePattern, (_, filePath) => {
+    const expandedPath = filePath.startsWith("~") ? path2.join(os.homedir(), filePath.slice(1)) : filePath;
+    try {
+      return fs2.readFileSync(expandedPath, "utf-8").trim();
+    } catch {
+      return "";
+    }
+  });
+  return result;
+}
+var SOLE_REFERENCE_PATTERN = /^\{(?:env|file):[^}]+\}$/;
+function substituteInObject(obj) {
+  if (typeof obj === "string") {
+    const result = substituteVariables(obj);
+    if (result === "" && SOLE_REFERENCE_PATTERN.test(obj)) {
+      return void 0;
+    }
+    return result;
+  }
+  if (Array.isArray(obj)) {
+    return obj.map((item) => substituteInObject(item));
+  }
+  if (obj && typeof obj === "object") {
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+      result[key] = substituteInObject(value);
+    }
+    return result;
+  }
+  return obj;
+}
+var AUTH_DIR = path2.join(os.homedir(), ".config", "releasekit");
+var AUTH_FILE = path2.join(AUTH_DIR, "auth.json");
+var CONFIG_FILE = "releasekit.config.json";
+function loadConfigFile(configPath) {
+  if (!fs3.existsSync(configPath)) {
+    return {};
+  }
+  try {
+    const content = fs3.readFileSync(configPath, "utf-8");
+    const parsed = parseJsonc(content);
+    const substituted = substituteInObject(parsed);
+    return ReleaseKitConfigSchema.parse(substituted);
+  } catch (error) {
+    if (error instanceof z2.ZodError) {
+      const issues = error.issues.map((i) => `  ${i.path.join(".")}: ${i.message}`).join("\n");
+      throw new ConfigError(`Config validation errors:
+${issues}`);
+    }
+    if (error instanceof SyntaxError) {
+      throw new ConfigError(`Invalid JSON in config file: ${error.message}`);
+    }
+    throw error;
+  }
+}
+function loadConfig(options) {
+  const cwd3 = options?.cwd ?? process.cwd();
+  const configPath = options?.configPath ?? path3.join(cwd3, CONFIG_FILE);
+  return loadConfigFile(configPath);
+}
+
+// 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 loadConfig2(options) {
+  const fullConfig = loadConfig(options);
+  return toVersionConfig(fullConfig.version, fullConfig.git);
+}
+
+// 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
+import fs4 from "fs";
+var _jsonOutputMode = false;
+var _pendingWrites = [];
+var _jsonData = {
+  dryRun: false,
+  updates: [],
+  changelogs: [],
+  sharedEntries: void 0,
+  tags: []
+};
+function enableJsonOutput(dryRun = false) {
+  _jsonOutputMode = true;
+  _jsonData.dryRun = dryRun;
+  _jsonData.updates = [];
+  _jsonData.changelogs = [];
+  _jsonData.sharedEntries = void 0;
+  _jsonData.tags = [];
+  _jsonData.commitMessage = void 0;
+  _pendingWrites.length = 0;
+}
+function recordPendingWrite(path10, content) {
+  if (!_jsonOutputMode) return;
+  _pendingWrites.push({ path: path10, content });
+}
+function flushPendingWrites() {
+  try {
+    for (const { path: path10, content } of _pendingWrites) {
+      fs4.writeFileSync(path10, content);
+    }
+  } finally {
+    _pendingWrites.length = 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 setSharedEntries(entries) {
+  if (!_jsonOutputMode) return;
+  _jsonData.sharedEntries = entries.length > 0 ? entries : void 0;
+}
+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;
+  }
+  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/core/versionCalculator.ts
+import { cwd } from "process";
+import { Bumper } from "conventional-recommended-bump";
+import semver3 from "semver";
+
+// src/git/repository.ts
+import { existsSync as existsSync3, statSync } from "fs";
+import { join as join3 } from "path";
+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) {
+  const sanitizedPackageName = packageName?.startsWith("@") ? packageName.slice(1).replace(/\//g, "-") : packageName;
+  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, sanitizedPackageName || "");
+  }
+  if (packageSpecificTags && sanitizedPackageName) {
+    return `${sanitizedPackageName}@${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
+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 packageSpecificTags = options?.packageSpecificTags ?? false;
+    const tagTemplate = options?.tagTemplate || (packageSpecificTags ? `\${packageName}@\${prefix}\${version}` : `\${prefix}\${version}`);
+    const sanitizedPackageName = packageName.startsWith("@") ? packageName.slice(1).replace(/\//g, "-") : packageName;
+    const escapedPackageName = escapeRegExp(sanitizedPackageName);
+    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 import("./commandExecutor-E44ID5U4.js");
+      const tagsOutput = execSync2("git", ["tag", "--sort=-creatordate"], { 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}$`);
+      const packageTags = allTags.filter((tag) => packageTagRegex.test(tag));
+      log(`Found ${packageTags.length} matching tags for ${packageName}`, "debug");
+      if (packageTags.length > 0) {
+        log(`Found ${packageTags.length} package tags using configured pattern`, "debug");
+        log(`Using most recently created tag: ${packageTags[0]}`, "debug");
+        return packageTags[0];
+      }
+      log("No matching tags found for configured tag pattern", "debug");
+      if (allTags.length > 0) {
+        log(`Available tags: ${allTags.join(", ")}`, "debug");
+      } else {
+        log("No tags available in the repository", "debug");
+      }
+      return "";
+    }
+    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 fs6 from "fs";
+import path5 from "path";
+
+// src/cargo/cargoHandler.ts
+import fs5 from "fs";
+import path4 from "path";
+import * as TOML2 from "smol-toml";
+function getCargoInfo(cargoPath) {
+  if (!fs5.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: path4.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 = 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 = TOML2.stringify(cargo);
+    if (dryRun) {
+      recordPendingWrite(cargoPath, updatedContent);
+    } else {
+      fs5.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/utils/manifestHelpers.ts
+function getVersionFromManifests(packageDir) {
+  const packageJsonPath = path5.join(packageDir, "package.json");
+  const cargoTomlPath = path5.join(packageDir, "Cargo.toml");
+  if (fs6.existsSync(packageJsonPath)) {
+    try {
+      const packageJson = JSON.parse(fs6.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 (fs6.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 fs7 from "fs";
+import semver2 from "semver";
+
+// src/git/tagVerification.ts
+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) && !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, 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 (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,
+    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 = 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,
+        strictReachable
+      );
+      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 fs9 from "fs";
+import path7 from "path";
+
+// src/changelog/commitParser.ts
+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/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 fs8 from "fs";
+import path6 from "path";
+function updatePackageVersion(packagePath, version, dryRun = false) {
+  if (isCargoToml(packagePath)) {
+    updateCargoVersion(packagePath, version, dryRun);
+    return;
+  }
+  try {
+    const packageContent = fs8.readFileSync(packagePath, "utf8");
+    const packageJson = JSON.parse(packageContent);
+    const packageName = packageJson.name;
+    const updatedContent = `${JSON.stringify({ ...packageJson, version }, null, 2)}
+`;
+    if (dryRun) {
+      recordPendingWrite(packagePath, updatedContent);
+    } else {
+      fs8.writeFileSync(packagePath, updatedContent);
+    }
+    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 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: [] };
+    }
+    const sharedEntriesMap = /* @__PURE__ */ new Map();
+    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(`Found ${repoLevelEntries.length} repo-level commit(s) for ${name}`, "debug");
+          for (const entry of repoLevelEntries) {
+            sharedEntriesMap.set(`${entry.type}:${entry.description}`, entry);
+          }
+        }
+        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 = path7.join(pkgPath, "package.json");
+        if (fs9.existsSync(packageJsonPath2)) {
+          const packageJson = JSON.parse(fs9.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 = path7.join(pkgPath, "package.json");
+      if (fs9.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 = path7.resolve(pkgPath, cargoPath, "Cargo.toml");
+            log(`Checking cargo path for ${name}: ${resolvedCargoPath}`, "debug");
+            if (fs9.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 = path7.join(pkgPath, "Cargo.toml");
+          log(`Checking default cargo path for ${name}: ${cargoTomlPath}`, "debug");
+          if (fs9.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 });
+    }
+    setSharedEntries([...sharedEntriesMap.values()]);
+    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";
+    const versionsMatch = updatedPackagesInfo.length <= 1 || updatedPackagesInfo.every((p) => p.version === representativeVersion);
+    let commitMessage = this.commitMessageTemplate || "chore: release";
+    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 (placeholderRegex.test(commitMessage)) {
+      const packageName = updatedPackagesInfo.length === 1 ? updatedPackagesInfo[0].name : packageNames;
+      commitMessage = formatCommitMessage(commitMessage, representativeVersion, packageName);
+    } else {
+      if (versionsMatch) {
+        const formattedVersion = `${formatVersionPrefix(this.versionPrefix)}${representativeVersion}`;
+        commitMessage = `${commitMessage} ${packageNames} ${formattedVersion}`;
+      } else {
+        const packageVersionList = updatedPackagesInfo.map((p) => `${p.name}@${p.version}`).join(", ");
+        commitMessage = `${commitMessage} ${packageVersionList}`;
+      }
+    }
+    setCommitMessage(commitMessage);
+    if (this.dryRun) {
+      log(`[DRY RUN] Would commit with message: "${commitMessage}"`, "info");
+    }
+    return {
+      updatedPackages: updatedPackagesInfo,
+      commitMessage,
+      tags
+    };
+  }
+};
+
+// src/core/versionStrategies.ts
+import fs10 from "fs";
+import * as path8 from "path";
+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 = path8.resolve(packageDir, cargoPath, "Cargo.toml");
+      if (fs10.existsSync(resolvedCargoPath)) {
+        updatePackageVersion(resolvedCargoPath, version, dryRun);
+        updatedFiles.push(resolvedCargoPath);
+      }
+    }
+  } else {
+    const cargoTomlPath = path8.join(packageDir, "Cargo.toml");
+    if (fs10.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 \${packageName} v\${version}`,
+        prereleaseIdentifier,
+        dryRun,
+        mainPackage
+      } = config;
+      const formattedPrefix = formatVersionPrefix(versionPrefix || "v");
+      let latestTag = await getLatestTag();
+      let mainPkgPath = packages.root;
+      let mainPkgName;
+      let versionSourcePath = mainPkgPath;
+      let versionSourceName;
+      if (mainPackage) {
+        const mainPkg = packages.packages.find((p) => p.packageJson.name === mainPackage);
+        if (mainPkg) {
+          mainPkgPath = mainPkg.dir;
+          mainPkgName = mainPkg.packageJson.name;
+          versionSourcePath = mainPkgPath;
+          versionSourceName = mainPkgName;
+          log(`Using ${mainPkgName} as primary package for version determination`, "info");
+        } else {
+          log(`Main package '${mainPackage}' not found. Using root package for version determination.`, "warning");
+        }
+      } else if (packages.packages.length > 0) {
+        versionSourcePath = packages.packages[0].dir;
+        versionSourceName = packages.packages[0].packageJson.name;
+        log(`No mainPackage specified; using ${versionSourceName} as sync version source`, "info");
+      }
+      if (!mainPkgPath) {
+        mainPkgPath = process.cwd();
+        log(`No valid package path found, using current working directory: ${mainPkgPath}`, "warning");
+      }
+      if (versionSourceName) {
+        const packageSpecificTag = await getLatestTagForPackage(versionSourceName, formattedPrefix, {
+          tagTemplate,
+          packageSpecificTags: config.packageSpecificTags
+        });
+        if (packageSpecificTag) {
+          latestTag = packageSpecificTag;
+          log(`Using package-specific tag for ${versionSourceName}: ${latestTag}`, "debug");
+        } else {
+          log(`No package-specific tag found for ${versionSourceName}, using global tag: ${latestTag}`, "debug");
+        }
+      }
+      const nextVersion = await calculateVersion(config, {
+        latestTag,
+        versionPrefix: formattedPrefix,
+        branchPattern,
+        baseBranch,
+        prereleaseIdentifier,
+        path: versionSourcePath,
+        name: versionSourceName,
+        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 = path8.join(packages.root, "package.json");
+          if (fs10.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 = path8.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;
+      if (config.packageSpecificTags && packages.packages.length === 1) {
+        tagPackageName = packages.packages[0].packageJson.name;
+      }
+      const workspaceNames = updatedPackages.filter((n) => n !== "root");
+      const commitPackageName = workspaceNames.length > 0 ? workspaceNames.join(", ") : void 0;
+      const nextTag = formatTag(
+        nextVersion,
+        formattedPrefix,
+        tagPackageName,
+        // Only pass tagTemplate when we have a package name to substitute into it.
+        // In multi-package sync mode tagPackageName is null, so omit the template to
+        // avoid a spurious ${packageName} warning and a malformed tag like "-v1.0.0".
+        tagPackageName ? tagTemplate : void 0,
+        config.packageSpecificTags || false
+      );
+      let formattedCommitMessage;
+      const hasPackageNamePlaceholder = commitMessage.includes("${packageName}");
+      if (commitPackageName === void 0 && !hasPackageNamePlaceholder) {
+        formattedCommitMessage = formatCommitMessage(commitMessage, nextVersion, void 0, void 0);
+      } else if (commitPackageName === void 0) {
+        formattedCommitMessage = commitMessage.replace(/\$\{version\}/g, nextVersion).replace(/\$\{packageName\}/g, "").replace(/\$\{scope\}/g, "");
+      } else {
+        formattedCommitMessage = formatCommitMessage(commitMessage, nextVersion, commitPackageName, void 0);
+      }
+      formattedCommitMessage = formattedCommitMessage.replace(/\s{2,}/g, " ").trim();
+      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 \${packageName} v\${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 = path8.join(pkgPath, "package.json");
+        if (fs10.existsSync(packageJsonPath2)) {
+          const packageJson = JSON.parse(fs10.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 = path8.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
+import { cwd as cwd2 } from "process";
+import { getPackagesSync } from "@manypkg/get-packages";
+
+// src/errors/gitError.ts
+var GitError = class extends BaseVersionError {
+};
+
+// src/utils/packageFiltering.ts
+import path9 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 = path9.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(cwd2());
+      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 = cwd2();
+      }
+      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 {
+  loadConfig2 as loadConfig,
+  VersionErrorCode,
+  createVersionError,
+  enableJsonOutput,
+  flushPendingWrites,
+  getJsonData,
+  printJsonOutput,
+  log,
+  calculateVersion,
+  PackageProcessor,
+  createSyncStrategy,
+  createSingleStrategy,
+  createAsyncStrategy,
+  VersionEngine
+};