@denisvieiradev/gitwise-core 0.1.0

package/dist/index.js

@@ -0,0 +1,3077 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// package.json
+var package_default = {
+  name: "@denisvieiradev/gitwise-core",
+  version: "0.1.0",
+  description: "Shared logic for gitwise: non-interactive commit/review/pr/release commands, LLM providers, git/github primitives, prompt templates.",
+  type: "module",
+  main: "./dist/index.js",
+  types: "./dist/index.d.ts",
+  exports: {
+    ".": {
+      types: "./dist/index.d.ts",
+      import: "./dist/index.js"
+    },
+    "./testing": {
+      types: "./dist/testing/index.d.ts",
+      import: "./dist/testing/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  files: [
+    "dist",
+    "templates",
+    "README.md",
+    "LICENSE"
+  ],
+  scripts: {
+    build: "tsup",
+    test: "node --experimental-vm-modules ../../node_modules/.bin/jest --passWithNoTests",
+    lint: "tsc --noEmit",
+    typecheck: "tsc --noEmit"
+  },
+  keywords: [
+    "gitwise",
+    "git",
+    "ai",
+    "claude",
+    "commit",
+    "pull-request",
+    "release",
+    "code-review"
+  ],
+  author: "Denis Vieira <denisvieira05@gmail.com> (https://github.com/denisvieiradev)",
+  license: "MIT",
+  repository: {
+    type: "git",
+    url: "git+https://github.com/denisvieiradev/gitwise.git",
+    directory: "packages/core"
+  },
+  bugs: {
+    url: "https://github.com/denisvieiradev/gitwise/issues"
+  },
+  homepage: "https://github.com/denisvieiradev/gitwise#readme",
+  engines: {
+    node: ">=22.12.0"
+  },
+  dependencies: {
+    "@anthropic-ai/sdk": "^0.109.0"
+  }
+};
+
+// src/errors.ts
+var EXIT_CODES = Object.freeze({
+  OK: 0,
+  UNKNOWN: 1,
+  NOTHING_STAGED: 10,
+  INVALID_INTENT: 11,
+  GIT_FAILED: 20,
+  GH_FAILED: 21,
+  REPO_STATE_INVALID: 22,
+  API_FAILED: 30,
+  API_KEY_MISSING: 31,
+  API_RATE_LIMITED: 32,
+  USER_ABORT: 40,
+  CONFIG_INVALID: 50,
+  RELEASE_PLAN_STALE: 60,
+  RELEASE_BRANCH_CONFLICT: 61,
+  SENSITIVE_FILE_BLOCKED: 70,
+  REPO_LOCKED: 80,
+  ROLLBACK_PARTIAL: 81
+});
+var GitwiseError = class extends Error {
+  code;
+  exitCode;
+  cause;
+  details;
+  constructor(args) {
+    super(args.message);
+    this.name = "GitwiseError";
+    this.code = args.code;
+    this.exitCode = args.exitCode ?? EXIT_CODES[args.code] ?? 1;
+    this.cause = args.cause;
+    this.details = args.details;
+  }
+  toJSON() {
+    return {
+      name: this.name,
+      code: this.code,
+      exitCode: this.exitCode,
+      message: this.message,
+      ...this.details !== void 0 ? { details: this.details } : {}
+    };
+  }
+};
+function wrapError(err) {
+  if (err instanceof GitwiseError) return err;
+  if (err instanceof Error) {
+    return new GitwiseError({
+      code: "UNKNOWN",
+      message: err.message,
+      cause: err
+    });
+  }
+  return new GitwiseError({
+    code: "UNKNOWN",
+    message: typeof err === "string" ? err : "Unknown error",
+    cause: err
+  });
+}
+
+// src/infra/logger.ts
+var verboseEnabled = false;
+if (process.env["GITWISE_DEBUG"] === "1") {
+  verboseEnabled = true;
+}
+function setVerbose(enabled) {
+  verboseEnabled = enabled;
+}
+function isVerbose() {
+  return verboseEnabled;
+}
+function info(message, context) {
+  if (context) {
+    console.log(message, context);
+  } else {
+    console.log(message);
+  }
+}
+function error(message, context) {
+  if (context) {
+    console.error(message, context);
+  } else {
+    console.error(message);
+  }
+}
+function warn(message, context) {
+  if (context) {
+    console.warn(message, context);
+  } else {
+    console.warn(message);
+  }
+}
+function debug(message, context) {
+  if (!verboseEnabled) return;
+  if (context) {
+    process.stderr.write(`[debug] ${message} ${JSON.stringify(context)}
+`);
+  } else {
+    process.stderr.write(`[debug] ${message}
+`);
+  }
+}
+
+// src/infra/filesystem.ts
+import { access, mkdir, readFile, writeFile } from "fs/promises";
+import { dirname } from "path";
+async function fileExists(filePath) {
+  try {
+    await access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function readJSON(filePath) {
+  const content = await readFile(filePath, "utf-8");
+  return JSON.parse(content);
+}
+async function writeJSON(filePath, data) {
+  await ensureDir(dirname(filePath));
+  const content = JSON.stringify(data, null, 2) + "\n";
+  await writeFile(filePath, content, "utf-8");
+}
+async function ensureDir(dirPath) {
+  await mkdir(dirPath, { recursive: true });
+}
+
+// src/infra/git.ts
+var git_exports = {};
+__export(git_exports, {
+  add: () => add,
+  applyCommit: () => applyCommit,
+  branchExists: () => branchExists,
+  checkout: () => checkout,
+  checkoutForce: () => checkoutForce,
+  cleanForced: () => cleanForced,
+  commit: () => commit,
+  createBranch: () => createBranch,
+  createTag: () => createTag,
+  deleteBranch: () => deleteBranch,
+  detectBaseBranch: () => detectBaseBranch,
+  fetch: () => fetch,
+  getBranch: () => getBranch,
+  getChangedFiles: () => getChangedFiles,
+  getDiff: () => getDiff,
+  getLatestTag: () => getLatestTag,
+  getLog: () => getLog,
+  getStagedDiff: () => getStagedDiff,
+  getStagedFiles: () => getStagedFiles,
+  getStagedFilesList: () => getStagedFilesList,
+  getUnstagedFiles: () => getUnstagedFiles,
+  headSha: () => headSha,
+  isBranchMerged: () => isBranchMerged,
+  mergeNoFf: () => mergeNoFf,
+  parseStatus: () => parseStatus,
+  push: () => push,
+  pushWithTags: () => pushWithTags,
+  resetHard: () => resetHard,
+  resetSoft: () => resetSoft,
+  resetStaged: () => resetStaged,
+  showFileAtHead: () => showFileAtHead,
+  stagePathsFromTree: () => stagePathsFromTree,
+  stashApplyNamed: () => stashApplyNamed,
+  stashDropNamed: () => stashDropNamed,
+  stashList: () => stashList,
+  stashPopNamed: () => stashPopNamed,
+  stashPushNamed: () => stashPushNamed,
+  status: () => status,
+  tagExists: () => tagExists,
+  writeTree: () => writeTree
+});
+import { execFile } from "child_process";
+import { promisify } from "util";
+var exec = promisify(execFile);
+var GIT_TIMEOUT_MS = 3e4;
+var GIT_MAX_BUFFER = 10 * 1024 * 1024;
+function execStderr(err) {
+  const stderr = err?.stderr;
+  if (typeof stderr === "string" && stderr.length > 0) return stderr;
+  return void 0;
+}
+async function run(args, cwd) {
+  debug("git command", { args, cwd });
+  try {
+    const result = await exec("git", args, { cwd, timeout: GIT_TIMEOUT_MS, maxBuffer: GIT_MAX_BUFFER });
+    return result.stdout.trim();
+  } catch (err) {
+    if (err instanceof Error && "killed" in err && err.killed) {
+      throw new GitwiseError({
+        code: "GIT_FAILED",
+        message: `Git command timed out after ${GIT_TIMEOUT_MS / 1e3}s: git ${args.join(" ")}`,
+        cause: err,
+        details: { command: `git ${args.join(" ")}`, timedOut: true }
+      });
+    }
+    const stderr = execStderr(err);
+    throw new GitwiseError({
+      code: "GIT_FAILED",
+      message: err instanceof Error ? err.message : String(err),
+      cause: err,
+      details: {
+        command: `git ${args.join(" ")}`,
+        ...stderr !== void 0 ? { stderr } : {}
+      }
+    });
+  }
+}
+async function getBranch(cwd) {
+  return run(["rev-parse", "--abbrev-ref", "HEAD"], cwd);
+}
+async function createBranch(cwd, branchName, startPoint) {
+  const args = ["checkout", "-b", branchName];
+  if (startPoint) args.push(startPoint);
+  await run(args, cwd);
+}
+async function checkout(cwd, branchName) {
+  await run(["checkout", branchName], cwd);
+}
+async function checkoutForce(cwd, branchName) {
+  await run(["checkout", "-f", branchName], cwd);
+}
+async function resetHard(cwd, ref) {
+  await run(["reset", "--hard", ref], cwd);
+}
+async function getDiff(cwd, base) {
+  const args = base ? ["diff", `${base}...HEAD`] : ["diff"];
+  return run(args, cwd);
+}
+async function getStagedDiff(cwd) {
+  return run(["diff", "--cached"], cwd);
+}
+async function getLog(cwd, range, maxCount) {
+  const args = ["log", "--oneline"];
+  if (maxCount) args.push(`-${maxCount}`);
+  if (range) args.push(range);
+  return run(args, cwd);
+}
+async function add(cwd, files) {
+  await run(["add", ...files], cwd);
+}
+async function writeTree(cwd) {
+  return run(["write-tree"], cwd);
+}
+async function stagePathsFromTree(cwd, tree, files) {
+  if (files.length === 0) return;
+  await run(["reset", "-q", tree, "--", ...files], cwd);
+}
+async function commit(cwd, message) {
+  return run(["commit", "-m", message], cwd);
+}
+async function status(cwd) {
+  debug("git command", { args: ["status", "--porcelain"], cwd });
+  try {
+    const result = await exec(
+      "git",
+      ["status", "--porcelain"],
+      { cwd, timeout: GIT_TIMEOUT_MS, maxBuffer: GIT_MAX_BUFFER }
+    );
+    return result.stdout.replace(/\n+$/, "");
+  } catch (err) {
+    if (err instanceof Error && "killed" in err && err.killed) {
+      throw new GitwiseError({
+        code: "GIT_FAILED",
+        message: `Git command timed out after ${GIT_TIMEOUT_MS / 1e3}s: git status --porcelain`,
+        cause: err,
+        details: { command: "git status --porcelain", timedOut: true }
+      });
+    }
+    const stderr = execStderr(err);
+    throw new GitwiseError({
+      code: "GIT_FAILED",
+      message: err instanceof Error ? err.message : String(err),
+      cause: err,
+      details: {
+        command: "git status --porcelain",
+        ...stderr !== void 0 ? { stderr } : {}
+      }
+    });
+  }
+}
+async function push(cwd, remote, branch) {
+  await run(["push", remote, branch], cwd);
+}
+async function fetch(cwd, remote) {
+  await run(["fetch", remote], cwd);
+}
+async function getChangedFiles(cwd) {
+  const files = await parseStatus(cwd);
+  return files.map((f) => f.file);
+}
+async function parseStatus(cwd) {
+  let result;
+  try {
+    result = await exec("git", ["status", "--porcelain"], { cwd, timeout: GIT_TIMEOUT_MS, maxBuffer: GIT_MAX_BUFFER });
+  } catch (err) {
+    const stderr = execStderr(err);
+    throw new GitwiseError({
+      code: "GIT_FAILED",
+      message: `Failed to read git status: ${err instanceof Error ? err.message : String(err)}`,
+      cause: err,
+      details: {
+        command: "git status --porcelain",
+        ...stderr !== void 0 ? { stderr } : {}
+      }
+    });
+  }
+  const output = result.stdout;
+  if (!output || !output.trim()) return [];
+  return output.split("\n").filter((line) => line.length >= 3).map((line) => {
+    const indexStatus = line[0];
+    const workTreeStatus = line[1];
+    let file = line.slice(3).trim();
+    if ((indexStatus === "R" || indexStatus === "C") && file.includes(" -> ")) {
+      file = file.split(" -> ").pop();
+    }
+    return { file, indexStatus, workTreeStatus };
+  }).filter((entry) => entry.file.length > 0);
+}
+async function getStagedFiles(cwd) {
+  const files = await parseStatus(cwd);
+  return files.filter((f) => f.indexStatus !== " " && f.indexStatus !== "?");
+}
+async function resetStaged(cwd) {
+  await run(["reset", "HEAD"], cwd);
+}
+async function getStagedFilesList(cwd) {
+  const output = await run(["diff", "--cached", "--name-only"], cwd);
+  if (!output) return [];
+  return output.split("\n").filter((f) => f.length > 0);
+}
+async function getUnstagedFiles(cwd) {
+  const files = await parseStatus(cwd);
+  return files.filter(
+    (f) => f.indexStatus === "?" && f.workTreeStatus === "?" || f.workTreeStatus !== " "
+  );
+}
+async function getLatestTag(cwd) {
+  try {
+    return await run(["describe", "--tags", "--abbrev=0"], cwd);
+  } catch {
+    return null;
+  }
+}
+async function createTag(cwd, tag, message, options) {
+  const flag = options?.signed === true ? "-s" : "-a";
+  await run(["tag", flag, tag, "-m", message], cwd);
+}
+async function tagExists(cwd, tag) {
+  try {
+    await exec("git", ["rev-parse", "--verify", "--quiet", `refs/tags/${tag}`], {
+      cwd,
+      timeout: GIT_TIMEOUT_MS
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function pushWithTags(cwd, remote, branch) {
+  await run(["push", remote, branch, "--follow-tags"], cwd);
+}
+async function mergeNoFf(cwd, source) {
+  await run(["merge", "--no-ff", source], cwd);
+}
+async function branchExists(cwd, branch) {
+  try {
+    await exec(
+      "git",
+      ["show-ref", "--verify", "--quiet", `refs/heads/${branch}`],
+      { cwd, timeout: GIT_TIMEOUT_MS, maxBuffer: GIT_MAX_BUFFER }
+    );
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function headSha(cwd) {
+  return run(["rev-parse", "HEAD"], cwd);
+}
+async function resetSoft(cwd, ref) {
+  await run(["reset", "--soft", ref], cwd);
+}
+async function stashPushNamed(cwd, message) {
+  await run(["stash", "push", "--include-untracked", "-m", message], cwd);
+}
+async function stashList(cwd) {
+  return run(["stash", "list"], cwd);
+}
+async function findStashRef(cwd, stashName) {
+  const list = await stashList(cwd);
+  const line = list.split("\n").find((l) => l.includes(stashName));
+  if (!line) {
+    throw new GitwiseError({
+      code: "GIT_FAILED",
+      message: `Named stash not found in stash list: ${stashName}`,
+      details: { stashName }
+    });
+  }
+  const match = /^(stash@\{\d+\})/.exec(line);
+  if (!match?.[1]) {
+    throw new GitwiseError({
+      code: "GIT_FAILED",
+      message: `Cannot parse stash ref from stash list line: ${line}`,
+      details: { stashName, line }
+    });
+  }
+  return match[1];
+}
+async function stashApplyNamed(cwd, stashName) {
+  const ref = await findStashRef(cwd, stashName);
+  await run(["stash", "apply", ref], cwd);
+}
+async function stashPopNamed(cwd, stashName) {
+  const ref = await findStashRef(cwd, stashName);
+  await run(["stash", "pop", ref], cwd);
+}
+async function stashDropNamed(cwd, stashName) {
+  const ref = await findStashRef(cwd, stashName);
+  await run(["stash", "drop", ref], cwd);
+}
+async function cleanForced(cwd) {
+  await run(["clean", "-fd"], cwd);
+}
+async function showFileAtHead(cwd, path3) {
+  debug("git command", { args: ["show", `HEAD:${path3}`], cwd });
+  try {
+    const result = await exec("git", ["show", `HEAD:${path3}`], {
+      cwd,
+      timeout: GIT_TIMEOUT_MS,
+      maxBuffer: GIT_MAX_BUFFER
+    });
+    return result.stdout;
+  } catch {
+    return null;
+  }
+}
+async function deleteBranch(cwd, branch, force = false) {
+  await run(["branch", force ? "-D" : "-d", branch], cwd);
+}
+async function isBranchMerged(cwd, branch, target) {
+  try {
+    await exec(
+      "git",
+      ["merge-base", "--is-ancestor", branch, target],
+      { cwd, timeout: GIT_TIMEOUT_MS, maxBuffer: GIT_MAX_BUFFER }
+    );
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function detectBaseBranch(cwd) {
+  try {
+    await exec("git", ["rev-parse", "--verify", "main"], { cwd, timeout: GIT_TIMEOUT_MS });
+    return "main";
+  } catch {
+  }
+  try {
+    await exec("git", ["rev-parse", "--verify", "master"], { cwd, timeout: GIT_TIMEOUT_MS });
+    return "master";
+  } catch {
+  }
+  throw new GitwiseError({
+    code: "NO_BASE_BRANCH",
+    message: "No base branch found: neither main nor master exists",
+    exitCode: EXIT_CODES.REPO_STATE_INVALID
+  });
+}
+async function applyCommit(params) {
+  const { message, files, cwd } = params;
+  try {
+    if (files.length > 0) {
+      await add(cwd, files);
+    }
+    await commit(cwd, message);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    const stderr = execStderr(err);
+    throw new GitwiseError({
+      code: "COMMIT_HOOK_FAILURE",
+      message: `Git commit failed: ${msg}`,
+      exitCode: EXIT_CODES.GIT_FAILED,
+      cause: err,
+      details: stderr !== void 0 ? { stderr } : void 0
+    });
+  }
+}
+
+// src/infra/github.ts
+var github_exports = {};
+__export(github_exports, {
+  createGitHubRelease: () => createGitHubRelease,
+  createPR: () => createPR,
+  getGhVersion: () => getGhVersion,
+  getPrUrl: () => getPrUrl,
+  isGhAvailable: () => isGhAvailable,
+  openPr: () => openPr,
+  updatePR: () => updatePR
+});
+import { execFile as execFile2 } from "child_process";
+import { promisify as promisify2 } from "util";
+var exec2 = promisify2(execFile2);
+async function isGhAvailable() {
+  try {
+    await exec2("gh", ["--version"]);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function getGhVersion() {
+  try {
+    const result = await exec2("gh", ["--version"]);
+    const firstLine = result.stdout.split("\n")[0] ?? "";
+    return firstLine.trim() || null;
+  } catch {
+    return null;
+  }
+}
+async function createPR(params) {
+  debug("Creating PR via gh", { title: params.title });
+  const args = ["pr", "create", "--title", params.title, "--body", params.body];
+  if (params.base) {
+    args.push("--base", params.base);
+  }
+  if (params.draft) {
+    args.push("--draft");
+  }
+  const result = await exec2("gh", args, { cwd: params.cwd });
+  const url = result.stdout?.trim();
+  if (!url) {
+    throw new GitwiseError({
+      code: "GH_FAILED",
+      message: "gh pr create returned empty output \u2014 check gh auth status",
+      details: { command: "gh pr create" }
+    });
+  }
+  return { url };
+}
+async function updatePR(params) {
+  debug("Updating PR via gh", { prNumber: params.prNumber });
+  const args = ["pr", "edit", String(params.prNumber)];
+  if (params.title) args.push("--title", params.title);
+  if (params.body) args.push("--body", params.body);
+  await exec2("gh", args, { cwd: params.cwd });
+  const url = await getPrUrl(params.prNumber, params.cwd);
+  return { url };
+}
+async function getPrUrl(prNumber, cwd) {
+  const result = await exec2(
+    "gh",
+    ["pr", "view", String(prNumber), "--json", "url", "-q", ".url"],
+    { cwd }
+  );
+  const url = result.stdout?.trim();
+  if (!url) {
+    throw new GitwiseError({
+      code: "GH_FAILED",
+      message: `gh pr view ${prNumber} returned empty output \u2014 check gh auth status`,
+      details: { command: `gh pr view ${prNumber}` }
+    });
+  }
+  return url;
+}
+async function createGitHubRelease(params) {
+  debug("Creating GitHub release via gh", { tag: params.tag });
+  const args = [
+    "release",
+    "create",
+    params.tag,
+    "--title",
+    params.title,
+    "--notes",
+    params.body
+  ];
+  const result = await exec2("gh", args, { cwd: params.cwd });
+  const url = result.stdout?.trim();
+  if (!url) {
+    throw new GitwiseError({
+      code: "GH_FAILED",
+      message: "gh release create returned empty output \u2014 check gh auth status",
+      details: { command: "gh release create" }
+    });
+  }
+  return { url };
+}
+var openPr = createPR;
+
+// src/infra/env.ts
+var env_exports = {};
+__export(env_exports, {
+  loadEnv: () => loadEnv,
+  read: () => read,
+  readEnvVar: () => readEnvVar,
+  writeEnvVar: () => writeEnvVar
+});
+import { readFile as readFile2, open, rename, unlink } from "fs/promises";
+import { join } from "path";
+var ENV_DIR = ".gitwise";
+var ENV_FILE = ".env";
+function getEnvPath(projectRoot) {
+  return join(projectRoot, ENV_DIR, ENV_FILE);
+}
+function parseLine(line) {
+  const trimmed = line.trim();
+  if (!trimmed || trimmed.startsWith("#")) return null;
+  const eq = trimmed.indexOf("=");
+  if (eq < 1) return null;
+  return [trimmed.slice(0, eq).trim(), trimmed.slice(eq + 1).trim()];
+}
+async function loadEnv(projectRoot) {
+  const envPath = getEnvPath(projectRoot);
+  if (!await fileExists(envPath)) return;
+  const content = await readFile2(envPath, "utf-8");
+  for (const line of content.split("\n")) {
+    const parsed = parseLine(line);
+    if (!parsed) continue;
+    const [key, value] = parsed;
+    if (process.env[key] === void 0) {
+      process.env[key] = value;
+    }
+  }
+}
+async function writeEnvVar(projectRoot, key, value) {
+  const envPath = getEnvPath(projectRoot);
+  await ensureDir(join(projectRoot, ENV_DIR));
+  let lines = [];
+  if (await fileExists(envPath)) {
+    const content = await readFile2(envPath, "utf-8");
+    lines = content.split("\n");
+  }
+  const prefix = `${key}=`;
+  const idx = lines.findIndex((l) => l.trim().startsWith(prefix));
+  const entry = `${key}=${value}`;
+  if (idx >= 0) {
+    lines[idx] = entry;
+  } else {
+    if (lines.length === 1 && lines[0] === "") {
+      lines[0] = entry;
+    } else {
+      lines.push(entry);
+    }
+  }
+  const final = lines.join("\n").replace(/\n{3,}/g, "\n\n");
+  const payload = final.endsWith("\n") ? final : final + "\n";
+  const tmpPath = `${envPath}.${process.pid}.${Date.now()}.tmp`;
+  const fd = await open(tmpPath, "w", 384);
+  try {
+    await fd.writeFile(payload, "utf-8");
+  } finally {
+    await fd.close();
+  }
+  try {
+    await rename(tmpPath, envPath);
+  } catch (err) {
+    await unlink(tmpPath).catch(() => void 0);
+    throw err;
+  }
+}
+async function readEnvVar(projectRoot, key) {
+  const envPath = getEnvPath(projectRoot);
+  if (!await fileExists(envPath)) return void 0;
+  const content = await readFile2(envPath, "utf-8");
+  for (const line of content.split("\n")) {
+    const parsed = parseLine(line);
+    if (parsed && parsed[0] === key) return parsed[1];
+  }
+  return void 0;
+}
+async function read(key, projectRoot) {
+  if (process.env[key] !== void 0) {
+    return process.env[key];
+  }
+  if (projectRoot) {
+    return readEnvVar(projectRoot, key);
+  }
+  return void 0;
+}
+
+// src/infra/transaction.ts
+var Transaction = class {
+  applied = [];
+  async run(step) {
+    const result = await step.apply();
+    this.applied.push({ step, result });
+    return result;
+  }
+  get size() {
+    return this.applied.length;
+  }
+  async rollback(reason, logger) {
+    const failures = [];
+    for (const { step, result } of [...this.applied].reverse()) {
+      try {
+        await step.compensate(result);
+      } catch (err) {
+        failures.push({ step: step.name, error: err });
+        logger.warn("compensate-failed", {
+          step: step.name,
+          reason: serializeError(err)
+        });
+      }
+    }
+    if (failures.length > 0) {
+      logger.warn("rollback partial: one or more compensate actions failed", {
+        code: "ROLLBACK_PARTIAL",
+        originalCode: reason.code,
+        failures: failures.map((f) => ({
+          step: f.step,
+          error: serializeError(f.error)
+        }))
+      });
+    }
+    return { partial: failures.length > 0, failures };
+  }
+};
+function serializeError(err) {
+  if (err instanceof Error) {
+    return { name: err.name, message: err.message };
+  }
+  return err;
+}
+
+// src/infra/lockfile.ts
+import { mkdir as mkdir2, open as open2, readFile as readFile3, unlink as unlink2 } from "fs/promises";
+import { hostname } from "os";
+import path from "path";
+var STALE_LOCK_MS = 10 * 60 * 1e3;
+async function acquireRepoLock(repoPath, options = {}) {
+  const command = options.command ?? "unknown";
+  const staleMs = options.staleMs ?? STALE_LOCK_MS;
+  const isAlive = options.isProcessAlive ?? defaultIsProcessAlive;
+  const now = options.now ?? (() => /* @__PURE__ */ new Date());
+  const dir = path.join(repoPath, ".gitwise");
+  const lockPath = path.join(dir, ".lock");
+  await mkdir2(dir, { recursive: true });
+  const payload = {
+    pid: process.pid,
+    host: hostname(),
+    command,
+    acquiredAt: now().toISOString()
+  };
+  await tryAcquire(lockPath, payload, staleMs, isAlive, now, 0, options.onReclaim);
+  let released = false;
+  return async () => {
+    if (released) return;
+    released = true;
+    try {
+      await unlink2(lockPath);
+    } catch (err) {
+      if (err.code !== "ENOENT") throw err;
+    }
+  };
+}
+async function tryAcquire(lockPath, payload, staleMs, isAlive, now, attempt, onReclaim) {
+  try {
+    const handle = await open2(lockPath, "wx");
+    try {
+      await handle.writeFile(JSON.stringify(payload, null, 2) + "\n", "utf-8");
+    } finally {
+      await handle.close();
+    }
+    return;
+  } catch (err) {
+    if (err.code !== "EEXIST") throw err;
+  }
+  if (attempt >= 1) {
+    throw new GitwiseError({
+      code: "REPO_LOCKED",
+      message: "Another gitwise process holds the lock on this repository",
+      details: { lockPath }
+    });
+  }
+  const existing = await readExisting(lockPath);
+  if (existing && !isStale(existing, staleMs, isAlive, now)) {
+    throw new GitwiseError({
+      code: "REPO_LOCKED",
+      message: `gitwise lock held by pid ${existing.pid} (command: ${existing.command}) since ${existing.acquiredAt}`,
+      details: { existing, lockPath }
+    });
+  }
+  try {
+    await unlink2(lockPath);
+  } catch (unlinkErr) {
+    if (unlinkErr.code !== "ENOENT") throw unlinkErr;
+  }
+  if (onReclaim) await onReclaim();
+  return tryAcquire(lockPath, payload, staleMs, isAlive, now, attempt + 1, onReclaim);
+}
+async function readExisting(lockPath) {
+  try {
+    const content = await readFile3(lockPath, "utf-8");
+    const parsed = JSON.parse(content);
+    if (typeof parsed.pid !== "number" || typeof parsed.host !== "string" || typeof parsed.command !== "string" || typeof parsed.acquiredAt !== "string") {
+      return null;
+    }
+    return {
+      pid: parsed.pid,
+      host: parsed.host,
+      command: parsed.command,
+      acquiredAt: parsed.acquiredAt
+    };
+  } catch {
+    return null;
+  }
+}
+function isStale(existing, staleMs, isAlive, now) {
+  if (!isAlive(existing.pid)) return true;
+  const acquiredAt = Date.parse(existing.acquiredAt);
+  if (Number.isNaN(acquiredAt)) return true;
+  const age = now().getTime() - acquiredAt;
+  return age > staleMs;
+}
+function defaultIsProcessAlive(pid) {
+  if (!Number.isInteger(pid) || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    const code = err.code;
+    if (code === "ESRCH") return false;
+    if (code === "EPERM") return true;
+    return false;
+  }
+}
+
+// src/providers/claude-code.ts
+import { execFile as execFile3, execSync, spawn } from "child_process";
+import fs from "fs";
+import os from "os";
+import path2 from "path";
+import { promisify as promisify3 } from "util";
+var execFileAsync = promisify3(execFile3);
+var LARGE_PROMPT_THRESHOLD = 1e5;
+var DEFAULT_TIMEOUT_MS = 12e4;
+var COMMON_CLAUDE_PATHS = [
+  // Native installs (Homebrew, manual) — preferred over npm
+  "/opt/homebrew/bin/claude",
+  "/usr/local/bin/claude",
+  path2.join(os.homedir(), ".claude", "local", "claude"),
+  // npm global installs — fallback
+  path2.join(os.homedir(), ".npm-global", "bin", "claude")
+];
+function isExecutable(filePath) {
+  try {
+    fs.accessSync(filePath, fs.constants.X_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function resolveClaudeBinary(customPath) {
+  if (customPath) {
+    if (isExecutable(customPath)) return customPath;
+    return null;
+  }
+  for (const candidate of COMMON_CLAUDE_PATHS) {
+    if (isExecutable(candidate)) return candidate;
+  }
+  try {
+    const found = execSync("which claude", { stdio: "pipe" }).toString().trim();
+    if (found && isExecutable(found)) return found;
+  } catch {
+  }
+  const nvmDir = path2.join(os.homedir(), ".nvm", "versions", "node");
+  try {
+    const versions = fs.readdirSync(nvmDir);
+    for (const version2 of versions) {
+      const candidate = path2.join(nvmDir, version2, "bin", "claude");
+      if (isExecutable(candidate)) return candidate;
+    }
+  } catch {
+  }
+  return null;
+}
+var ClaudeCodeProvider = class {
+  models;
+  claudeBinaryPath;
+  constructor(models, claudeCliPath) {
+    this.models = models;
+    this.claudeBinaryPath = claudeCliPath ?? resolveClaudeBinary() ?? "claude";
+  }
+  async chat(req) {
+    const modelId = this.resolveModel(req.tier);
+    debug("Calling Claude Code CLI", { model: modelId, tier: req.tier, binary: this.claudeBinaryPath });
+    const userContent = req.userMessage;
+    const args = this.buildArgs(req.systemPrompt, modelId, userContent);
+    const result = userContent.length > LARGE_PROMPT_THRESHOLD ? await this.callViaStdin(args, userContent) : await this.callViaCli(args);
+    return {
+      content: result.result,
+      tokens: {
+        input: result.usage.input_tokens,
+        output: result.usage.output_tokens
+      }
+    };
+  }
+  buildArgs(systemPrompt, modelId, userContent) {
+    const args = [
+      "-p",
+      ...userContent.length <= LARGE_PROMPT_THRESHOLD ? [userContent] : [],
+      "--system-prompt",
+      systemPrompt,
+      "--model",
+      modelId,
+      "--output-format",
+      "json"
+    ];
+    return args;
+  }
+  async callViaCli(args) {
+    try {
+      const { stdout } = await execFileAsync(this.claudeBinaryPath, args, {
+        timeout: DEFAULT_TIMEOUT_MS,
+        maxBuffer: 10 * 1024 * 1024,
+        ...{ input: "" }
+      });
+      return this.parseResponse(stdout);
+    } catch (err) {
+      const execErr = err;
+      if (execErr.stdout) {
+        try {
+          const parsed = JSON.parse(execErr.stdout);
+          if (parsed.is_error) {
+            throw new Error(`Claude CLI error: ${parsed.result}`);
+          }
+        } catch (parseErr) {
+          if (parseErr instanceof Error && parseErr.message.startsWith("Claude CLI error:")) {
+            throw parseErr;
+          }
+        }
+      }
+      const stderr = execErr.stderr?.replace(/Warning: no stdin data.*\n?/g, "").trim();
+      if (stderr) {
+        throw new Error(`Claude CLI failed: ${stderr}`);
+      }
+      throw this.wrapError(err);
+    }
+  }
+  async callViaStdin(args, input) {
+    return new Promise((resolve, reject) => {
+      const child = spawn(this.claudeBinaryPath, args, {
+        stdio: ["pipe", "pipe", "pipe"],
+        timeout: DEFAULT_TIMEOUT_MS
+      });
+      let stdout = "";
+      let stderr = "";
+      child.stdout.on("data", (data) => {
+        stdout += data.toString();
+      });
+      child.stderr.on("data", (data) => {
+        stderr += data.toString();
+      });
+      child.on("close", (code) => {
+        if (code !== 0) {
+          if (stdout) {
+            try {
+              const parsed = JSON.parse(stdout);
+              if (parsed.is_error) {
+                reject(new Error(`Claude CLI error: ${parsed.result}`));
+                return;
+              }
+            } catch {
+            }
+          }
+          const filteredStderr = stderr.replace(/Warning: no stdin data.*\n?/g, "").trim();
+          reject(
+            new Error(
+              `Claude CLI exited with code ${code}${filteredStderr ? `: ${filteredStderr}` : ""}`
+            )
+          );
+          return;
+        }
+        try {
+          resolve(this.parseResponse(stdout));
+        } catch (err) {
+          reject(err);
+        }
+      });
+      child.on("error", (err) => {
+        reject(this.wrapError(err));
+      });
+      child.stdin.write(input);
+      child.stdin.end();
+    });
+  }
+  parseResponse(stdout) {
+    const parsed = JSON.parse(stdout);
+    if (parsed.is_error) {
+      throw new Error(`Claude CLI returned error: ${parsed.result}`);
+    }
+    const usage = { input_tokens: 0, output_tokens: 0 };
+    if (parsed.usage) {
+      usage.input_tokens = parsed.usage.input_tokens ?? 0;
+      usage.output_tokens = parsed.usage.output_tokens ?? 0;
+    }
+    return {
+      result: parsed.result ?? "",
+      is_error: false,
+      usage
+    };
+  }
+  resolveModel(tier) {
+    return this.models[tier];
+  }
+  wrapError(err) {
+    if (err instanceof Error) {
+      if (err.message.includes("ENOENT")) {
+        return new GitwiseError({
+          code: "PROVIDER_UNAVAILABLE",
+          message: `Claude Code CLI not found at "${this.claudeBinaryPath}". Re-run \`gw config\` to reconfigure.`,
+          exitCode: EXIT_CODES.API_FAILED,
+          cause: err
+        });
+      }
+      return err;
+    }
+    return new Error(String(err));
+  }
+};
+
+// src/config/types.ts
+var DEFAULT_USER_CONFIG = {
+  provider: "api",
+  models: {
+    fast: "claude-haiku-4-5-20251001",
+    balanced: "claude-sonnet-4-6",
+    powerful: "claude-opus-4-7"
+  },
+  language: "en",
+  commitConvention: "conventional"
+};
+
+// src/config/merge.ts
+import os3 from "os";
+
+// src/config/user.ts
+import { join as join2 } from "path";
+import os2 from "os";
+var GITWISE_DIR = ".gitwise";
+var USER_CONFIG_FILE = "config.json";
+function getUserConfigPath(homeDir) {
+  return join2(homeDir ?? os2.homedir(), GITWISE_DIR, USER_CONFIG_FILE);
+}
+function mergeWithDefaults(partial) {
+  return {
+    ...DEFAULT_USER_CONFIG,
+    ...partial,
+    models: {
+      ...DEFAULT_USER_CONFIG.models,
+      ...partial.models ?? {}
+    }
+  };
+}
+async function readUserConfig(homeDir) {
+  const configPath = getUserConfigPath(homeDir);
+  if (!await fileExists(configPath)) {
+    debug("User config not found, using defaults", { path: configPath });
+    return { ...DEFAULT_USER_CONFIG };
+  }
+  const raw = await readJSON(configPath);
+  return mergeWithDefaults(raw);
+}
+async function writeUserConfig(partial, homeDir) {
+  const configPath = getUserConfigPath(homeDir);
+  const existing = await readUserConfig(homeDir);
+  const updated = mergeWithDefaults({ ...existing, ...partial });
+  debug("Writing user config", { path: configPath });
+  await writeJSON(configPath, updated);
+}
+async function writeApiKey(value, homeDir) {
+  const home = homeDir ?? os2.homedir();
+  await writeEnvVar(home, "ANTHROPIC_API_KEY", value);
+}
+
+// src/config/repo.ts
+import { join as join3 } from "path";
+var REPO_CONFIG_FILE = ".gitwise.json";
+async function readRepoConfig(cwd) {
+  const configPath = join3(cwd, REPO_CONFIG_FILE);
+  if (!await fileExists(configPath)) {
+    debug("Repo config not found", { path: configPath });
+    return null;
+  }
+  try {
+    const raw = await readJSON(configPath);
+    return raw;
+  } catch (err) {
+    throw new GitwiseError({
+      code: "INVALID_REPO_CONFIG",
+      message: `Invalid repo config at ${configPath}: ${err instanceof Error ? err.message : String(err)}`,
+      exitCode: EXIT_CODES.CONFIG_INVALID,
+      cause: err
+    });
+  }
+}
+
+// src/config/merge.ts
+function deepMerge(base, override) {
+  return {
+    ...base,
+    ...override.language !== void 0 && { language: override.language },
+    ...override.defaultBaseBranch !== void 0 && { defaultBaseBranch: override.defaultBaseBranch },
+    ...override.commitConvention !== void 0 && { commitConvention: override.commitConvention },
+    ...override.templatesPath !== void 0 && { templatesPath: override.templatesPath },
+    ...override.releaseStrategy !== void 0 && { releaseStrategy: override.releaseStrategy },
+    ...override.developBranch !== void 0 && { developBranch: override.developBranch },
+    models: {
+      ...base.models,
+      ...override.models ?? {}
+    }
+  };
+}
+async function getMergedConfig(options) {
+  const { cwd, homeDir } = options;
+  const userConfig = await readUserConfig(homeDir);
+  const repoConfig = await readRepoConfig(cwd);
+  if (!repoConfig) {
+    return userConfig;
+  }
+  return deepMerge(userConfig, repoConfig);
+}
+async function getApiKey(homeDir) {
+  const home = homeDir ?? os3.homedir();
+  return read("ANTHROPIC_API_KEY", home);
+}
+
+// src/template/loader.ts
+import { readFile as readFile4 } from "fs/promises";
+import { dirname as dirname2, join as join4 } from "path";
+import { fileURLToPath } from "url";
+import os4 from "os";
+
+// src/template/interpolate.ts
+function interpolate(template, ctx) {
+  return template.replace(
+    /\{\{(\w+)\}\}/g,
+    (_match, key) => ctx[key] ?? _match
+  );
+}
+
+// src/template/loader.ts
+var __dirname2 = dirname2(fileURLToPath(import.meta.url));
+var BUNDLED_TEMPLATES_CANDIDATES = [
+  join4(__dirname2, "..", "templates"),
+  join4(__dirname2, "..", "..", "templates")
+];
+function validateTemplateName(name) {
+  if (!/^[a-zA-Z0-9_-]+$/.test(name)) {
+    throw new GitwiseError({
+      code: "TEMPLATE_INVALID_NAME",
+      message: `Invalid template name: '${name}'. Only alphanumeric characters, hyphens, and underscores are allowed.`,
+      exitCode: EXIT_CODES.CONFIG_INVALID
+    });
+  }
+}
+async function loadTemplate(name, options = {}) {
+  validateTemplateName(name);
+  const repoRoot = options.repoRoot ?? process.cwd();
+  const userTemplatesPath = options.templatesPath ?? join4(os4.homedir(), ".gitwise", "templates");
+  const repoOverride = join4(repoRoot, ".gitwise", "templates", `${name}.md`);
+  if (await fileExists(repoOverride)) {
+    debug("Loading repo-level template override", { path: repoOverride });
+    return readFile4(repoOverride, "utf-8");
+  }
+  const userOverride = join4(userTemplatesPath, `${name}.md`);
+  if (await fileExists(userOverride)) {
+    debug("Loading user-global template override", { path: userOverride });
+    return readFile4(userOverride, "utf-8");
+  }
+  for (const candidate of BUNDLED_TEMPLATES_CANDIDATES) {
+    const bundled = join4(candidate, `${name}.md`);
+    if (await fileExists(bundled)) {
+      debug("Loading bundled template", { path: bundled });
+      return readFile4(bundled, "utf-8");
+    }
+  }
+  throw new GitwiseError({
+    code: "TEMPLATE_NOT_FOUND",
+    message: `Template '${name}' not found`,
+    exitCode: EXIT_CODES.CONFIG_INVALID
+  });
+}
+async function loadAndInterpolate(name, ctx, options = {}) {
+  const template = await loadTemplate(name, options);
+  return interpolate(template, ctx);
+}
+
+// src/providers/model-router.ts
+var COMMAND_TIER_MAP = {
+  commit: "fast",
+  review: "powerful",
+  pr: "fast",
+  release: "fast"
+};
+function resolveModelTier(command) {
+  return COMMAND_TIER_MAP[command] ?? "balanced";
+}
+var SUPPORTED_COMMANDS = Object.keys(COMMAND_TIER_MAP);
+
+// src/commands/commit.ts
+var SENSITIVE_PATTERNS = [
+  /^\.env$/,
+  /^\.env\./,
+  /\.pem$/,
+  /\.key$/,
+  /^id_rsa/,
+  /^id_dsa/,
+  /^id_ecdsa/,
+  /^id_ed25519/,
+  /credentials\.json$/,
+  /secrets\.json$/,
+  /auth\.json$/,
+  /service-account\.json$/,
+  /\.p12$/,
+  /\.pfx$/,
+  /\.pkcs12$/
+];
+var SAFE_ENV_TEMPLATE_SUFFIXES = [
+  ".example",
+  ".sample",
+  ".template",
+  ".dist",
+  ".defaults"
+];
+function isSafeEnvTemplate(basename) {
+  if (!basename.startsWith(".env")) return false;
+  return SAFE_ENV_TEMPLATE_SUFFIXES.some((suffix) => basename.endsWith(suffix));
+}
+function isSensitiveFile(filePath) {
+  const basename = filePath.split("/").pop() ?? filePath;
+  if (isSafeEnvTemplate(basename)) return false;
+  return SENSITIVE_PATTERNS.some((pattern) => pattern.test(basename));
+}
+function tryParseJson(text) {
+  try {
+    const parsed = JSON.parse(text.trim());
+    if (parsed.type === "plan" && Array.isArray(parsed.commits)) {
+      return parsed;
+    }
+    if (parsed.type === "single" && typeof parsed.message === "string") {
+      return parsed;
+    }
+  } catch {
+  }
+  return null;
+}
+function extractBalancedJsonCandidates(raw) {
+  const candidates = [];
+  const stack = [];
+  let inString = false;
+  let escape = false;
+  for (let i = 0; i < raw.length; i++) {
+    const c = raw[i];
+    if (inString) {
+      if (escape) {
+        escape = false;
+      } else if (c === "\\") {
+        escape = true;
+      } else if (c === '"') {
+        inString = false;
+      }
+      continue;
+    }
+    if (c === '"') {
+      inString = true;
+      continue;
+    }
+    if (c === "{") {
+      stack.push(i);
+    } else if (c === "}") {
+      const start = stack.pop();
+      if (start !== void 0) {
+        candidates.push(raw.slice(start, i + 1));
+      }
+    }
+  }
+  return candidates;
+}
+function parseAlternativesResponse(raw) {
+  const isValid = (p) => typeof p === "object" && p !== null && p["type"] === "alternatives" && Array.isArray(p["options"]) && p["options"].length > 0 && p["options"].every((o) => typeof o === "string");
+  try {
+    const parsed = JSON.parse(raw.trim());
+    if (isValid(parsed)) return parsed.options;
+  } catch {
+  }
+  const fence = raw.match(/```(?:json)?\s*([\s\S]*?)```/);
+  if (fence?.[1]) {
+    try {
+      const parsed = JSON.parse(fence[1].trim());
+      if (isValid(parsed)) return parsed.options;
+    } catch {
+    }
+  }
+  for (const line of raw.split("\n")) {
+    const t = line.trim();
+    if (!t.startsWith("{")) continue;
+    try {
+      const parsed = JSON.parse(t);
+      if (isValid(parsed)) return parsed.options;
+    } catch {
+    }
+  }
+  return null;
+}
+function parseCommitResponse(raw) {
+  const direct = tryParseJson(raw);
+  if (direct) return direct;
+  const fenceMatch = raw.match(/```json?\s*\n?([\s\S]*?)```/);
+  if (fenceMatch?.[1]) {
+    const fromFence = tryParseJson(fenceMatch[1]);
+    if (fromFence) return fromFence;
+  }
+  const candidates = extractBalancedJsonCandidates(raw);
+  const parsedCandidates = candidates.map(tryParseJson).filter((p) => p !== null);
+  const plan = parsedCandidates.find((p) => p.type === "plan");
+  if (plan) return plan;
+  if (parsedCandidates[0]) return parsedCandidates[0];
+  return { type: "single", message: raw.trim() };
+}
+var MAX_DIFF_CHARS = 8e4;
+function truncateDiff(diff) {
+  if (diff.length <= MAX_DIFF_CHARS) return diff;
+  return diff.slice(0, MAX_DIFF_CHARS) + "\n\n[diff truncated \u2014 too large for context window]";
+}
+var SYSTEM_PROMPT = `You are a developer writing commit messages. Analyze the git diff and the list of staged files to determine if the changes span one or multiple contexts.
+
+Rules for commit messages:
+- Format: type(scope): description
+- Types: feat, fix, refactor, test, chore, style, docs
+- Description must be imperative, lowercase, max 72 chars
+- Scope is optional but recommended
+- Do NOT mention AI, Claude, generated, LLM, or copilot
+
+Response format (JSON only, no extra text):
+
+If all changes belong to a SINGLE context, return:
+{"type": "single", "message": "type(scope): description"}
+
+If changes span MULTIPLE distinct contexts (e.g., a bug fix AND a new feature, or docs AND refactoring), return:
+{"type": "plan", "commits": [{"message": "type(scope): short title", "description": "brief explanation of what and why", "files": ["file1.ts"]}, {"message": "type(scope): short title", "description": "brief explanation of what and why", "files": ["file3.ts"]}]}
+
+Rules for plan:
+- "message" is the commit title (max 72 chars, imperative, lowercase)
+- "description" is a brief one-line explanation of the change purpose
+- "files" lists only the files belonging to that commit
+- Every staged file must appear in exactly one commit \u2014 do not leave any file unassigned
+- Only return a plan when there are clearly separate concerns. Do not split for minor differences.`;
+async function commit2(opts) {
+  const { cwd, provider, prompt, split = "auto" } = opts;
+  const stagedFiles = await getStagedFilesList(cwd);
+  const diff = await getStagedDiff(cwd);
+  if (!diff) {
+    throw new GitwiseError({
+      code: "NOTHING_STAGED",
+      message: "No staged changes to commit"
+    });
+  }
+  const sensitiveFiles = stagedFiles.filter(isSensitiveFile);
+  if (sensitiveFiles.length > 0) {
+    debug("Sensitive files blocked from commit", { files: sensitiveFiles });
+    throw new GitwiseError({
+      code: "SENSITIVE_FILE_BLOCKED",
+      message: `SENSITIVE_FILE_BLOCKED: ${sensitiveFiles.length} file(s) matched sensitive patterns (env/pem/credentials). Re-run with --debug (or set GITWISE_DEBUG=1) to see which files were flagged.`,
+      details: { files: sensitiveFiles }
+    });
+  }
+  let systemPrompt = SYSTEM_PROMPT;
+  try {
+    const templateContent = await loadTemplate("commit", {
+      repoRoot: opts.repoRoot ?? cwd,
+      templatesPath: opts.templatesPath
+    });
+    if (templateContent && !templateContent.includes("{{type}}")) {
+      systemPrompt = templateContent;
+    }
+  } catch {
+  }
+  const effectiveSystemPrompt = opts.generateAlternatives ? `${systemPrompt}
+
+When asked to generate alternatives, return ONLY this JSON (no other text):
+{"type": "alternatives", "options": ["message1", "message2", "message3"]}` : systemPrompt;
+  const userMessage = [
+    `Staged files:
+${stagedFiles.join("\n")}`,
+    `
+Diff:
+${truncateDiff(diff)}`,
+    prompt ? `
+User intent: ${prompt}` : "",
+    opts.feedbackHint ? `
+User feedback on previous suggestion: ${opts.feedbackHint}` : "",
+    opts.generateAlternatives ? `
+IMPORTANT: Generate exactly 3 different alternative commit messages. Return JSON only: {"type": "alternatives", "options": ["message1", "message2", "message3"]}` : ""
+  ].join("");
+  debug("Calling LLM for commit analysis", { tier: "fast", fileCount: stagedFiles.length });
+  const tier = resolveModelTier("commit");
+  const response = await provider.chat({ systemPrompt: effectiveSystemPrompt, userMessage, tier });
+  const parsed = parseCommitResponse(response.content);
+  const tokens = { input: response.tokens.input, output: response.tokens.output };
+  if (opts.generateAlternatives) {
+    const options = parseAlternativesResponse(response.content);
+    if (options && options.length > 0) {
+      return { kind: "alternatives", options, tokens };
+    }
+    const fallbackMsg = parsed.type === "single" ? parsed.message : parsed.commits[0]?.message ?? response.content.trim().slice(0, 100);
+    return { kind: "alternatives", options: [fallbackMsg], tokens };
+  }
+  if (split === "never") {
+    const message2 = parsed.type === "single" ? parsed.message : parsed.commits.map((c) => c.message).join("\n\n");
+    return {
+      kind: "single",
+      commits: [{ message: message2, files: stagedFiles }],
+      tokens
+    };
+  }
+  if (parsed.type === "plan" && parsed.commits.length > 1) {
+    if (split === "always" || split === "auto") {
+      const assignedFiles = new Set(parsed.commits.flatMap((c) => c.files));
+      const missing = stagedFiles.filter((f) => !assignedFiles.has(f));
+      if (missing.length > 0) {
+        parsed.commits[parsed.commits.length - 1].files.push(...missing);
+      }
+      return {
+        kind: "split",
+        commits: parsed.commits,
+        tokens
+      };
+    }
+  }
+  if (split === "always" && parsed.type !== "plan") {
+    throw new GitwiseError({
+      code: "NO_SPLIT_POSSIBLE",
+      message: "split: 'always' requested but LLM returned a single-context plan",
+      exitCode: EXIT_CODES.INVALID_INTENT
+    });
+  }
+  const message = parsed.type === "single" ? parsed.message : parsed.commits[0]?.message ?? "chore: update";
+  return {
+    kind: "single",
+    commits: [{ message, files: stagedFiles }],
+    tokens
+  };
+}
+function takeNamedStashStep(cwd, stashName) {
+  return {
+    name: `takeNamedStash(${stashName})`,
+    async apply() {
+      await stashPushNamed(cwd, stashName);
+      await stashApplyNamed(cwd, stashName);
+    },
+    async compensate() {
+      await resetHard(cwd, "HEAD");
+      await cleanForced(cwd);
+      await stashPopNamed(cwd, stashName);
+    }
+  };
+}
+function applyOneCommitStep(entry, cwd, stagedTree) {
+  const msg = entry.description ? `${entry.message}
+
+${entry.description}` : entry.message;
+  return {
+    name: `applyCommit(${entry.message})`,
+    async apply() {
+      const priorSha = await headSha(cwd);
+      await stagePathsFromTree(cwd, stagedTree, entry.files);
+      const staged = await getStagedFilesList(cwd);
+      if (staged.length === 0) {
+        debug("Skipping commit group with no staged changes", {
+          message: entry.message,
+          files: entry.files
+        });
+        return { priorSha, newSha: priorSha };
+      }
+      await applyCommit({ message: msg, files: [], cwd });
+      const newSha = await headSha(cwd);
+      return { priorSha, newSha };
+    },
+    async compensate({ priorSha }) {
+      await resetSoft(cwd, priorSha);
+    }
+  };
+}
+async function applyCommitPlan(plan, opts) {
+  const { cwd, push: shouldPush = false, remote = "origin" } = opts;
+  if (plan.kind === "split") {
+    if (plan.commits.length === 0) {
+      throw new GitwiseError({
+        code: "INVALID_INTENT",
+        message: "Commit split plan has zero commits; cannot apply"
+      });
+    }
+    const stashName = `gitwise/split-${(/* @__PURE__ */ new Date()).toISOString()}`;
+    const releaseLock = await acquireRepoLock(cwd, { command: "commit-split" });
+    try {
+      const tx = new Transaction();
+      const logger = { warn };
+      try {
+        const stagedTree = await writeTree(cwd);
+        await tx.run(takeNamedStashStep(cwd, stashName));
+        await resetStaged(cwd);
+        for (const entry of plan.commits) {
+          await tx.run(applyOneCommitStep(entry, cwd, stagedTree));
+        }
+        await stashDropNamed(cwd, stashName);
+      } catch (err) {
+        const wrapped = err instanceof GitwiseError ? err : new GitwiseError({
+          code: "GIT_FAILED",
+          message: err instanceof Error ? err.message : String(err),
+          cause: err,
+          details: { stderr: err instanceof Error ? err.message : String(err) }
+        });
+        await tx.rollback(wrapped, logger);
+        throw wrapped;
+      }
+    } finally {
+      await releaseLock();
+    }
+  } else {
+    const entry = plan.commits[0];
+    if (!entry) return;
+    const msg = entry.description ? `${entry.message}
+
+${entry.description}` : entry.message;
+    await applyCommit({ message: msg, files: [], cwd });
+  }
+  if (shouldPush) {
+    const branch = await getBranch(cwd);
+    await push(cwd, remote, branch);
+  }
+}
+
+// src/commands/review.ts
+var MAX_DIFF_CHARS2 = 8e4;
+var DEFAULT_REVIEW_TEMPLATE = `You are a senior code reviewer. Analyze the diff and produce a code review with findings in these categories:
+
+## Critical
+Issues that must be fixed before merging (bugs, security, data loss).
+
+## Suggestions
+Improvements worth considering (performance, readability, patterns).
+
+## Nitpicks
+Minor style or convention issues.
+
+For each finding, include:
+- File and line reference
+- Description of the issue
+- Suggested fix
+
+End with a summary: total findings count per category and overall recommendation (approve, request changes).
+
+{{diff}}
+`;
+function truncateDiff2(diff) {
+  if (diff.length <= MAX_DIFF_CHARS2) return diff;
+  return diff.slice(0, MAX_DIFF_CHARS2) + "\n\n[diff truncated \u2014 too large for context window]";
+}
+function extractSection(markdown, heading) {
+  const headingRegex = new RegExp(`##\\s*${heading}\\b([\\s\\S]*?)(?=##|$)`, "i");
+  const match = markdown.match(headingRegex);
+  if (!match || !match[1]) return [];
+  return match[1].split("\n").map((l) => l.replace(/^[-*•]\s*/, "").trim()).filter((l) => l.length > 0);
+}
+function linesToFindings(lines) {
+  return lines.map((line) => ({
+    description: line
+  }));
+}
+function parseReviewMarkdown(text) {
+  return {
+    critical: linesToFindings(extractSection(text, "Critical")),
+    suggestions: linesToFindings(extractSection(text, "Suggestions")),
+    nitpicks: linesToFindings(extractSection(text, "Nitpicks"))
+  };
+}
+function buildMarkdown(parsed) {
+  const sections = [];
+  sections.push("## Critical");
+  if (parsed.critical.length > 0) {
+    sections.push(...parsed.critical.map((f) => `- ${f.description}`));
+  } else {
+    sections.push("_No critical issues found._");
+  }
+  sections.push("\n## Suggestions");
+  if (parsed.suggestions.length > 0) {
+    sections.push(...parsed.suggestions.map((f) => `- ${f.description}`));
+  } else {
+    sections.push("_No suggestions._");
+  }
+  sections.push("\n## Nitpicks");
+  if (parsed.nitpicks.length > 0) {
+    sections.push(...parsed.nitpicks.map((f) => `- ${f.description}`));
+  } else {
+    sections.push("_No nitpicks._");
+  }
+  return sections.join("\n");
+}
+async function review(opts) {
+  const { cwd, provider, prompt, tier: requestedTier } = opts;
+  const baseBranch = opts.baseBranch ?? await resolveBaseBranch(cwd);
+  let diff;
+  try {
+    diff = await getDiff(cwd, baseBranch);
+  } catch (err) {
+    if (isUnknownRevisionError(err)) {
+      diff = await getDiff(cwd);
+    } else {
+      const reason = errorMessage(err);
+      throw new GitwiseError({
+        code: "DIFF_FAILED",
+        message: `Failed to compute diff against ${baseBranch}: ${reason}`,
+        exitCode: EXIT_CODES.GIT_FAILED,
+        cause: err
+      });
+    }
+  }
+  if (!diff) {
+    throw new GitwiseError({
+      code: "EMPTY_DIFF",
+      message: `No changes found between current branch and ${baseBranch}`,
+      exitCode: EXIT_CODES.NOTHING_STAGED
+    });
+  }
+  let templateContent;
+  try {
+    templateContent = await loadTemplate("review", {
+      repoRoot: opts.repoRoot ?? cwd,
+      templatesPath: opts.templatesPath
+    });
+  } catch {
+    templateContent = DEFAULT_REVIEW_TEMPLATE;
+  }
+  const truncated = truncateDiff2(diff);
+  const userMessage = interpolate(templateContent, { diff: truncated }) + (prompt ? `
+
+Additional context: ${prompt}` : "");
+  const systemPrompt = "You are a senior code reviewer. Analyze the provided diff carefully and return findings.";
+  const defaultTier = resolveModelTier("review");
+  const activeTier = requestedTier ?? defaultTier;
+  debug("Calling LLM for code review", { tier: activeTier, diffLength: truncated.length });
+  const response = await provider.chat({ systemPrompt, userMessage, tier: activeTier });
+  const tokens = { input: response.tokens.input, output: response.tokens.output };
+  const parsed = parseReviewMarkdown(response.content);
+  const markdown = buildMarkdown(parsed);
+  return {
+    critical: parsed.critical,
+    suggestions: parsed.suggestions,
+    nitpicks: parsed.nitpicks,
+    markdown,
+    tokens
+  };
+}
+async function resolveBaseBranch(cwd) {
+  try {
+    return await detectBaseBranch(cwd);
+  } catch {
+    return "main";
+  }
+}
+function errorMessage(err) {
+  if (err && typeof err === "object" && typeof err.message === "string") {
+    return err.message;
+  }
+  return String(err);
+}
+function isUnknownRevisionError(err) {
+  if (err === null || typeof err !== "object") return false;
+  const errObj = err;
+  const message = typeof errObj.message === "string" ? errObj.message : "";
+  const stderr = typeof errObj.stderr === "string" ? errObj.stderr : "";
+  const text = `${message}
+${stderr}`;
+  return /unknown revision|bad revision|not a valid object name|ambiguous argument/i.test(text);
+}
+
+// src/commands/pr.ts
+import { execFile as execFile4 } from "child_process";
+import { promisify as promisify4 } from "util";
+var exec3 = promisify4(execFile4);
+function parsePrResponse(content) {
+  const titleMatch = content.match(/^TITLE:\s*(.+)$/m);
+  const title = titleMatch ? titleMatch[1].trim() : "Update";
+  const separatorIdx = content.indexOf("---");
+  const body = separatorIdx >= 0 ? content.slice(separatorIdx + 3).trim() : content;
+  return { title, body };
+}
+async function detectExistingPr(cwd) {
+  try {
+    const result = await exec3("gh", ["pr", "view", "--json", "number", "--jq", ".number"], { cwd });
+    const numberStr = result.stdout.trim();
+    if (numberStr) {
+      const n = parseInt(numberStr, 10);
+      if (!isNaN(n)) return n;
+    }
+  } catch {
+  }
+  return void 0;
+}
+var PR_SYSTEM_PROMPT = `You are a developer creating a pull request. Based on the commit log, generate a PR title and description.
+
+Output format (nothing else):
+TITLE: <concise title, max 70 chars>
+---
+## Summary
+<1-3 bullet points>
+
+## Changes
+<changelog based on commits>
+
+## Test Plan
+<testing checklist>`;
+async function pr(opts) {
+  const { cwd, provider, prompt } = opts;
+  const baseBranch = opts.baseBranch ?? await resolveBaseBranch2(cwd);
+  const currentBranch = await getBranch(cwd);
+  const commits = await getLog(cwd, `${baseBranch}..HEAD`);
+  if (!commits) {
+    throw new GitwiseError({
+      code: "NO_COMMITS",
+      message: `No commits found on this branch relative to ${baseBranch}`,
+      exitCode: EXIT_CODES.RELEASE_PLAN_STALE
+    });
+  }
+  let systemPrompt = PR_SYSTEM_PROMPT;
+  let userMessageFromTemplate = `Branch: ${currentBranch}
+
+Commits:
+${commits}`;
+  try {
+    const templateContent = await loadTemplate("pr", {
+      repoRoot: opts.repoRoot ?? cwd,
+      templatesPath: opts.templatesPath
+    });
+    if (templateContent && templateContent.includes("{{")) {
+      userMessageFromTemplate = interpolate(templateContent, {
+        branch: currentBranch,
+        commits,
+        summary: "",
+        changelog: "",
+        test_plan: ""
+      });
+    }
+  } catch {
+  }
+  const userMessage = userMessageFromTemplate + (prompt ? `
+
+Additional context: ${prompt}` : "");
+  const existingPrNumber = await detectExistingPr(cwd);
+  debug("Calling LLM for PR draft", { tier: "fast", branch: currentBranch, existingPrNumber });
+  const tier = resolveModelTier("pr");
+  const response = await provider.chat({ systemPrompt, userMessage, tier });
+  const tokens = { input: response.tokens.input, output: response.tokens.output };
+  const { title, body } = parsePrResponse(response.content);
+  return {
+    title,
+    body,
+    existingPrNumber,
+    tokens
+  };
+}
+async function applyPr(draft, opts) {
+  const { cwd, draft: isDraft = false, baseBranch } = opts;
+  const ghAvailable = await isGhAvailable();
+  if (!ghAvailable) {
+    throw new GitwiseError({
+      code: "GH_UNAVAILABLE",
+      message: "gh CLI is not installed \u2014 cannot create or update a PR",
+      exitCode: EXIT_CODES.GH_FAILED,
+      details: { draft }
+    });
+  }
+  if (draft.existingPrNumber !== void 0) {
+    const updated = await updatePR({
+      prNumber: draft.existingPrNumber,
+      title: draft.title,
+      body: draft.body,
+      cwd
+    });
+    return { url: updated.url };
+  }
+  const created = await createPR({
+    title: draft.title,
+    body: draft.body,
+    base: baseBranch,
+    cwd,
+    draft: isDraft
+  });
+  return { url: created.url };
+}
+async function resolveBaseBranch2(cwd) {
+  try {
+    return await detectBaseBranch(cwd);
+  } catch {
+    return "main";
+  }
+}
+
+// src/commands/release.ts
+import { readFile as readFile6, unlink as unlink4, writeFile as writeFile3 } from "fs/promises";
+import { join as join6, relative } from "path";
+
+// src/strategies/release.ts
+var githubFlow = Object.freeze({
+  name: "github-flow",
+  releaseBranchFor(_version) {
+    return null;
+  },
+  mergeTargets(mainBranch, _developBranch) {
+    return [mainBranch];
+  },
+  requiresDevelop() {
+    return false;
+  }
+});
+var gitflow = Object.freeze({
+  name: "gitflow",
+  releaseBranchFor(version2) {
+    return `release/${version2}`;
+  },
+  mergeTargets(mainBranch, developBranch) {
+    return developBranch ? [mainBranch, developBranch] : [mainBranch];
+  },
+  requiresDevelop() {
+    return true;
+  }
+});
+var STRATEGIES = Object.freeze({
+  "github-flow": githubFlow,
+  gitflow
+});
+function createReleaseStrategy(name) {
+  return STRATEGIES[name];
+}
+
+// src/commands/release-plan.ts
+import { readFile as readFile5, unlink as unlink3, writeFile as writeFile2 } from "fs/promises";
+import { dirname as dirname3, join as join5 } from "path";
+var PLAN_REL_PATH = ".gitwise/release-plan.json";
+function planPath(cwd) {
+  return join5(cwd, PLAN_REL_PATH);
+}
+async function saveReleasePlan(cwd, plan) {
+  await writeJSON(planPath(cwd), plan);
+}
+async function loadReleasePlan(cwd) {
+  const filePath = planPath(cwd);
+  if (!await fileExists(filePath)) return null;
+  const raw = await readFile5(filePath, "utf-8");
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (err) {
+    throw new GitwiseError({
+      code: "INVALID_PLAN_JSON",
+      message: `Release plan at ${filePath} is not valid JSON: ${err instanceof Error ? err.message : String(err)}`,
+      exitCode: EXIT_CODES.CONFIG_INVALID,
+      cause: err
+    });
+  }
+  const schema = parsed?.schema;
+  if (schema !== 1) {
+    throw new GitwiseError({
+      code: "INVALID_PLAN_SCHEMA",
+      message: `Release plan schema ${String(schema)} is not supported by this gitwise binary (expected 1).`,
+      exitCode: EXIT_CODES.CONFIG_INVALID
+    });
+  }
+  if (!isPersistedReleasePlan(parsed)) {
+    throw new GitwiseError({
+      code: "INVALID_PLAN_SCHEMA",
+      message: `Release plan at ${filePath} is missing or has wrong-typed required fields for schema 1.`,
+      exitCode: EXIT_CODES.CONFIG_INVALID
+    });
+  }
+  return parsed;
+}
+function isPersistedReleasePlan(value) {
+  if (!value || typeof value !== "object") return false;
+  const p = value;
+  if (p.schema !== 1) return false;
+  if (p.strategy !== "gitflow" && p.strategy !== "github-flow") return false;
+  if (p.suggestedBump !== "major" && p.suggestedBump !== "minor" && p.suggestedBump !== "patch") {
+    return false;
+  }
+  if (typeof p.currentVersion !== "string") return false;
+  if (typeof p.newVersion !== "string") return false;
+  if (typeof p.changelog !== "string") return false;
+  if (typeof p.notes !== "string") return false;
+  if (typeof p.commits !== "string") return false;
+  if (typeof p.preparedAt !== "string") return false;
+  if (typeof p.baseCommit !== "string") return false;
+  if (typeof p.targetBranch !== "string") return false;
+  if (typeof p.releaseBranchCreated !== "boolean") return false;
+  if (!p.tokens || typeof p.tokens !== "object") return false;
+  const tokens = p.tokens;
+  if (typeof tokens.input !== "number" || !Number.isFinite(tokens.input)) return false;
+  if (typeof tokens.output !== "number" || !Number.isFinite(tokens.output)) return false;
+  return true;
+}
+async function deleteReleasePlan(cwd) {
+  try {
+    await unlink3(planPath(cwd));
+  } catch (err) {
+    if (err.code === "ENOENT") return;
+    throw err;
+  }
+}
+function applyGitignoreEntry(content, entry) {
+  if (isCovered(content, entry)) return content;
+  const needsLeadingNewline = content.length > 0 && !content.endsWith("\n");
+  return `${content}${needsLeadingNewline ? "\n" : ""}${entry}
+`;
+}
+async function ensureGitignored(cwd, entry) {
+  const gitignorePath = join5(cwd, ".gitignore");
+  const exists = await fileExists(gitignorePath);
+  const original = exists ? await readFile5(gitignorePath, "utf-8") : "";
+  const next = applyGitignoreEntry(original, entry);
+  if (next === original) return;
+  await writeFile2(gitignorePath, next, "utf-8");
+  info(`Added ${entry} to .gitignore`);
+}
+function isCovered(content, entry) {
+  const candidates = /* @__PURE__ */ new Set([entry]);
+  const dir = dirname3(entry);
+  if (dir && dir !== "." && dir !== "/") {
+    candidates.add(`${dir}/`);
+    candidates.add(`${dir}/*`);
+  }
+  for (const rawLine of content.split("\n")) {
+    const line = rawLine.trim();
+    if (line.length === 0 || line.startsWith("#")) continue;
+    if (candidates.has(line)) return true;
+  }
+  return false;
+}
+
+// src/commands/release.ts
+var RELEASE_PLAN_REL_PATH = ".gitwise/release-plan.json";
+var RELEASE_NOTES_GLOB_REL_PATH = ".gitwise/release-*.md";
+var STRICT_SEMVER_RE = /^v?(\d+)\.(\d+)\.(\d+)$/;
+function bumpVersion(current, type) {
+  const match = STRICT_SEMVER_RE.exec(current);
+  if (!match) {
+    throw new GitwiseError({
+      code: "INVALID_VERSION",
+      message: `Invalid current version: ${current}`,
+      exitCode: EXIT_CODES.CONFIG_INVALID
+    });
+  }
+  const major = Number(match[1]);
+  const minor = Number(match[2]);
+  const patch = Number(match[3]);
+  switch (type) {
+    case "major":
+      return `${major + 1}.0.0`;
+    case "minor":
+      return `${major}.${minor + 1}.0`;
+    case "patch":
+      return `${major}.${minor}.${patch + 1}`;
+    // Belt-and-suspenders: TS makes this unreachable for typed callers, but
+    // any JS caller (or a cast like `parseVersionSuggestion`'s former one)
+    // could smuggle in a bogus value. Surface it as INVALID_VERSION instead
+    // of silently returning undefined and minting `release/undefined` /
+    // `vundefined` artifacts downstream.
+    default:
+      throw new GitwiseError({
+        code: "INVALID_VERSION",
+        message: `Invalid bump type: ${String(type)}`,
+        exitCode: EXIT_CODES.CONFIG_INVALID
+      });
+  }
+}
+function parseVersionSuggestion(raw) {
+  try {
+    const cleaned = raw.replace(/```(?:json)?\n?/g, "").trim();
+    const parsed = JSON.parse(cleaned);
+    const { suggestion, reasoning } = parsed;
+    if ((suggestion === "major" || suggestion === "minor" || suggestion === "patch") && typeof reasoning === "string") {
+      return { suggestion, reasoning };
+    }
+  } catch {
+  }
+  return null;
+}
+function heuristicBump(commits) {
+  if (/BREAKING CHANGE|!:/.test(commits)) return "major";
+  if (/^feat[:(]/m.test(commits)) return "minor";
+  return "patch";
+}
+var CHANGELOG_HEADER = `# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com),
+and this project adheres to [Semantic Versioning](https://semver.org/).
+
+`;
+async function release(opts) {
+  const { cwd, provider, language = "en" } = opts;
+  const pkgPath = join6(cwd, "package.json");
+  if (!await fileExists(pkgPath)) {
+    throw new GitwiseError({
+      code: "NO_PACKAGE_JSON",
+      message: "No package.json found",
+      exitCode: EXIT_CODES.CONFIG_INVALID
+    });
+  }
+  const pkg = await readJSON(pkgPath);
+  const currentVersion = pkg.version;
+  const projectName = pkg.name ?? "project";
+  const lastTag = await getLatestTag(cwd);
+  const logRange = lastTag ? `${lastTag}..HEAD` : void 0;
+  const commits = await getLog(cwd, logRange);
+  if (!commits) {
+    throw new GitwiseError({
+      code: "NO_COMMITS",
+      message: "No new commits since last release",
+      exitCode: EXIT_CODES.RELEASE_PLAN_STALE
+    });
+  }
+  const templateOpts = {
+    repoRoot: opts.repoRoot ?? cwd,
+    templatesPath: opts.templatesPath
+  };
+  const tier = resolveModelTier("release");
+  let totalInput = 0;
+  let totalOutput = 0;
+  let suggestedBump;
+  if (opts.bump) {
+    suggestedBump = opts.bump;
+  } else {
+    const versionTemplate = await loadTemplate("release-version", templateOpts);
+    const versionPrompt = interpolate(versionTemplate, { currentVersion });
+    debug("Calling LLM for version suggestion");
+    const versionResponse = await provider.chat({
+      systemPrompt: "You are a release engineer. Respond with JSON only.",
+      userMessage: `${versionPrompt}
+
+Commits:
+${commits}`,
+      tier
+    });
+    totalInput += versionResponse.tokens.input;
+    totalOutput += versionResponse.tokens.output;
+    const suggestion = parseVersionSuggestion(versionResponse.content);
+    suggestedBump = suggestion?.suggestion ?? heuristicBump(commits);
+  }
+  const newVersion = bumpVersion(currentVersion, suggestedBump);
+  const changelogTemplate = await loadTemplate("release-changelog", templateOpts);
+  const changelogPrompt = interpolate(changelogTemplate, { projectName });
+  debug("Calling LLM for changelog generation");
+  const changelogResponse = await provider.chat({
+    systemPrompt: "You are a technical writer generating a changelog. Follow Keep a Changelog format.",
+    userMessage: `${changelogPrompt}
+
+Commits:
+${commits}`,
+    tier
+  });
+  totalInput += changelogResponse.tokens.input;
+  totalOutput += changelogResponse.tokens.output;
+  const changelog = changelogResponse.content;
+  const notesTemplate = await loadTemplate("release-notes", templateOpts);
+  const notesPrompt = interpolate(notesTemplate, {
+    version: newVersion,
+    projectName,
+    language
+  });
+  debug("Calling LLM for release notes generation");
+  const notesResponse = await provider.chat({
+    systemPrompt: "You are a product communications specialist writing release notes.",
+    userMessage: `${notesPrompt}
+
+Commits:
+${commits}`,
+    tier
+  });
+  totalInput += notesResponse.tokens.input;
+  totalOutput += notesResponse.tokens.output;
+  const notes = notesResponse.content;
+  return {
+    suggestedBump,
+    newVersion,
+    currentVersion,
+    changelog,
+    notes,
+    commits,
+    tokens: { input: totalInput, output: totalOutput }
+  };
+}
+function createReleaseBranchStep(cwd, branchName, startPoint) {
+  return {
+    name: `create-branch:${branchName}`,
+    apply: async () => {
+      const previousBranch = await getBranch(cwd);
+      await createBranch(cwd, branchName, startPoint);
+      return { branchName, previousBranch };
+    },
+    compensate: async ({ branchName: branch, previousBranch }) => {
+      await checkoutForce(cwd, previousBranch);
+      await deleteBranch(cwd, branch, true);
+    }
+  };
+}
+function writeFileStep(filePath, contents) {
+  return {
+    name: `write-file:${filePath}`,
+    apply: async () => {
+      const priorBytes = await fileExists(filePath) ? await readFile6(filePath) : null;
+      await writeFile3(filePath, contents);
+      return priorBytes;
+    },
+    compensate: async (priorBytes) => {
+      if (priorBytes === null) {
+        try {
+          await unlink4(filePath);
+        } catch (err) {
+          if (err.code !== "ENOENT") throw err;
+        }
+      } else {
+        await writeFile3(filePath, priorBytes);
+      }
+    }
+  };
+}
+function mutateGitignoreStep(cwd) {
+  const gitignorePath = join6(cwd, ".gitignore");
+  return {
+    name: "mutate-gitignore",
+    apply: async () => {
+      const priorBytes = await fileExists(gitignorePath) ? await readFile6(gitignorePath) : null;
+      await ensureGitignored(cwd, RELEASE_PLAN_REL_PATH);
+      await ensureGitignored(cwd, RELEASE_NOTES_GLOB_REL_PATH);
+      return priorBytes;
+    },
+    compensate: async (priorBytes) => {
+      if (priorBytes === null) {
+        try {
+          await unlink4(gitignorePath);
+        } catch (err) {
+          if (err.code !== "ENOENT") throw err;
+        }
+      } else {
+        await writeFile3(gitignorePath, priorBytes);
+      }
+    }
+  };
+}
+function writeChangelogStep(cwd, newVersion, entryBody) {
+  const changelogPath = join6(cwd, "CHANGELOG.md");
+  return {
+    name: "write-changelog",
+    apply: async () => {
+      const priorBytes = await fileExists(changelogPath) ? await readFile6(changelogPath) : null;
+      const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+      const versionHeader = `## [${newVersion}] - ${date}
+
+${entryBody}
+
+`;
+      if (priorBytes !== null) {
+        const existing = priorBytes.toString("utf-8");
+        const headerEnd = existing.indexOf("## [");
+        if (headerEnd > 0) {
+          await writeFile3(
+            changelogPath,
+            existing.slice(0, headerEnd) + versionHeader + existing.slice(headerEnd),
+            "utf-8"
+          );
+        } else {
+          const body = existing.startsWith(CHANGELOG_HEADER) ? existing.slice(CHANGELOG_HEADER.length) : existing;
+          await writeFile3(
+            changelogPath,
+            CHANGELOG_HEADER + versionHeader + body,
+            "utf-8"
+          );
+        }
+      } else {
+        await writeFile3(
+          changelogPath,
+          CHANGELOG_HEADER + versionHeader,
+          "utf-8"
+        );
+      }
+      return priorBytes;
+    },
+    compensate: async (priorBytes) => {
+      if (priorBytes === null) {
+        try {
+          await unlink4(changelogPath);
+        } catch (err) {
+          if (err.code !== "ENOENT") throw err;
+        }
+      } else {
+        await writeFile3(changelogPath, priorBytes);
+      }
+    }
+  };
+}
+function commitReleaseStep(cwd, message, files) {
+  return {
+    name: "commit-release-bump",
+    apply: async () => {
+      const preSha = await headSha(cwd);
+      await applyCommit({ message, files, cwd });
+      return preSha;
+    },
+    compensate: async (preSha) => {
+      await resetHard(cwd, preSha);
+    }
+  };
+}
+function savePlanStep(cwd, plan) {
+  return {
+    name: "save-plan",
+    apply: async () => {
+      await saveReleasePlan(cwd, plan);
+    },
+    compensate: async () => {
+      await deleteReleasePlan(cwd);
+    }
+  };
+}
+async function prepareRelease(opts) {
+  const { cwd } = opts;
+  const repoConfig = await readRepoConfig(cwd);
+  const strategyName = opts.strategy ?? repoConfig?.releaseStrategy ?? "github-flow";
+  const developBranch = opts.developBranch ?? repoConfig?.developBranch ?? "develop";
+  const strategy = createReleaseStrategy(strategyName);
+  debug("release.prepare.start", { strategy: strategyName, cwd });
+  const releaseLock = await acquireRepoLock(cwd, {
+    command: "release prepare"
+  });
+  try {
+    const dirtyEntries = (await status(cwd)).split("\n").map((line) => line.replace(/\s+$/, "")).filter((line) => line.length >= 3).filter((line) => {
+      const path3 = line.slice(3).trim();
+      if (path3 === ".gitignore") return false;
+      if (path3 === ".gitwise/" || path3 === ".gitwise") return false;
+      if (path3.startsWith(".gitwise/")) return false;
+      return true;
+    });
+    if (dirtyEntries.length > 0) {
+      throw new GitwiseError({
+        code: "WORKING_TREE_DIRTY",
+        message: `Working tree must be clean before preparing a release \u2014 commit or stash first.
+${dirtyEntries.join("\n")}`,
+        exitCode: EXIT_CODES.REPO_STATE_INVALID
+      });
+    }
+    const existingPlan = await loadReleasePlan(cwd);
+    if (existingPlan) {
+      throw new GitwiseError({
+        code: "RELEASE_PLAN_EXISTS",
+        message: `An in-flight release plan already exists at .gitwise/release-plan.json for v${existingPlan.newVersion} (${existingPlan.strategy}). Finish it with "gw release finish" or discard it with "gw release abort" before preparing a new release.`,
+        exitCode: EXIT_CODES.RELEASE_BRANCH_CONFLICT
+      });
+    }
+    if (strategy.requiresDevelop()) {
+      if (!await branchExists(cwd, developBranch)) {
+        throw new GitwiseError({
+          code: "STRATEGY_DEVELOP_MISSING",
+          message: `GitFlow requires a "${developBranch}" branch but it does not exist. Create it first (e.g. git checkout -b ${developBranch}).`,
+          exitCode: EXIT_CODES.REPO_STATE_INVALID
+        });
+      }
+    }
+    const baseCommit = await headSha(cwd);
+    const plan = await release(opts);
+    const releaseBranch = strategy.releaseBranchFor(plan.newVersion);
+    if (releaseBranch && await branchExists(cwd, releaseBranch)) {
+      throw new GitwiseError({
+        code: "RELEASE_BRANCH_CONFLICT",
+        message: `Release branch "${releaseBranch}" already exists. Delete it or pick a different version \u2014 see docs/recovery.md if a prior prepare crashed before its rollback finished.`,
+        exitCode: EXIT_CODES.RELEASE_BRANCH_CONFLICT,
+        details: { releaseBranch, newVersion: plan.newVersion }
+      });
+    }
+    const tx = new Transaction();
+    await ensureDir(join6(cwd, ".gitwise"));
+    let targetBranch;
+    try {
+      if (releaseBranch) {
+        await tx.run(
+          createReleaseBranchStep(cwd, releaseBranch, developBranch)
+        );
+        debug("release.prepare.branch.created", {
+          branch: releaseBranch,
+          from: developBranch
+        });
+        targetBranch = releaseBranch;
+      } else {
+        targetBranch = await getBranch(cwd);
+      }
+      const notesPath = join6(cwd, ".gitwise", `release-${plan.newVersion}.md`);
+      await tx.run(writeFileStep(notesPath, plan.notes));
+      let propagatedManifests = [];
+      if (releaseBranch) {
+        const pkgPath = join6(cwd, "package.json");
+        await tx.run(writeWorkspaceVersionStep(pkgPath, plan.newVersion));
+        if (opts.workspacePropagation) {
+          propagatedManifests = await runWorkspaceVersionStepsInto(
+            tx,
+            cwd,
+            plan.newVersion
+          );
+        }
+        await tx.run(writeChangelogStep(cwd, plan.newVersion, plan.changelog));
+      }
+      await tx.run(mutateGitignoreStep(cwd));
+      if (releaseBranch) {
+        const stagePaths = ["package.json", "CHANGELOG.md"];
+        if (await fileExists(join6(cwd, ".gitignore"))) {
+          stagePaths.push(".gitignore");
+        }
+        stagePaths.push(...propagatedManifests);
+        await tx.run(
+          commitReleaseStep(
+            cwd,
+            `chore(release): v${plan.newVersion}`,
+            stagePaths
+          )
+        );
+      }
+      const persistedPlan = {
+        schema: 1,
+        strategy: strategyName,
+        currentVersion: plan.currentVersion,
+        newVersion: plan.newVersion,
+        suggestedBump: plan.suggestedBump,
+        changelog: plan.changelog,
+        notes: plan.notes,
+        commits: plan.commits,
+        preparedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        baseCommit,
+        targetBranch,
+        releaseBranchCreated: releaseBranch !== null,
+        tokens: plan.tokens
+      };
+      await tx.run(savePlanStep(cwd, persistedPlan));
+      debug("release.prepare.plan.saved", {
+        newVersion: plan.newVersion,
+        targetBranch,
+        releaseBranchCreated: persistedPlan.releaseBranchCreated
+      });
+      return persistedPlan;
+    } catch (err) {
+      const reason = err instanceof GitwiseError ? err : new GitwiseError({
+        code: "RELEASE_PREPARE_FAILED",
+        message: `Failed to prepare release: ${err instanceof Error ? err.message : String(err)}`,
+        exitCode: EXIT_CODES.GIT_FAILED,
+        cause: err
+      });
+      debug("release.prepare.rollback.start", {
+        appliedSteps: tx.size,
+        code: reason.code
+      });
+      await tx.rollback(reason, txLogger);
+      throw reason;
+    }
+  } finally {
+    await releaseLock();
+  }
+}
+async function applyRelease(plan, opts) {
+  const { cwd, tagAndPush = true, createGhRelease = true, workspacePropagation = false, signTags } = opts;
+  const dirty = (await status(cwd)).trim();
+  if (dirty) {
+    throw new GitwiseError({
+      code: "WORKING_TREE_DIRTY",
+      message: `Working tree must be clean before releasing \u2014 commit or stash first.
+${dirty}`,
+      exitCode: EXIT_CODES.REPO_STATE_INVALID
+    });
+  }
+  const tag = `v${plan.newVersion}`;
+  if (await tagExists(cwd, tag)) {
+    throw new GitwiseError({
+      code: "TAG_EXISTS",
+      message: `Tag ${tag} already exists. Bump to a new version or delete the tag.`,
+      exitCode: EXIT_CODES.RELEASE_BRANCH_CONFLICT
+    });
+  }
+  await ensureDir(join6(cwd, ".gitwise"));
+  await writeFile3(
+    join6(cwd, ".gitwise", `release-${plan.newVersion}.md`),
+    plan.notes,
+    "utf-8"
+  );
+  const persistedPlan = {
+    schema: 1,
+    strategy: "github-flow",
+    currentVersion: plan.currentVersion,
+    newVersion: plan.newVersion,
+    suggestedBump: plan.suggestedBump,
+    changelog: plan.changelog,
+    notes: plan.notes,
+    commits: plan.commits,
+    preparedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    baseCommit: await headSha(cwd),
+    targetBranch: await getBranch(cwd),
+    releaseBranchCreated: false,
+    tokens: plan.tokens
+  };
+  await ensureGitignored(cwd, RELEASE_PLAN_REL_PATH);
+  await ensureGitignored(cwd, RELEASE_NOTES_GLOB_REL_PATH);
+  await saveReleasePlan(cwd, persistedPlan);
+  await finishRelease({ cwd, tagAndPush, createGhRelease, workspacePropagation, signTags });
+}
+async function finishRelease(opts) {
+  const {
+    cwd,
+    tagAndPush = true,
+    createGhRelease = true,
+    deleteReleaseBranch = true,
+    workspacePropagation = false,
+    signTags = true
+  } = opts;
+  if (signTags === false) {
+    process.stderr.write(
+      "[gitwise] WARNING: --no-sign / signTags:false is a testing-only escape hatch. Release tags will NOT be GPG-signed. Do not use in production releases.\n"
+    );
+  }
+  const plan = await loadReleasePlan(cwd);
+  if (!plan) {
+    throw new GitwiseError({
+      code: "NO_RELEASE_PLAN",
+      message: `No release plan found at .gitwise/release-plan.json. Run "gw release prepare" first.`,
+      exitCode: EXIT_CODES.RELEASE_PLAN_STALE
+    });
+  }
+  debug("release.finish.start", {
+    strategy: plan.strategy,
+    newVersion: plan.newVersion,
+    targetBranch: plan.targetBranch
+  });
+  const strategy = createReleaseStrategy(plan.strategy);
+  const tag = `v${plan.newVersion}`;
+  if (await tagExists(cwd, tag)) {
+    debug("release.finish.validate.failed", {
+      code: "STALE_PLAN_TAG_EXISTS",
+      tag
+    });
+    throw new GitwiseError({
+      code: "STALE_PLAN_TAG_EXISTS",
+      message: `Tag ${tag} already exists \u2014 the saved plan is stale. Run "gw release abort" or delete the tag before retrying.`,
+      exitCode: EXIT_CODES.RELEASE_PLAN_STALE
+    });
+  }
+  const currentBranch = await getBranch(cwd);
+  if (currentBranch !== plan.targetBranch) {
+    debug("release.finish.validate.failed", {
+      code: "STALE_PLAN_BRANCH_MISMATCH",
+      expected: plan.targetBranch,
+      actual: currentBranch
+    });
+    throw new GitwiseError({
+      code: "STALE_PLAN_BRANCH_MISMATCH",
+      message: `Release plan targets "${plan.targetBranch}" but the current branch is "${currentBranch}". Check out the target branch before running finish.`,
+      exitCode: EXIT_CODES.RELEASE_PLAN_STALE
+    });
+  }
+  const expectedDirtyPaths = /* @__PURE__ */ new Set([
+    ".gitwise/",
+    ".gitwise/release-plan.json",
+    `.gitwise/release-${plan.newVersion}.md`
+  ]);
+  if (await gitignoreMatchesPrepareOutput(cwd)) {
+    expectedDirtyPaths.add(".gitignore");
+  }
+  const dirtyEntries = (await status(cwd)).split("\n").map((line) => line.replace(/\s+$/, "")).filter((line) => line.length >= 3).filter((line) => !expectedDirtyPaths.has(line.slice(3).trim()));
+  if (dirtyEntries.length > 0) {
+    debug("release.finish.validate.failed", {
+      code: "WORKING_TREE_DIRTY"
+    });
+    throw new GitwiseError({
+      code: "WORKING_TREE_DIRTY",
+      message: `Working tree must be clean before finishing a release \u2014 commit or stash first.
+${dirtyEntries.join("\n")}`,
+      exitCode: EXIT_CODES.REPO_STATE_INVALID
+    });
+  }
+  const repoConfig = await readRepoConfig(cwd);
+  const developBranch = repoConfig?.developBranch ?? "develop";
+  if (strategy.requiresDevelop()) {
+    if (!await branchExists(cwd, developBranch)) {
+      debug("release.finish.validate.failed", {
+        code: "STRATEGY_DEVELOP_MISSING",
+        developBranch
+      });
+      throw new GitwiseError({
+        code: "STRATEGY_DEVELOP_MISSING",
+        message: `GitFlow requires a "${developBranch}" branch but it does not exist.`,
+        exitCode: EXIT_CODES.REPO_STATE_INVALID
+      });
+    }
+  }
+  const mainBranch = strategy.requiresDevelop() ? await detectBaseBranch(cwd) : plan.targetBranch;
+  const notesPath = join6(cwd, ".gitwise", `release-${plan.newVersion}.md`);
+  let notes;
+  try {
+    notes = await readFile6(notesPath, "utf-8");
+  } catch (err) {
+    if (err.code === "ENOENT") {
+      debug("release.finish.notes.missing", { path: notesPath });
+      notes = plan.notes;
+    } else {
+      const cause = err instanceof Error ? err.message : String(err);
+      debug("release.finish.notes.read.failed", { path: notesPath, error: cause });
+      throw new GitwiseError({
+        code: "NOTES_READ_FAILED",
+        message: `Failed to read release notes at ${notesPath}: ${cause}. Recreate the file from the plan or run "gw release abort" to discard the in-flight release.`,
+        cause: err
+      });
+    }
+  }
+  if (!plan.releaseBranchCreated) {
+    const pkgPath = join6(cwd, "package.json");
+    const pkg = await readJSON(pkgPath);
+    pkg["version"] = plan.newVersion;
+    await writeJSON(pkgPath, pkg);
+    let propagatedManifests = [];
+    if (workspacePropagation) {
+      propagatedManifests = await propagateVersionToWorkspaces(cwd, plan.newVersion);
+    }
+    const changelogPath = join6(cwd, "CHANGELOG.md");
+    const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+    const versionHeader = `## [${plan.newVersion}] - ${date}
+
+${plan.changelog}
+
+`;
+    if (await fileExists(changelogPath)) {
+      const existing = await readFile6(changelogPath, "utf-8");
+      const headerEnd = existing.indexOf("## [");
+      if (headerEnd > 0) {
+        await writeFile3(
+          changelogPath,
+          existing.slice(0, headerEnd) + versionHeader + existing.slice(headerEnd),
+          "utf-8"
+        );
+      } else {
+        const body = existing.startsWith(CHANGELOG_HEADER) ? existing.slice(CHANGELOG_HEADER.length) : existing;
+        await writeFile3(
+          changelogPath,
+          CHANGELOG_HEADER + versionHeader + body,
+          "utf-8"
+        );
+      }
+    } else {
+      await writeFile3(changelogPath, CHANGELOG_HEADER + versionHeader, "utf-8");
+    }
+    const stagePaths = ["package.json", "CHANGELOG.md"];
+    if (await fileExists(join6(cwd, ".gitignore"))) {
+      stagePaths.push(".gitignore");
+    }
+    stagePaths.push(...propagatedManifests);
+    await applyCommit({
+      message: `chore(release): v${plan.newVersion}`,
+      files: stagePaths,
+      cwd
+    });
+  }
+  await deleteReleasePlan(cwd);
+  const mergeTargets = strategy.mergeTargets(mainBranch, developBranch);
+  for (const target of mergeTargets) {
+    if (target === plan.targetBranch) continue;
+    await checkout(cwd, target);
+    try {
+      await mergeNoFf(cwd, plan.targetBranch);
+    } catch (err) {
+      const cause = err instanceof Error ? err.message : String(err);
+      debug("release.finish.merge.failed", {
+        target,
+        source: plan.targetBranch,
+        error: cause
+      });
+      throw new GitwiseError({
+        code: "FINISH_MERGE_CONFLICT",
+        message: `Failed to merge "${plan.targetBranch}" into "${target}" while finishing v${plan.newVersion}. The release plan file has already been deleted, so finish cannot be re-run. Resolve the conflicts, run "git merge --continue", then tag and push manually: git tag -a v${plan.newVersion} -F .gitwise/release-${plan.newVersion}.md && git push --follow-tags origin ${mainBranch}.
+${cause}`,
+        exitCode: EXIT_CODES.GIT_FAILED,
+        cause: err,
+        details: {
+          target,
+          source: plan.targetBranch,
+          newVersion: plan.newVersion
+        }
+      });
+    }
+    debug("release.finish.merge.target", {
+      target,
+      source: plan.targetBranch
+    });
+  }
+  if (await getBranch(cwd) !== mainBranch) {
+    await checkout(cwd, mainBranch);
+  }
+  if (tagAndPush) {
+    await createTag(cwd, tag, notes, { signed: signTags !== false });
+    await pushWithTags(cwd, "origin", mainBranch);
+    debug("release.finish.tag.pushed", {
+      tag,
+      branch: mainBranch,
+      remote: "origin"
+    });
+    if (strategy.requiresDevelop()) {
+      await push(cwd, "origin", developBranch);
+    }
+  }
+  if (createGhRelease) {
+    if (await isGhAvailable()) {
+      try {
+        await createGitHubRelease({
+          tag,
+          title: tag,
+          body: notes,
+          cwd
+        });
+      } catch (err) {
+        debug("release.finish.gh.failed", {
+          tag,
+          error: err instanceof Error ? err.message : String(err)
+        });
+      }
+    } else {
+      debug("gh not available, skipping GitHub release creation");
+    }
+  }
+  if (plan.releaseBranchCreated && deleteReleaseBranch) {
+    try {
+      await deleteBranch(cwd, plan.targetBranch);
+    } catch (err) {
+      debug("release.finish.branch.delete.failed", {
+        branch: plan.targetBranch,
+        error: err instanceof Error ? err.message : String(err)
+      });
+    }
+  }
+}
+async function abortRelease(opts) {
+  const { cwd, deleteBranch: deleteBranch2 = false } = opts;
+  debug("release.abort.start", { cwd, deleteBranch: deleteBranch2 });
+  const plan = await loadReleasePlan(cwd);
+  if (!plan) {
+    throw new GitwiseError({
+      code: "NO_RELEASE_PLAN",
+      message: `No release plan found at .gitwise/release-plan.json. Nothing to abort.`,
+      exitCode: EXIT_CODES.RELEASE_PLAN_STALE
+    });
+  }
+  const shouldDeleteBranch = deleteBranch2 && plan.releaseBranchCreated;
+  let mainBranch = "";
+  if (shouldDeleteBranch) {
+    const strategy = createReleaseStrategy(plan.strategy);
+    const repoConfig = await readRepoConfig(cwd);
+    const developBranch = repoConfig?.developBranch ?? "develop";
+    mainBranch = strategy.requiresDevelop() ? await detectBaseBranch(cwd) : plan.targetBranch;
+    for (const target of strategy.mergeTargets(mainBranch, developBranch)) {
+      if (target === plan.targetBranch) continue;
+      if (!await isBranchMerged(cwd, plan.targetBranch, target)) {
+        throw new GitwiseError({
+          code: "RELEASE_BRANCH_UNMERGED",
+          message: `Refusing to delete release branch "${plan.targetBranch}" \u2014 it has commits not present in "${target}". Merge or cherry-pick them first, or remove the branch manually.`,
+          exitCode: EXIT_CODES.RELEASE_BRANCH_CONFLICT
+        });
+      }
+    }
+  }
+  await deleteReleasePlan(cwd);
+  if (shouldDeleteBranch) {
+    if (await getBranch(cwd) === plan.targetBranch) {
+      await checkout(cwd, mainBranch);
+    }
+    await deleteBranch(cwd, plan.targetBranch);
+    debug("release.abort.branch.deleted", { branch: plan.targetBranch });
+  }
+}
+async function runReleaseInProcess(opts) {
+  const plan = await prepareRelease(opts);
+  const resolveDeleteBranch = async () => {
+    const setting = opts.confirmAbortDeletesBranch;
+    if (typeof setting !== "function") return setting ?? false;
+    try {
+      return await setting(plan) === true;
+    } catch {
+      return false;
+    }
+  };
+  let confirmed;
+  try {
+    confirmed = await opts.confirm(plan);
+  } catch (err) {
+    await abortRelease({
+      cwd: opts.cwd,
+      deleteBranch: await resolveDeleteBranch()
+    });
+    throw err;
+  }
+  if (!confirmed) {
+    await abortRelease({
+      cwd: opts.cwd,
+      deleteBranch: await resolveDeleteBranch()
+    });
+    return null;
+  }
+  await finishRelease({ cwd: opts.cwd, ...opts.finishOptions });
+  return plan;
+}
+async function gitignoreMatchesPrepareOutput(cwd) {
+  const headContent = await showFileAtHead(cwd, ".gitignore") ?? "";
+  const gitignorePath = join6(cwd, ".gitignore");
+  const currentContent = await fileExists(gitignorePath) ? await readFile6(gitignorePath, "utf-8") : "";
+  let expected = applyGitignoreEntry(headContent, RELEASE_PLAN_REL_PATH);
+  expected = applyGitignoreEntry(expected, RELEASE_NOTES_GLOB_REL_PATH);
+  return currentContent === expected;
+}
+function writeWorkspaceVersionStep(manifestPath, newVersion) {
+  return {
+    name: `write-version:${manifestPath}`,
+    apply: async () => {
+      const priorBytes = await readFile6(manifestPath);
+      const parsed = JSON.parse(priorBytes.toString("utf-8"));
+      parsed["version"] = newVersion;
+      await writeJSON(manifestPath, parsed);
+      return priorBytes;
+    },
+    compensate: async (priorBytes) => {
+      await writeFile3(manifestPath, priorBytes);
+    }
+  };
+}
+var txLogger = {
+  warn(message, context) {
+    warn(`[gitwise] ${message}`, context);
+  }
+};
+async function propagateVersionToWorkspaces(cwd, version2) {
+  const releaseLock = await acquireRepoLock(cwd, {
+    command: "release propagate-version"
+  });
+  try {
+    const tx = new Transaction();
+    try {
+      return await runWorkspaceVersionStepsInto(tx, cwd, version2);
+    } catch (err) {
+      const reason = err instanceof GitwiseError ? err : new GitwiseError({
+        code: "WORKSPACE_VERSION_WRITE_FAILED",
+        message: `Failed to propagate version ${version2} to workspaces: ${err instanceof Error ? err.message : String(err)}`,
+        exitCode: EXIT_CODES.GIT_FAILED,
+        cause: err
+      });
+      await tx.rollback(reason, txLogger);
+      throw reason;
+    }
+  } finally {
+    await releaseLock();
+  }
+}
+async function runWorkspaceVersionStepsInto(tx, cwd, version2) {
+  const patterns = await readWorkspacePatterns(cwd);
+  const workspaceDirs = (await expandWorkspacePatterns(cwd, patterns)).sort();
+  const modified = [];
+  for (const dir of workspaceDirs) {
+    const pkgPath = join6(dir, "package.json");
+    if (await fileExists(pkgPath)) {
+      await tx.run(writeWorkspaceVersionStep(pkgPath, version2));
+      modified.push(relative(cwd, pkgPath));
+    }
+    const pluginPath = join6(dir, "plugin.json");
+    if (await fileExists(pluginPath)) {
+      await tx.run(writeWorkspaceVersionStep(pluginPath, version2));
+      modified.push(relative(cwd, pluginPath));
+    }
+  }
+  return modified;
+}
+async function detectWorkspaceRoot(cwd) {
+  const patterns = await readWorkspacePatterns(cwd);
+  const dirs = await expandWorkspacePatterns(cwd, patterns);
+  for (const dir of dirs) {
+    if (await fileExists(join6(dir, "package.json"))) return true;
+  }
+  return false;
+}
+async function readWorkspacePatterns(cwd) {
+  const pkgPath = join6(cwd, "package.json");
+  if (!await fileExists(pkgPath)) return ["packages/*"];
+  let parsed;
+  try {
+    parsed = await readJSON(pkgPath);
+  } catch {
+    return ["packages/*"];
+  }
+  const ws = parsed.workspaces;
+  const fromArray = Array.isArray(ws) ? ws.filter((p) => typeof p === "string" && p.length > 0) : [];
+  if (fromArray.length > 0) return fromArray;
+  if (ws && typeof ws === "object" && !Array.isArray(ws)) {
+    const inner = ws.packages;
+    if (Array.isArray(inner)) {
+      const fromObject = inner.filter(
+        (p) => typeof p === "string" && p.length > 0
+      );
+      if (fromObject.length > 0) return fromObject;
+    }
+  }
+  return ["packages/*"];
+}
+async function expandWorkspacePatterns(cwd, patterns) {
+  const { readdir } = await import("fs/promises");
+  const readdirFn = readdir;
+  const matched = /* @__PURE__ */ new Set();
+  for (const pattern of patterns) {
+    if (pattern.startsWith("!")) continue;
+    const segments = pattern.split("/").filter((s) => s.length > 0);
+    if (segments.length === 0) continue;
+    await walkWorkspaceSegments(cwd, segments, 0, matched, readdirFn);
+  }
+  return Array.from(matched);
+}
+async function walkWorkspaceSegments(current, segments, index, out, readdirFn) {
+  if (index >= segments.length) {
+    out.add(current);
+    return;
+  }
+  const segment = segments[index] ?? "";
+  if (!segment.includes("*")) {
+    await walkWorkspaceSegments(
+      join6(current, segment),
+      segments,
+      index + 1,
+      out,
+      readdirFn
+    );
+    return;
+  }
+  let entries;
+  try {
+    entries = await readdirFn(current, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  const regex = segmentToRegex(segment);
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    if (!regex.test(entry.name)) continue;
+    await walkWorkspaceSegments(
+      join6(current, entry.name),
+      segments,
+      index + 1,
+      out,
+      readdirFn
+    );
+  }
+}
+function segmentToRegex(segment) {
+  const escaped = segment.split(/(\*|\?)/).map((part) => {
+    if (part === "*") return "[^/]*";
+    if (part === "?") return "[^/]";
+    return part.replace(/[.+^${}()|[\]\\]/g, "\\$&");
+  }).join("");
+  return new RegExp(`^${escaped}$`);
+}
+
+// src/providers/anthropic.ts
+import Anthropic from "@anthropic-ai/sdk";
+var DEFAULT_MAX_TOKENS = 4096;
+var DEFAULT_TIMEOUT_MS2 = 12e4;
+var MAX_RETRIES = 3;
+var BASE_DELAY_MS = 1e3;
+var AnthropicProvider = class {
+  client;
+  models;
+  constructor(apiKey, models) {
+    this.client = new Anthropic({
+      apiKey: apiKey ?? process.env["ANTHROPIC_API_KEY"],
+      timeout: DEFAULT_TIMEOUT_MS2
+    });
+    this.models = models;
+  }
+  async chat(req) {
+    const modelId = this.resolveModel(req.tier);
+    debug("Calling Anthropic API", { model: modelId, tier: req.tier });
+    return this.callWithRetry(req, modelId);
+  }
+  async callWithRetry(req, modelId) {
+    let lastError;
+    for (let attempt = 0; attempt < MAX_RETRIES; attempt++) {
+      try {
+        return await this.callApi(req, modelId);
+      } catch (err) {
+        lastError = err instanceof Error ? err : new Error(String(err));
+        if (this.isRetryable(err)) {
+          const delay = BASE_DELAY_MS * Math.pow(2, attempt);
+          debug("Retrying after error", { attempt, delay, error: lastError.message });
+          await this.sleep(delay);
+          continue;
+        }
+        throw lastError;
+      }
+    }
+    throw new GitwiseError({
+      code: "API_RATE_LIMITED",
+      message: lastError?.message ?? "Max retries exceeded",
+      cause: lastError
+    });
+  }
+  async callApi(req, modelId) {
+    const response = await this.client.messages.create({
+      model: modelId,
+      max_tokens: DEFAULT_MAX_TOKENS,
+      system: req.systemPrompt,
+      messages: [{ role: "user", content: req.userMessage }]
+    });
+    const text = response.content.filter((block) => block.type === "text").map((block) => block.text).join("");
+    return {
+      content: text,
+      tokens: {
+        input: response.usage.input_tokens,
+        output: response.usage.output_tokens
+      }
+    };
+  }
+  resolveModel(tier) {
+    return this.models[tier];
+  }
+  isRetryable(err) {
+    if (err instanceof Anthropic.APIError) {
+      return err.status === 429 || err.status === 529;
+    }
+    return false;
+  }
+  sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+};
+
+// src/providers/factory.ts
+function createProvider(config) {
+  if (config.kind === "claude-code") {
+    return new ClaudeCodeProvider(config.models, config.claudeCliPath);
+  }
+  return new AnthropicProvider(config.apiKey, config.models);
+}
+
+// src/index.ts
+var version = package_default.version;
+var __placeholder__ = /* @__PURE__ */ Symbol.for("@denisvieiradev/gitwise-core#placeholder");
+export {
+  DEFAULT_USER_CONFIG,
+  EXIT_CODES,
+  GitwiseError,
+  STALE_LOCK_MS,
+  SUPPORTED_COMMANDS,
+  Transaction,
+  __placeholder__,
+  abortRelease,
+  acquireRepoLock,
+  applyCommitPlan,
+  applyOneCommitStep,
+  applyPr,
+  applyRelease,
+  bumpVersion,
+  commit2 as commit,
+  createProvider,
+  createReleaseStrategy,
+  debug,
+  deleteReleasePlan,
+  detectWorkspaceRoot,
+  ensureDir,
+  ensureGitignored,
+  env_exports as env,
+  error,
+  fileExists,
+  finishRelease,
+  getApiKey,
+  getMergedConfig,
+  git_exports as git,
+  github_exports as github,
+  heuristicBump,
+  info,
+  interpolate,
+  isVerbose,
+  loadAndInterpolate,
+  loadReleasePlan,
+  loadTemplate,
+  parseCommitResponse,
+  pr,
+  prepareRelease,
+  propagateVersionToWorkspaces,
+  readJSON,
+  readRepoConfig,
+  readUserConfig,
+  release,
+  resolveClaudeBinary,
+  resolveModelTier,
+  review,
+  runReleaseInProcess,
+  saveReleasePlan,
+  setVerbose,
+  stashList,
+  takeNamedStashStep,
+  version,
+  warn,
+  wrapError,
+  writeApiKey,
+  writeJSON,
+  writeUserConfig,
+  writeWorkspaceVersionStep
+};
+//# sourceMappingURL=index.js.map