@releasekit/version 0.2.0 → 0.2.1

package/dist/{chunk-GH75HGCN.js → chunk-ZIZARLA7.js}

@@ -1,13 +1,352 @@
 import {
-  BaseVersionError
-} from "./chunk-GQLJ7JQY.js";
+  BaseVersionError,
+  ReleaseKitError
+} from "./chunk-PVBHVUZB.js";
 import {
   execAsync,
   execSync
 } from "./chunk-LMPZV35Z.js";
 
-// src/config.ts
-import { loadConfig as loadReleaseKitConfig } from "@releasekit/config";
+// ../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 how release notes are sourced for GitHub releases.
+   * - 'auto': Use RELEASE_NOTES.md if it exists, then per-package changelog
+   *   data from the version output, then GitHub's auto-generated notes.
+   * - 'github': Always use GitHub's auto-generated notes.
+   * - 'none': No notes body.
+   * - Any other string: Treated as a file path to read notes from.
+   */
+  releaseNotes: z.union([z.literal("auto"), z.literal("github"), z.literal("none"), z.string()]).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",
+    releaseNotes: "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 OutputConfigSchema = z.object({
+  format: z.enum(["markdown", "github-release", "json"]),
+  file: z.string().optional(),
+  options: z.record(z.string(), z.unknown()).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 NotesInputConfigSchema = z.object({
+  source: z.string().optional(),
+  file: z.string().optional()
+});
+var NotesConfigSchema = z.object({
+  input: NotesInputConfigSchema.optional(),
+  output: z.array(OutputConfigSchema).default([{ format: "markdown", file: "CHANGELOG.md" }]),
+  monorepo: MonorepoConfigSchema.optional(),
+  templates: TemplateConfigSchema.optional(),
+  llm: LLMConfigSchema.optional(),
+  updateStrategy: z.enum(["prepend", "regenerate"]).default("prepend")
+});
+var ReleaseKitConfigSchema = z.object({
+  git: GitConfigSchema.optional(),
+  monorepo: MonorepoConfigSchema.optional(),
+  version: VersionConfigSchema.optional(),
+  publish: PublishConfigSchema.optional(),
+  notes: NotesConfigSchema.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) {
@@ -20,8 +359,7 @@ function toVersionConfig(config, gitConfig) {
       packages: [],
       updateInternalDependencies: "minor",
       versionPrefix: "",
-      baseBranch: gitConfig?.branch,
-      skipHooks: gitConfig?.skipHooks
+      baseBranch: gitConfig?.branch
     };
   }
   return {
@@ -40,7 +378,6 @@ function toVersionConfig(config, gitConfig) {
       releaseType: bp.releaseType
     })),
     defaultReleaseType: config.defaultReleaseType,
-    skipHooks: gitConfig?.skipHooks,
     mismatchStrategy: config.mismatchStrategy,
     versionPrefix: config.versionPrefix ?? "",
     prereleaseIdentifier: config.prereleaseIdentifier,
@@ -50,8 +387,8 @@ function toVersionConfig(config, gitConfig) {
 }
 
 // src/config.ts
-function loadConfig(options) {
-  const fullConfig = loadReleaseKitConfig(options);
+function loadConfig2(options) {
+  const fullConfig = loadConfig(options);
   return toVersionConfig(fullConfig.version, fullConfig.git);
 }
 
@@ -185,14 +522,11 @@ function log(message, level = "info") {
     default:
       chalkFn = chalk.blue;
   }
+  const formattedMessage = level === "debug" ? `[DEBUG] ${message}` : message;
   if (isJsonOutputMode()) {
-    if (level === "error") {
-      chalkFn(message);
-      console.error(message);
-    }
+    console.error(chalkFn(formattedMessage));
     return;
   }
-  const formattedMessage = level === "debug" ? `[DEBUG] ${message}` : message;
   if (level === "error") {
     console.error(chalkFn(formattedMessage));
   } else {
@@ -206,24 +540,8 @@ import { Bumper } from "conventional-recommended-bump";
 import semver3 from "semver";
 
 // src/git/repository.ts
-import { existsSync, statSync } from "fs";
-import { join } from "path";
-function isGitRepository(directory) {
-  const gitDir = join(directory, ".git");
-  if (!existsSync(gitDir)) {
-    return false;
-  }
-  const stats = statSync(gitDir);
-  if (!stats.isDirectory()) {
-    return false;
-  }
-  try {
-    execSync("git", ["rev-parse", "--is-inside-work-tree"], { cwd: directory });
-    return true;
-  } catch (_error) {
-    return false;
-  }
-}
+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();
@@ -476,16 +794,15 @@ async function getLatestTagForPackage(packageName, versionPrefix, options) {
 }
 
 // src/utils/manifestHelpers.ts
-import fs2 from "fs";
-import path2 from "path";
+import fs5 from "fs";
+import path5 from "path";
 
 // src/cargo/cargoHandler.ts
-import fs from "fs";
-import path from "path";
-import { isCargoToml, parseCargoToml } from "@releasekit/config";
-import * as TOML from "smol-toml";
+import fs4 from "fs";
+import path4 from "path";
+import * as TOML2 from "smol-toml";
 function getCargoInfo(cargoPath) {
-  if (!fs.existsSync(cargoPath)) {
+  if (!fs4.existsSync(cargoPath)) {
     log(`Cargo.toml file not found at: ${cargoPath}`, "error");
     throw new Error(`Cargo.toml file not found at: ${cargoPath}`);
   }
@@ -499,7 +816,7 @@ function getCargoInfo(cargoPath) {
       name: cargo.package.name,
       version: cargo.package.version || "0.0.0",
       path: cargoPath,
-      dir: path.dirname(cargoPath),
+      dir: path4.dirname(cargoPath),
       content: cargo
     };
   } catch (error) {
@@ -524,8 +841,8 @@ function updateCargoVersion(cargoPath, version, dryRun = false) {
       } else {
         cargo.package.version = version;
       }
-      const updatedContent = TOML.stringify(cargo);
-      fs.writeFileSync(cargoPath, updatedContent);
+      const updatedContent = TOML2.stringify(cargo);
+      fs4.writeFileSync(cargoPath, updatedContent);
     }
     addPackageUpdate(packageName, version, cargoPath);
     log(`${dryRun ? "[DRY RUN] Would update" : "Updated"} Cargo.toml at ${cargoPath} to version ${version}`, "success");
@@ -540,11 +857,11 @@ function updateCargoVersion(cargoPath, version, dryRun = false) {
 
 // src/utils/manifestHelpers.ts
 function getVersionFromManifests(packageDir) {
-  const packageJsonPath = path2.join(packageDir, "package.json");
-  const cargoTomlPath = path2.join(packageDir, "Cargo.toml");
-  if (fs2.existsSync(packageJsonPath)) {
+  const packageJsonPath = path5.join(packageDir, "package.json");
+  const cargoTomlPath = path5.join(packageDir, "Cargo.toml");
+  if (fs5.existsSync(packageJsonPath)) {
     try {
-      const packageJson = JSON.parse(fs2.readFileSync(packageJsonPath, "utf-8"));
+      const packageJson = JSON.parse(fs5.readFileSync(packageJsonPath, "utf-8"));
       if (packageJson.version) {
         log(`Found version ${packageJson.version} in package.json`, "debug");
         return {
@@ -560,7 +877,7 @@ function getVersionFromManifests(packageDir) {
       log(`Error reading package.json: ${errMsg}`, "warning");
     }
   }
-  if (fs2.existsSync(cargoTomlPath)) {
+  if (fs5.existsSync(cargoTomlPath)) {
     try {
       const cargoInfo = getCargoInfo(cargoTomlPath);
       if (cargoInfo.version) {
@@ -587,18 +904,17 @@ function getVersionFromManifests(packageDir) {
 }
 
 // src/utils/versionUtils.ts
-import fs3 from "fs";
-import { parseCargoToml as parseCargoToml2 } from "@releasekit/config";
+import fs6 from "fs";
 import semver2 from "semver";
 
 // src/git/tagVerification.ts
-function verifyTag(tagName, cwd4) {
+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: cwd4,
+      cwd: cwd3,
       stdio: "ignore"
     });
     return { exists: true, reachable: true };
@@ -695,11 +1011,11 @@ var VersionMismatchError = class extends Error {
     this.name = "VersionMismatchError";
   }
 };
-async function getBestVersionSource(tagName, packageVersion, cwd4, mismatchStrategy = "error", strictReachable = false) {
+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, cwd4);
+  const verification = verifyTag(tagName, cwd3);
   if (!verification.exists || !verification.reachable) {
     if (strictReachable) {
       throw new Error(
@@ -964,9 +1280,8 @@ async function calculateVersion(config, options) {
 }
 
 // src/package/packageProcessor.ts
-import * as fs5 from "fs";
-import path4 from "path";
-import { exit } from "process";
+import * as fs8 from "fs";
+import path7 from "path";
 
 // src/changelog/commitParser.ts
 var CONVENTIONAL_COMMIT_REGEX = /^(\w+)(?:\(([^)]+)\))?(!)?: (.+)(?:\n\n([\s\S]*))?/;
@@ -1140,168 +1455,6 @@ function extractIssueIds(body) {
   return issueIds;
 }
 
-// src/git/commands.ts
-import { cwd as cwd2 } from "process";
-
-// src/errors/gitError.ts
-var GitError = class extends BaseVersionError {
-};
-function createGitError(code, details) {
-  const messages = {
-    ["NOT_GIT_REPO" /* NOT_GIT_REPO */]: "Not a git repository",
-    ["GIT_PROCESS_ERROR" /* GIT_PROCESS_ERROR */]: "Failed to create new version",
-    ["NO_FILES" /* NO_FILES */]: "No files specified for commit",
-    ["NO_COMMIT_MESSAGE" /* NO_COMMIT_MESSAGE */]: "Commit message is required",
-    ["GIT_ERROR" /* GIT_ERROR */]: "Git operation failed",
-    ["TAG_ALREADY_EXISTS" /* TAG_ALREADY_EXISTS */]: "Git tag already exists"
-  };
-  const suggestions = {
-    ["NOT_GIT_REPO" /* NOT_GIT_REPO */]: [
-      "Initialize git repository with: git init",
-      "Ensure you are in the correct directory"
-    ],
-    ["TAG_ALREADY_EXISTS" /* TAG_ALREADY_EXISTS */]: [
-      "Delete the existing tag: git tag -d <tag-name>",
-      "Use a different version by incrementing manually",
-      "Check if this version was already released"
-    ],
-    ["GIT_PROCESS_ERROR" /* GIT_PROCESS_ERROR */]: void 0,
-    ["NO_FILES" /* NO_FILES */]: void 0,
-    ["NO_COMMIT_MESSAGE" /* NO_COMMIT_MESSAGE */]: void 0,
-    ["GIT_ERROR" /* GIT_ERROR */]: void 0
-  };
-  const baseMessage = messages[code];
-  const fullMessage = details ? `${baseMessage}: ${details}` : baseMessage;
-  return new GitError(fullMessage, code, suggestions[code]);
-}
-
-// src/git/commands.ts
-async function gitAdd(files) {
-  return execAsync("git", ["add", ...files]);
-}
-async function gitCommit(options) {
-  const args = ["commit"];
-  if (options.amend) {
-    args.push("--amend");
-  }
-  if (options.author) {
-    args.push("--author", options.author);
-  }
-  if (options.date) {
-    args.push("--date", options.date);
-  }
-  if (options.skipHooks) {
-    args.push("--no-verify");
-  }
-  args.push("-m", options.message);
-  return execAsync("git", args);
-}
-async function createGitTag(options) {
-  const { tag, message = "" } = options;
-  const args = ["tag", "-a", "-m", message, tag];
-  try {
-    return await execAsync("git", args);
-  } catch (error) {
-    const errorMessage = error instanceof Error ? error.message : String(error);
-    if (errorMessage.includes("already exists")) {
-      throw createGitError(
-        "TAG_ALREADY_EXISTS" /* TAG_ALREADY_EXISTS */,
-        `Tag '${tag}' already exists in the repository. Please use a different version or delete the existing tag first.`
-      );
-    }
-    throw createGitError("GIT_ERROR" /* GIT_ERROR */, errorMessage);
-  }
-}
-async function gitProcess(options) {
-  const { files, nextTag, commitMessage, skipHooks, dryRun } = options;
-  if (!isGitRepository(cwd2())) {
-    throw createGitError("NOT_GIT_REPO" /* NOT_GIT_REPO */);
-  }
-  try {
-    if (!dryRun) {
-      await gitAdd(files);
-      await gitCommit({
-        message: commitMessage,
-        skipHooks
-      });
-      if (nextTag) {
-        const tagMessage = `New Version ${nextTag} generated at ${(/* @__PURE__ */ new Date()).toISOString()}`;
-        await createGitTag({
-          tag: nextTag,
-          message: tagMessage
-        });
-      }
-    } else {
-      log("[DRY RUN] Would add files:", "info");
-      for (const file of files) {
-        log(`  - ${file}`, "info");
-      }
-      log(`[DRY RUN] Would commit with message: "${commitMessage}"`, "info");
-      if (nextTag) {
-        log(`[DRY RUN] Would create tag: ${nextTag}`, "info");
-      }
-    }
-  } catch (err) {
-    const errorMessage = err instanceof Error ? err.message : String(err);
-    if (errorMessage.includes("already exists") && nextTag) {
-      log(`Tag '${nextTag}' already exists in the repository.`, "error");
-      throw createGitError(
-        "TAG_ALREADY_EXISTS" /* TAG_ALREADY_EXISTS */,
-        `Tag '${nextTag}' already exists in the repository. Please use a different version or delete the existing tag first.`
-      );
-    }
-    log(`Git process error: ${errorMessage}`, "error");
-    if (err instanceof Error && err.stack) {
-      console.error("Git process stack trace:");
-      console.error(err.stack);
-    }
-    throw createGitError("GIT_PROCESS_ERROR" /* GIT_PROCESS_ERROR */, errorMessage);
-  }
-}
-async function createGitCommitAndTag(files, nextTag, commitMessage, skipHooks, dryRun) {
-  try {
-    if (!files || files.length === 0) {
-      throw createGitError("NO_FILES" /* NO_FILES */);
-    }
-    if (!commitMessage) {
-      throw createGitError("NO_COMMIT_MESSAGE" /* NO_COMMIT_MESSAGE */);
-    }
-    setCommitMessage(commitMessage);
-    if (nextTag) {
-      addTag(nextTag);
-    }
-    await gitProcess({
-      files,
-      nextTag,
-      commitMessage,
-      skipHooks,
-      dryRun
-    });
-    if (!dryRun) {
-      log(`Created tag: ${nextTag}`, "success");
-    }
-  } catch (error) {
-    if (error instanceof GitError) {
-      throw error;
-    }
-    const errorMessage = error instanceof Error ? error.message : String(error);
-    log(`Failed to create git commit and tag: ${errorMessage}`, "error");
-    if (error instanceof Error) {
-      console.error("Git operation error details:");
-      console.error(error.stack || error.message);
-      if (errorMessage.includes("Command failed:")) {
-        const cmdOutput = errorMessage.split("Command failed:")[1];
-        if (cmdOutput) {
-          console.error("Git command output:", cmdOutput.trim());
-        }
-      }
-    } else {
-      console.error("Unknown git error:", error);
-    }
-    throw new GitError(`Git operation failed: ${errorMessage}`, "GIT_ERROR" /* GIT_ERROR */);
-  }
-}
-
 // src/utils/packageMatching.ts
 import micromatch from "micromatch";
 function matchesPackageTarget(packageName, target) {
@@ -1336,20 +1489,20 @@ function shouldProcessPackage(packageName, skip = []) {
 }
 
 // src/package/packageManagement.ts
-import fs4 from "fs";
-import path3 from "path";
+import fs7 from "fs";
+import path6 from "path";
 function updatePackageVersion(packagePath, version, dryRun = false) {
   if (isCargoToml(packagePath)) {
     updateCargoVersion(packagePath, version, dryRun);
     return;
   }
   try {
-    const packageContent = fs4.readFileSync(packagePath, "utf8");
+    const packageContent = fs7.readFileSync(packagePath, "utf8");
     const packageJson = JSON.parse(packageContent);
     const packageName = packageJson.name;
     if (!dryRun) {
       packageJson.version = version;
-      fs4.writeFileSync(packagePath, `${JSON.stringify(packageJson, null, 2)}
+      fs7.writeFileSync(packagePath, `${JSON.stringify(packageJson, null, 2)}
 `);
     }
     addPackageUpdate(packageName, version, packagePath);
@@ -1373,7 +1526,6 @@ var PackageProcessor = class {
   tagTemplate;
   commitMessageTemplate;
   dryRun;
-  skipHooks;
   getLatestTag;
   config;
   // Config for version calculation
@@ -1384,7 +1536,6 @@ var PackageProcessor = class {
     this.tagTemplate = options.tagTemplate;
     this.commitMessageTemplate = options.commitMessageTemplate || "";
     this.dryRun = options.dryRun || false;
-    this.skipHooks = options.skipHooks || false;
     this.getLatestTag = options.getLatestTag;
     this.config = options.config;
     this.fullConfig = options.fullConfig;
@@ -1519,9 +1670,9 @@ var PackageProcessor = class {
       }
       let repoUrl;
       try {
-        const packageJsonPath2 = path4.join(pkgPath, "package.json");
-        if (fs5.existsSync(packageJsonPath2)) {
-          const packageJson = JSON.parse(fs5.readFileSync(packageJsonPath2, "utf8"));
+        const packageJsonPath2 = path7.join(pkgPath, "package.json");
+        if (fs8.existsSync(packageJsonPath2)) {
+          const packageJson = JSON.parse(fs8.readFileSync(packageJsonPath2, "utf8"));
           if (packageJson.repository) {
             if (typeof packageJson.repository === "string") {
               repoUrl = packageJson.repository;
@@ -1547,8 +1698,8 @@ var PackageProcessor = class {
         repoUrl: repoUrl || null,
         entries: changelogEntries
       });
-      const packageJsonPath = path4.join(pkgPath, "package.json");
-      if (fs5.existsSync(packageJsonPath)) {
+      const packageJsonPath = path7.join(pkgPath, "package.json");
+      if (fs8.existsSync(packageJsonPath)) {
         updatePackageVersion(packageJsonPath, nextVersion, this.dryRun);
       }
       const cargoEnabled = this.fullConfig.cargo?.enabled !== false;
@@ -1558,9 +1709,9 @@ var PackageProcessor = class {
         log(`Cargo paths config for ${name}: ${JSON.stringify(cargoPaths)}`, "debug");
         if (cargoPaths && cargoPaths.length > 0) {
           for (const cargoPath of cargoPaths) {
-            const resolvedCargoPath = path4.resolve(pkgPath, cargoPath, "Cargo.toml");
+            const resolvedCargoPath = path7.resolve(pkgPath, cargoPath, "Cargo.toml");
             log(`Checking cargo path for ${name}: ${resolvedCargoPath}`, "debug");
-            if (fs5.existsSync(resolvedCargoPath)) {
+            if (fs8.existsSync(resolvedCargoPath)) {
               log(`Found Cargo.toml for ${name} at ${resolvedCargoPath}, updating...`, "debug");
               updatePackageVersion(resolvedCargoPath, nextVersion, this.dryRun);
             } else {
@@ -1568,9 +1719,9 @@ var PackageProcessor = class {
             }
           }
         } else {
-          const cargoTomlPath = path4.join(pkgPath, "Cargo.toml");
+          const cargoTomlPath = path7.join(pkgPath, "Cargo.toml");
           log(`Checking default cargo path for ${name}: ${cargoTomlPath}`, "debug");
-          if (fs5.existsSync(cargoTomlPath)) {
+          if (fs8.existsSync(cargoTomlPath)) {
             log(`Found Cargo.toml for ${name} at ${cargoTomlPath}, updating...`, "debug");
             updatePackageVersion(cargoTomlPath, nextVersion, this.dryRun);
           } else {
@@ -1587,19 +1738,12 @@ var PackageProcessor = class {
         this.tagTemplate,
         this.fullConfig.packageSpecificTags
       );
-      const tagMessage = `chore(release): ${name} ${nextVersion}`;
       addTag(packageTag);
       tags.push(packageTag);
-      if (!this.dryRun) {
-        try {
-          await createGitTag({ tag: packageTag, message: tagMessage });
-          log(`Created tag: ${packageTag}`, "success");
-        } catch (tagError) {
-          log(`Failed to create tag ${packageTag} for ${name}: ${tagError.message}`, "error");
-          log(tagError.stack || "No stack trace available", "error");
-        }
-      } else {
+      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 });
     }
@@ -1607,30 +1751,6 @@ var PackageProcessor = class {
       log("No packages required a version update.", "info");
       return { updatedPackages: [], tags };
     }
-    const filesToCommit = [];
-    for (const info of updatedPackagesInfo) {
-      const packageJsonPath = path4.join(info.path, "package.json");
-      if (fs5.existsSync(packageJsonPath)) {
-        filesToCommit.push(packageJsonPath);
-      }
-      const cargoEnabled = this.fullConfig.cargo?.enabled !== false;
-      if (cargoEnabled) {
-        const cargoPaths = this.fullConfig.cargo?.paths;
-        if (cargoPaths && cargoPaths.length > 0) {
-          for (const cargoPath of cargoPaths) {
-            const resolvedCargoPath = path4.resolve(info.path, cargoPath, "Cargo.toml");
-            if (fs5.existsSync(resolvedCargoPath)) {
-              filesToCommit.push(resolvedCargoPath);
-            }
-          }
-        } else {
-          const cargoTomlPath = path4.join(info.path, "Cargo.toml");
-          if (fs5.existsSync(cargoTomlPath)) {
-            filesToCommit.push(cargoTomlPath);
-          }
-        }
-      }
-    }
     const packageNames = updatedPackagesInfo.map((p) => p.name).join(", ");
     const representativeVersion = updatedPackagesInfo[0]?.version || "multiple";
     let commitMessage = this.commitMessageTemplate || "chore(release): publish packages";
@@ -1647,21 +1767,7 @@ var PackageProcessor = class {
       commitMessage = `chore(release): ${packageNames} ${representativeVersion}`;
     }
     setCommitMessage(commitMessage);
-    if (!this.dryRun) {
-      try {
-        await gitAdd(filesToCommit);
-        await gitCommit({ message: commitMessage, skipHooks: this.skipHooks });
-        log(`Created commit for targeted release: ${packageNames}`, "success");
-      } catch (commitError) {
-        log("Failed to create commit for targeted release.", "error");
-        console.error(commitError);
-        exit(1);
-      }
-    } else {
-      log("[DRY RUN] Would add files:", "info");
-      for (const file of filesToCommit) {
-        log(`  - ${file}`, "info");
-      }
+    if (this.dryRun) {
       log(`[DRY RUN] Would commit with message: "${commitMessage}"`, "info");
     }
     return {
@@ -1673,8 +1779,8 @@ var PackageProcessor = class {
 };
 
 // src/core/versionStrategies.ts
-import fs6 from "fs";
-import * as path5 from "path";
+import fs9 from "fs";
+import * as path8 from "path";
 function shouldProcessPackage2(pkg, config) {
   const pkgName = pkg.packageJson.name;
   return shouldProcessPackage(pkgName, config.skip);
@@ -1688,15 +1794,15 @@ function updateCargoFiles(packageDir, version, cargoConfig, dryRun = false) {
   const cargoPaths = cargoConfig?.paths;
   if (cargoPaths && cargoPaths.length > 0) {
     for (const cargoPath of cargoPaths) {
-      const resolvedCargoPath = path5.resolve(packageDir, cargoPath, "Cargo.toml");
-      if (fs6.existsSync(resolvedCargoPath)) {
+      const resolvedCargoPath = path8.resolve(packageDir, cargoPath, "Cargo.toml");
+      if (fs9.existsSync(resolvedCargoPath)) {
         updatePackageVersion(resolvedCargoPath, version, dryRun);
         updatedFiles.push(resolvedCargoPath);
       }
     }
   } else {
-    const cargoTomlPath = path5.join(packageDir, "Cargo.toml");
-    if (fs6.existsSync(cargoTomlPath)) {
+    const cargoTomlPath = path8.join(packageDir, "Cargo.toml");
+    if (fs9.existsSync(cargoTomlPath)) {
       updatePackageVersion(cargoTomlPath, version, dryRun);
       updatedFiles.push(cargoTomlPath);
     }
@@ -1714,7 +1820,6 @@ function createSyncStrategy(config) {
         commitMessage = `chore(release): v\${version}`,
         prereleaseIdentifier,
         dryRun,
-        skipHooks,
         mainPackage
       } = config;
       const formattedPrefix = formatVersionPrefix(versionPrefix || "v");
@@ -1767,8 +1872,8 @@ function createSyncStrategy(config) {
       const processedPaths = /* @__PURE__ */ new Set();
       try {
         if (packages.root) {
-          const rootPkgPath = path5.join(packages.root, "package.json");
-          if (fs6.existsSync(rootPkgPath)) {
+          const rootPkgPath = path8.join(packages.root, "package.json");
+          if (fs9.existsSync(rootPkgPath)) {
             updatePackageVersion(rootPkgPath, nextVersion, dryRun);
             files.push(rootPkgPath);
             updatedPackages.push("root");
@@ -1787,7 +1892,7 @@ function createSyncStrategy(config) {
         if (!shouldProcessPackage2(pkg, config)) {
           continue;
         }
-        const packageJsonPath = path5.join(pkg.dir, "package.json");
+        const packageJsonPath = path8.join(pkg.dir, "package.json");
         if (processedPaths.has(packageJsonPath)) {
           continue;
         }
@@ -1864,7 +1969,13 @@ function createSyncStrategy(config) {
         config.packageSpecificTags || false
       );
       const formattedCommitMessage = formatCommitMessage(commitMessage, nextVersion, commitPackageName, void 0);
-      await createGitCommitAndTag(files, nextTag, formattedCommitMessage, skipHooks, dryRun);
+      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");
@@ -1879,14 +1990,7 @@ function createSyncStrategy(config) {
 function createSingleStrategy(config) {
   return async (packages) => {
     try {
-      const {
-        mainPackage,
-        versionPrefix,
-        tagTemplate,
-        commitMessage = `chore(release): \${version}`,
-        dryRun,
-        skipHooks
-      } = config;
+      const { mainPackage, versionPrefix, tagTemplate, commitMessage = `chore(release): \${version}`, dryRun } = config;
       let packageName;
       if (mainPackage) {
         packageName = mainPackage;
@@ -1970,9 +2074,9 @@ function createSingleStrategy(config) {
       }
       let repoUrl;
       try {
-        const packageJsonPath2 = path5.join(pkgPath, "package.json");
-        if (fs6.existsSync(packageJsonPath2)) {
-          const packageJson = JSON.parse(fs6.readFileSync(packageJsonPath2, "utf8"));
+        const packageJsonPath2 = path8.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;
@@ -1998,7 +2102,7 @@ function createSingleStrategy(config) {
         repoUrl: repoUrl || null,
         entries: changelogEntries
       });
-      const packageJsonPath = path5.join(pkgPath, "package.json");
+      const packageJsonPath = path8.join(pkgPath, "package.json");
       updatePackageVersion(packageJsonPath, nextVersion, dryRun);
       const filesToCommit = [packageJsonPath];
       const cargoFiles = updateCargoFiles(pkgPath, nextVersion, config.cargo, dryRun);
@@ -2006,9 +2110,10 @@ function createSingleStrategy(config) {
       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) {
-        await createGitCommitAndTag(filesToCommit, tagName, commitMsg, skipHooks, dryRun);
-        log(`Created tag: ${tagName}`, "success");
+        log(`Version ${nextVersion} prepared (tag: ${tagName})`, "success");
       } else {
         log(`Would create tag: ${tagName}`, "info");
       }
@@ -2033,7 +2138,6 @@ function createAsyncStrategy(config) {
     tagTemplate: config.tagTemplate,
     commitMessageTemplate: config.commitMessage || "",
     dryRun: config.dryRun || false,
-    skipHooks: config.skipHooks || false,
     getLatestTag: dependencies.getLatestTag,
     fullConfig: config,
     // Extract common version configuration properties
@@ -2096,11 +2200,15 @@ function createStrategyMap(config) {
 }
 
 // src/core/versionEngine.ts
-import { cwd as cwd3 } from "process";
+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 path6 from "path";
+import path9 from "path";
 import micromatch2 from "micromatch";
 function filterPackagesByConfig(packages, configTargets, workspaceRoot) {
   if (configTargets.length === 0) {
@@ -2126,7 +2234,7 @@ function filterByDirectoryPattern(packages, pattern, workspaceRoot) {
   }
   const normalizedPattern = pattern.replace(/\\/g, "/");
   return packages.filter((pkg) => {
-    const relativePath = path6.relative(workspaceRoot, pkg.dir);
+    const relativePath = path9.relative(workspaceRoot, pkg.dir);
     const normalizedRelativePath = relativePath.replace(/\\/g, "/");
     if (normalizedPattern === normalizedRelativePath) {
       return true;
@@ -2204,13 +2312,13 @@ var VersionEngine = class {
       if (this.workspaceCache) {
         return this.workspaceCache;
       }
-      const pkgsResult = getPackagesSync(cwd3());
+      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 = cwd3();
+        pkgsResult.root = cwd2();
       }
       if (this.config.packages && this.config.packages.length > 0) {
         const originalCount = pkgsResult.packages.length;
@@ -2274,7 +2382,7 @@ var VersionEngine = class {
 };
 
 export {
-  loadConfig,
+  loadConfig2 as loadConfig,
   VersionErrorCode,
   createVersionError,
   enableJsonOutput,