@denisvieiradev/gitwise-core 0.1.0 → 1.3.0

package/dist/index.js

@@ -7,7 +7,7 @@ var __export = (target, all) => {
 // package.json
 var package_default = {
   name: "@denisvieiradev/gitwise-core",
-  version: "0.1.0",
+  version: "1.3.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",
@@ -60,7 +60,7 @@ var package_default = {
     node: ">=22.12.0"
   },
   dependencies: {
-    "@anthropic-ai/sdk": "^0.109.0"
+    "@anthropic-ai/sdk": "^0.127.0"
   }
 };
 
@@ -486,10 +486,10 @@ async function stashDropNamed(cwd, stashName) {
 async function cleanForced(cwd) {
   await run(["clean", "-fd"], cwd);
 }
-async function showFileAtHead(cwd, path3) {
-  debug("git command", { args: ["show", `HEAD:${path3}`], cwd });
+async function showFileAtHead(cwd, path7) {
+  debug("git command", { args: ["show", `HEAD:${path7}`], cwd });
   try {
-    const result = await exec("git", ["show", `HEAD:${path3}`], {
+    const result = await exec("git", ["show", `HEAD:${path7}`], {
       cwd,
       timeout: GIT_TIMEOUT_MS,
       maxBuffer: GIT_MAX_BUFFER
@@ -890,22 +890,16 @@ function defaultIsProcessAlive(pid) {
 }
 
 // src/providers/claude-code.ts
-import { execFile as execFile3, execSync, spawn } from "child_process";
+import os2 from "os";
+import path3 from "path";
+
+// src/providers/cli-subprocess.ts
+import { 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")
-];
+import { StringDecoder } from "string_decoder";
+import { clearTimeout, setTimeout as setTimeout2 } from "timers";
 function isExecutable(filePath) {
   try {
     fs.accessSync(filePath, fs.constants.X_OK);
@@ -914,207 +908,441 @@ function isExecutable(filePath) {
     return false;
   }
 }
-function resolveClaudeBinary(customPath) {
-  if (customPath) {
-    if (isExecutable(customPath)) return customPath;
-    return null;
-  }
-  for (const candidate of COMMON_CLAUDE_PATHS) {
+function resolveCliBinary(name, commonPaths, customPath) {
+  if (customPath) return isExecutable(customPath) ? customPath : null;
+  for (const candidate of commonPaths) {
     if (isExecutable(candidate)) return candidate;
   }
   try {
-    const found = execSync("which claude", { stdio: "pipe" }).toString().trim();
+    const found = execSync(`which ${name}`, { 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");
+    for (const version2 of fs.readdirSync(nvmDir)) {
+      const candidate = path2.join(nvmDir, version2, "bin", name);
       if (isExecutable(candidate)) return candidate;
     }
   } catch {
   }
   return null;
 }
-var ClaudeCodeProvider = class {
-  models;
-  claudeBinaryPath;
-  constructor(models, claudeCliPath) {
+var LARGE_PROMPT_THRESHOLD = 1e5;
+var DEFAULT_TIMEOUT_MS = 12e4;
+var KILL_GRACE_MS = 5e3;
+var CliSubprocessProvider = class {
+  constructor(spec, models, cliPath) {
+    this.spec = spec;
     this.models = models;
-    this.claudeBinaryPath = claudeCliPath ?? resolveClaudeBinary() ?? "claude";
+    this.binaryPath = cliPath || spec.resolveBinary() || spec.defaultCommand;
   }
+  binaryPath;
   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);
+    const modelId = this.models[req.tier];
+    debug(`Calling ${this.spec.toolName}`, { model: modelId, tier: req.tier, binary: this.binaryPath });
+    const prompt = this.spec.foldSystemPrompt ? `${req.systemPrompt}
+
+${req.userMessage}` : req.userMessage;
+    const large = Buffer.byteLength(prompt, "utf8") > LARGE_PROMPT_THRESHOLD;
+    const args = this.spec.buildArgs({ prompt, systemPrompt: req.systemPrompt, modelId, large });
+    const stdout = await this.spawnCli(args, large ? prompt : "");
+    const parsed = this.spec.parseOutput(stdout);
     return {
-      content: result.result,
-      tokens: {
-        input: result.usage.input_tokens,
-        output: result.usage.output_tokens
-      }
+      content: parsed.content,
+      tokens: parsed.tokens ?? { input: 0, output: 0 },
+      tokensAvailable: parsed.tokens !== null
     };
   }
-  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: "" }
+  spawnCli(args, input) {
+    return new Promise((resolve, reject) => {
+      const ownGroup = process.platform !== "win32";
+      const child = spawn(this.binaryPath, args, {
+        stdio: ["pipe", "pipe", "pipe"],
+        detached: ownGroup
       });
-      return this.parseResponse(stdout);
-    } catch (err) {
-      const execErr = err;
-      if (execErr.stdout) {
+      const killTree = (sig) => {
         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;
-          }
+          if (ownGroup && child.pid !== void 0) process.kill(-child.pid, sig);
+          else child.kill(sig);
+        } catch {
         }
+      };
+      const timeoutMs = this.spec.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+      let timedOut = false;
+      let escalation;
+      const timer = setTimeout2(() => {
+        timedOut = true;
+        killTree("SIGTERM");
+        escalation = setTimeout2(() => killTree("SIGKILL"), KILL_GRACE_MS);
+        escalation.unref();
+      }, timeoutMs);
+      const reapOnExit = () => killTree("SIGKILL");
+      let interruptedBy;
+      const onSignal = (sig) => {
+        interruptedBy = sig;
+        killTree("SIGKILL");
+        reject(new Error(`${this.spec.toolName} was interrupted by ${sig}`));
+        cleanup();
+        if (process.listenerCount(sig) === 0) process.kill(process.pid, sig);
+      };
+      const onSigint = () => onSignal("SIGINT");
+      const onSigterm = () => onSignal("SIGTERM");
+      process.once("exit", reapOnExit);
+      process.on("SIGINT", onSigint);
+      process.on("SIGTERM", onSigterm);
+      function cleanup() {
+        clearTimeout(timer);
+        clearTimeout(escalation);
+        process.off("exit", reapOnExit);
+        process.off("SIGINT", onSigint);
+        process.off("SIGTERM", onSigterm);
       }
-      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 = "";
+      const outDecoder = new StringDecoder("utf8");
+      const errDecoder = new StringDecoder("utf8");
       child.stdout.on("data", (data) => {
-        stdout += data.toString();
+        stdout += outDecoder.write(data);
       });
       child.stderr.on("data", (data) => {
-        stderr += data.toString();
+        stderr += errDecoder.write(data);
       });
-      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}` : ""}`
-            )
-          );
+      child.on("close", (code, signal) => {
+        if (timedOut) killTree("SIGKILL");
+        cleanup();
+        stdout += outDecoder.end();
+        stderr += errDecoder.end();
+        if (interruptedBy) return;
+        if (timedOut) {
+          reject(new Error(`${this.spec.toolName} timed out after ${Math.round(timeoutMs / 1e3)}s`));
           return;
         }
-        try {
-          resolve(this.parseResponse(stdout));
-        } catch (err) {
-          reject(err);
+        if (code === null && signal) {
+          reject(new Error(`${this.spec.toolName} was terminated by signal ${signal}`));
+          return;
         }
+        if (code !== 0) {
+          reject(new Error(this.exitErrorMessage(code, stdout, stderr)));
+          return;
+        }
+        resolve(stdout);
       });
       child.on("error", (err) => {
+        cleanup();
         reject(this.wrapError(err));
       });
+      child.stdin.on("error", () => void 0);
       child.stdin.write(input);
       child.stdin.end();
     });
   }
-  parseResponse(stdout) {
+  exitErrorMessage(code, stdout, stderr) {
+    if (this.spec.formatExitError) return this.spec.formatExitError(code, stdout, stderr);
+    const trimmed = stderr.trim();
+    return `${this.spec.toolName} exited with code ${code}${trimmed ? `: ${trimmed}` : ""}`;
+  }
+  wrapError(err) {
+    const message = err instanceof Error ? err.message : String(err?.message ?? err);
+    const code = err?.code;
+    if (code === "ENOENT" || message.includes("ENOENT")) {
+      return new GitwiseError({
+        code: "PROVIDER_UNAVAILABLE",
+        message: `${this.spec.toolName} not found at "${this.binaryPath}". ${this.spec.installHint}`,
+        exitCode: EXIT_CODES.API_FAILED,
+        cause: err
+      });
+    }
+    return err instanceof Error ? err : new Error(message);
+  }
+};
+
+// src/providers/claude-code.ts
+var COMMON_CLAUDE_PATHS = [
+  // Native installs (Homebrew, manual) — preferred over npm
+  "/opt/homebrew/bin/claude",
+  "/usr/local/bin/claude",
+  path3.join(os2.homedir(), ".claude", "local", "claude"),
+  // npm global installs — fallback
+  path3.join(os2.homedir(), ".npm-global", "bin", "claude")
+];
+function resolveClaudeBinary(customPath) {
+  return resolveCliBinary("claude", COMMON_CLAUDE_PATHS, customPath);
+}
+var claudeCodeSpec = {
+  toolName: "Claude Code CLI",
+  installHint: "Re-run `gw config` to reconfigure.",
+  defaultCommand: "claude",
+  foldSystemPrompt: false,
+  resolveBinary: resolveClaudeBinary,
+  buildArgs({ prompt, systemPrompt, modelId, large }) {
+    return [
+      "-p",
+      ...large ? [] : [prompt],
+      "--system-prompt",
+      systemPrompt,
+      "--model",
+      modelId,
+      "--output-format",
+      "json"
+    ];
+  },
+  parseOutput(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
+      content: parsed.result ?? "",
+      tokens: {
+        input: parsed.usage?.input_tokens ?? 0,
+        output: parsed.usage?.output_tokens ?? 0
+      }
     };
+  },
+  formatExitError(code, stdout, stderr) {
+    if (stdout) {
+      try {
+        const parsed = JSON.parse(stdout);
+        if (parsed.is_error) return `Claude CLI error: ${parsed.result}`;
+      } catch {
+      }
+    }
+    const filteredStderr = stderr.replace(/Warning: no stdin data.*\n?/g, "").trim();
+    return `Claude CLI exited with code ${code}${filteredStderr ? `: ${filteredStderr}` : ""}`;
   }
-  resolveModel(tier) {
-    return this.models[tier];
+};
+var ClaudeCodeProvider = class extends CliSubprocessProvider {
+  constructor(models, claudeCliPath) {
+    super(claudeCodeSpec, models, claudeCliPath);
   }
-  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
-        });
+};
+
+// src/providers/codex.ts
+import os3 from "os";
+import path4 from "path";
+var COMMON_CODEX_PATHS = [
+  // Native installs (Homebrew cask, manual, standalone installer) — preferred over npm
+  "/opt/homebrew/bin/codex",
+  "/usr/local/bin/codex",
+  path4.join(os3.homedir(), ".local", "bin", "codex"),
+  // npm global installs (`npm install -g @openai/codex`) — fallback
+  path4.join(os3.homedir(), ".npm-global", "bin", "codex")
+];
+function resolveCodexBinary(customPath) {
+  return resolveCliBinary("codex", COMMON_CODEX_PATHS, customPath);
+}
+function parseEvents(stdout) {
+  const events = [];
+  for (const line of stdout.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    try {
+      events.push(JSON.parse(trimmed));
+    } catch {
+    }
+  }
+  return events;
+}
+var codexSpec = {
+  toolName: "Codex CLI",
+  installHint: "Install it (`npm install -g @openai/codex`) or re-run `gw provider` to choose another provider.",
+  defaultCommand: "codex",
+  foldSystemPrompt: true,
+  // Full agent turns take longer than a single Claude Code completion.
+  timeoutMs: 3e5,
+  resolveBinary: resolveCodexBinary,
+  buildArgs({ prompt, modelId, large }) {
+    return [
+      "exec",
+      "--json",
+      "--ephemeral",
+      "--skip-git-repo-check",
+      "--sandbox",
+      "read-only",
+      "--model",
+      modelId,
+      "--",
+      large ? "-" : prompt
+    ];
+  },
+  parseOutput(stdout) {
+    let content;
+    let tokens = null;
+    for (const event of parseEvents(stdout)) {
+      if (event.type === "item.completed" && event.item?.type === "agent_message") {
+        content = event.item.text ?? "";
+      } else if (event.type === "turn.completed" && event.usage) {
+        tokens = {
+          input: event.usage.input_tokens ?? 0,
+          output: event.usage.output_tokens ?? 0
+        };
       }
-      return err;
     }
-    return new Error(String(err));
+    if (content === void 0) {
+      throw new Error("Codex CLI returned no final agent message");
+    }
+    return { content, tokens };
+  },
+  // The CLI's own error text lives in the JSONL stream, not stderr; surface it
+  // verbatim, falling back to stderr when the stream carries none.
+  formatExitError(code, stdout, stderr) {
+    const messages = /* @__PURE__ */ new Set();
+    for (const event of parseEvents(stdout)) {
+      if (event.type === "error" && event.message) messages.add(event.message);
+      if (event.type === "turn.failed" && event.error?.message) messages.add(event.error.message);
+    }
+    const detail = messages.size > 0 ? [...messages].join("\n") : stderr.trim();
+    return `Codex CLI exited with code ${code}${detail ? `: ${detail}` : ""}`;
+  }
+};
+
+// src/providers/copilot.ts
+import os4 from "os";
+import path5 from "path";
+var COMMON_COPILOT_PATHS = [
+  // Native/Homebrew installs — preferred over npm
+  "/opt/homebrew/bin/copilot",
+  "/usr/local/bin/copilot",
+  // Copilot's install script (non-root) target
+  path5.join(os4.homedir(), ".local", "bin", "copilot"),
+  // npm global installs (`npm install -g @github/copilot`) — fallback
+  path5.join(os4.homedir(), ".npm-global", "bin", "copilot")
+];
+function resolveCopilotBinary(customPath) {
+  return resolveCliBinary("copilot", COMMON_COPILOT_PATHS, customPath);
+}
+var copilotSpec = {
+  toolName: "Copilot CLI",
+  installHint: "Install it (`npm install -g @github/copilot`) or re-run `gw provider` to choose another provider.",
+  defaultCommand: "copilot",
+  foldSystemPrompt: true,
+  // Full agent turns take longer than a single Claude Code completion.
+  timeoutMs: 3e5,
+  resolveBinary: resolveCopilotBinary,
+  buildArgs({ prompt, modelId, large }) {
+    return [...large ? [] : [`--prompt=${prompt}`], "--no-ask-user", "--silent", "--model", modelId];
+  },
+  parseOutput(stdout) {
+    const content = stdout.trim();
+    if (!content) throw new Error("Copilot CLI returned an empty response");
+    return { content, tokens: null };
+  }
+};
+
+// src/providers/kiro.ts
+import os5 from "os";
+import path6 from "path";
+import { stripVTControlCharacters } from "util";
+var COMMON_KIRO_PATHS = [
+  // macOS app bundle and the installer's symlink location — preferred
+  "/Applications/Kiro CLI.app/Contents/MacOS/kiro-cli",
+  path6.join(os5.homedir(), ".local", "bin", "kiro-cli"),
+  "/opt/homebrew/bin/kiro-cli",
+  "/usr/local/bin/kiro-cli"
+];
+function resolveKiroBinary(customPath) {
+  return resolveCliBinary("kiro-cli", COMMON_KIRO_PATHS, customPath);
+}
+var kiroSpec = {
+  toolName: "Kiro CLI",
+  installHint: "Install it from https://kiro.dev/docs/cli/ or re-run `gw provider` to choose another provider.",
+  defaultCommand: "kiro-cli",
+  foldSystemPrompt: true,
+  // Full agent turns take longer than a single Claude Code completion.
+  timeoutMs: 3e5,
+  resolveBinary: resolveKiroBinary,
+  buildArgs({ prompt, modelId, large }) {
+    return [
+      "chat",
+      "--no-interactive",
+      "--trust-tools=",
+      "--wrap",
+      "never",
+      "--model",
+      modelId,
+      // `--` (standard for kiro-cli's clap-style parser) keeps a prompt that
+      // starts with "-" from being read as an option.
+      ...large ? [] : ["--", prompt]
+    ];
+  },
+  parseOutput(stdout) {
+    const content = stripVTControlCharacters(stdout).trim();
+    if (!content) throw new Error("Kiro CLI returned an empty response");
+    return { content, tokens: null };
+  },
+  formatExitError(code, stdout, stderr) {
+    const detail = stderr.trim() || stripVTControlCharacters(stdout).trim();
+    return `Kiro CLI exited with code ${code}${detail ? `: ${detail}` : ""}`;
   }
 };
 
 // src/config/types.ts
+var CLAUDE_MODELS = {
+  fast: "claude-haiku-4-5-20251001",
+  balanced: "claude-sonnet-4-6",
+  powerful: "claude-opus-4-7"
+};
 var DEFAULT_USER_CONFIG = {
   provider: "api",
   models: {
-    fast: "claude-haiku-4-5-20251001",
-    balanced: "claude-sonnet-4-6",
-    powerful: "claude-opus-4-7"
+    api: { ...CLAUDE_MODELS },
+    "claude-code": { ...CLAUDE_MODELS },
+    codex: {
+      fast: "gpt-6-luna",
+      balanced: "gpt-6-sol",
+      powerful: "gpt-6-astra"
+    },
+    copilot: {
+      fast: "claude-haiku-4.5",
+      balanced: "claude-sonnet-4.6",
+      powerful: "claude-opus-4.7"
+    },
+    kiro: {
+      fast: "claude-haiku-4.5",
+      balanced: "claude-sonnet-4.5",
+      powerful: "claude-sonnet-4.5"
+    }
   },
   language: "en",
   commitConvention: "conventional"
 };
 
 // src/config/merge.ts
-import os3 from "os";
+import os7 from "os";
 
 // src/config/user.ts
 import { join as join2 } from "path";
-import os2 from "os";
+import os6 from "os";
+
+// src/providers/types.ts
+var PROVIDER_KINDS = ["api", "claude-code", "codex", "copilot", "kiro"];
+
+// src/config/user.ts
 var GITWISE_DIR = ".gitwise";
 var USER_CONFIG_FILE = "config.json";
 function getUserConfigPath(homeDir) {
-  return join2(homeDir ?? os2.homedir(), GITWISE_DIR, USER_CONFIG_FILE);
+  return join2(homeDir ?? os6.homedir(), GITWISE_DIR, USER_CONFIG_FILE);
+}
+function isLegacyFlatModels(value) {
+  if (!value || typeof value !== "object") return false;
+  const v = value;
+  return typeof v["fast"] === "string" && typeof v["balanced"] === "string" && typeof v["powerful"] === "string";
+}
+function migrateFlatModels(flat, provider) {
+  const target = provider === void 0 ? DEFAULT_USER_CONFIG.provider : provider;
+  const migrated = { ...DEFAULT_USER_CONFIG.models };
+  if (typeof target === "string" && PROVIDER_KINDS.includes(target)) {
+    migrated[target] = { ...flat };
+  }
+  return migrated;
 }
 function mergeWithDefaults(partial) {
-  return {
-    ...DEFAULT_USER_CONFIG,
-    ...partial,
-    models: {
-      ...DEFAULT_USER_CONFIG.models,
-      ...partial.models ?? {}
-    }
-  };
+  const models = {};
+  for (const kind of PROVIDER_KINDS) {
+    models[kind] = { ...DEFAULT_USER_CONFIG.models[kind], ...partial.models?.[kind] ?? {} };
+  }
+  return { ...DEFAULT_USER_CONFIG, ...partial, models };
 }
 async function readUserConfig(homeDir) {
   const configPath = getUserConfigPath(homeDir);
@@ -1123,6 +1351,17 @@ async function readUserConfig(homeDir) {
     return { ...DEFAULT_USER_CONFIG };
   }
   const raw = await readJSON(configPath);
+  if (isLegacyFlatModels(raw.models)) {
+    const migratedModels = migrateFlatModels(raw.models, raw.provider);
+    const merged = mergeWithDefaults({ ...raw, models: migratedModels });
+    debug("Migrated legacy flat models config to per-provider shape", { path: configPath });
+    try {
+      await writeJSON(configPath, merged);
+    } catch (err) {
+      debug("Could not persist migrated config; using it in memory", { path: configPath, error: String(err) });
+    }
+    return merged;
+  }
   return mergeWithDefaults(raw);
 }
 async function writeUserConfig(partial, homeDir) {
@@ -1133,7 +1372,7 @@ async function writeUserConfig(partial, homeDir) {
   await writeJSON(configPath, updated);
 }
 async function writeApiKey(value, homeDir) {
-  const home = homeDir ?? os2.homedir();
+  const home = homeDir ?? os6.homedir();
   await writeEnvVar(home, "ANTHROPIC_API_KEY", value);
 }
 
@@ -1160,6 +1399,26 @@ async function readRepoConfig(cwd) {
 }
 
 // src/config/merge.ts
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+var MODEL_TIERS = ["fast", "balanced", "powerful"];
+function mergeRepoModels(base, override) {
+  if (!isPlainObject(override)) return base.models;
+  const source = override;
+  const flat = {};
+  for (const tier of MODEL_TIERS) {
+    const value = source[tier];
+    if (typeof value === "string") flat[tier] = value;
+  }
+  const merged = { ...base.models };
+  merged[base.provider] = { ...base.models[base.provider], ...flat };
+  for (const kind of PROVIDER_KINDS) {
+    const block = source[kind];
+    if (isPlainObject(block)) merged[kind] = { ...merged[kind], ...block };
+  }
+  return merged;
+}
 function deepMerge(base, override) {
   return {
     ...base,
@@ -1169,10 +1428,7 @@ function deepMerge(base, override) {
     ...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 ?? {}
-    }
+    models: mergeRepoModels(base, override.models)
   };
 }
 async function getMergedConfig(options) {
@@ -1185,7 +1441,7 @@ async function getMergedConfig(options) {
   return deepMerge(userConfig, repoConfig);
 }
 async function getApiKey(homeDir) {
-  const home = homeDir ?? os3.homedir();
+  const home = homeDir ?? os7.homedir();
   return read("ANTHROPIC_API_KEY", home);
 }
 
@@ -1193,7 +1449,7 @@ async function getApiKey(homeDir) {
 import { readFile as readFile4 } from "fs/promises";
 import { dirname as dirname2, join as join4 } from "path";
 import { fileURLToPath } from "url";
-import os4 from "os";
+import os8 from "os";
 
 // src/template/interpolate.ts
 function interpolate(template, ctx) {
@@ -1221,7 +1477,7 @@ function validateTemplateName(name) {
 async function loadTemplate(name, options = {}) {
   validateTemplateName(name);
   const repoRoot = options.repoRoot ?? process.cwd();
-  const userTemplatesPath = options.templatesPath ?? join4(os4.homedir(), ".gitwise", "templates");
+  const userTemplatesPath = options.templatesPath ?? join4(os8.homedir(), ".gitwise", "templates");
   const repoOverride = join4(repoRoot, ".gitwise", "templates", `${name}.md`);
   if (await fileExists(repoOverride)) {
     debug("Loading repo-level template override", { path: repoOverride });
@@ -1462,20 +1718,22 @@ IMPORTANT: Generate exactly 3 different alternative commit messages. Return JSON
   const response = await provider.chat({ systemPrompt: effectiveSystemPrompt, userMessage, tier });
   const parsed = parseCommitResponse(response.content);
   const tokens = { input: response.tokens.input, output: response.tokens.output };
+  const tokensAvailable = response.tokensAvailable;
   if (opts.generateAlternatives) {
     const options = parseAlternativesResponse(response.content);
     if (options && options.length > 0) {
-      return { kind: "alternatives", options, tokens };
+      return { kind: "alternatives", options, tokens, tokensAvailable };
     }
     const fallbackMsg = parsed.type === "single" ? parsed.message : parsed.commits[0]?.message ?? response.content.trim().slice(0, 100);
-    return { kind: "alternatives", options: [fallbackMsg], tokens };
+    return { kind: "alternatives", options: [fallbackMsg], tokens, tokensAvailable };
   }
   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
+      tokens,
+      tokensAvailable
     };
   }
   if (parsed.type === "plan" && parsed.commits.length > 1) {
@@ -1488,7 +1746,8 @@ IMPORTANT: Generate exactly 3 different alternative commit messages. Return JSON
       return {
         kind: "split",
         commits: parsed.commits,
-        tokens
+        tokens,
+        tokensAvailable
       };
     }
   }
@@ -1503,7 +1762,8 @@ IMPORTANT: Generate exactly 3 different alternative commit messages. Return JSON
   return {
     kind: "single",
     commits: [{ message, files: stagedFiles }],
-    tokens
+    tokens,
+    tokensAvailable
   };
 }
 function takeNamedStashStep(cwd, stashName) {
@@ -1713,7 +1973,8 @@ Additional context: ${prompt}` : "");
     suggestions: parsed.suggestions,
     nitpicks: parsed.nitpicks,
     markdown,
-    tokens
+    tokens,
+    tokensAvailable: response.tokensAvailable
   };
 }
 async function resolveBaseBranch(cwd) {
@@ -1740,9 +2001,9 @@ ${stderr}`;
 }
 
 // src/commands/pr.ts
-import { execFile as execFile4 } from "child_process";
-import { promisify as promisify4 } from "util";
-var exec3 = promisify4(execFile4);
+import { execFile as execFile3 } from "child_process";
+import { promisify as promisify3 } from "util";
+var exec3 = promisify3(execFile3);
 function parsePrResponse(content) {
   const titleMatch = content.match(/^TITLE:\s*(.+)$/m);
   const title = titleMatch ? titleMatch[1].trim() : "Update";
@@ -1821,7 +2082,8 @@ Additional context: ${prompt}` : "");
     title,
     body,
     existingPrNumber,
-    tokens
+    tokens,
+    tokensAvailable: response.tokensAvailable
   };
 }
 async function applyPr(draft, opts) {
@@ -1938,7 +2200,7 @@ async function loadReleasePlan(cwd) {
       exitCode: EXIT_CODES.CONFIG_INVALID
     });
   }
-  return parsed;
+  return { ...parsed, tokensAvailable: parsed.tokensAvailable ?? true };
 }
 function isPersistedReleasePlan(value) {
   if (!value || typeof value !== "object") return false;
@@ -1961,6 +2223,7 @@ function isPersistedReleasePlan(value) {
   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;
+  if (p.tokensAvailable !== void 0 && typeof p.tokensAvailable !== "boolean") return false;
   return true;
 }
 async function deleteReleasePlan(cwd) {
@@ -2092,6 +2355,7 @@ async function release(opts) {
   const tier = resolveModelTier("release");
   let totalInput = 0;
   let totalOutput = 0;
+  let tokensAvailable = true;
   let suggestedBump;
   if (opts.bump) {
     suggestedBump = opts.bump;
@@ -2109,6 +2373,7 @@ ${commits}`,
     });
     totalInput += versionResponse.tokens.input;
     totalOutput += versionResponse.tokens.output;
+    tokensAvailable = versionResponse.tokensAvailable;
     const suggestion = parseVersionSuggestion(versionResponse.content);
     suggestedBump = suggestion?.suggestion ?? heuristicBump(commits);
   }
@@ -2126,6 +2391,7 @@ ${commits}`,
   });
   totalInput += changelogResponse.tokens.input;
   totalOutput += changelogResponse.tokens.output;
+  tokensAvailable = tokensAvailable && changelogResponse.tokensAvailable;
   const changelog = changelogResponse.content;
   const notesTemplate = await loadTemplate("release-notes", templateOpts);
   const notesPrompt = interpolate(notesTemplate, {
@@ -2144,6 +2410,7 @@ ${commits}`,
   });
   totalInput += notesResponse.tokens.input;
   totalOutput += notesResponse.tokens.output;
+  tokensAvailable = tokensAvailable && notesResponse.tokensAvailable;
   const notes = notesResponse.content;
   return {
     suggestedBump,
@@ -2152,7 +2419,8 @@ ${commits}`,
     changelog,
     notes,
     commits,
-    tokens: { input: totalInput, output: totalOutput }
+    tokens: { input: totalInput, output: totalOutput },
+    tokensAvailable
   };
 }
 function createReleaseBranchStep(cwd, branchName, startPoint) {
@@ -2300,10 +2568,10 @@ async function prepareRelease(opts) {
   });
   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;
+      const path7 = line.slice(3).trim();
+      if (path7 === ".gitignore") return false;
+      if (path7 === ".gitwise/" || path7 === ".gitwise") return false;
+      if (path7.startsWith(".gitwise/")) return false;
       return true;
     });
     if (dirtyEntries.length > 0) {
@@ -2401,7 +2669,8 @@ ${dirtyEntries.join("\n")}`,
         baseCommit,
         targetBranch,
         releaseBranchCreated: releaseBranch !== null,
-        tokens: plan.tokens
+        tokens: plan.tokens,
+        tokensAvailable: plan.tokensAvailable
       };
       await tx.run(savePlanStep(cwd, persistedPlan));
       debug("release.prepare.plan.saved", {
@@ -2466,13 +2735,36 @@ ${dirty}`,
     baseCommit: await headSha(cwd),
     targetBranch: await getBranch(cwd),
     releaseBranchCreated: false,
-    tokens: plan.tokens
+    tokens: plan.tokens,
+    tokensAvailable: plan.tokensAvailable
   };
   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 });
 }
+function finishPushFailure(opts) {
+  const { stage, tag, mainBranch, developBranch, newVersion, err } = opts;
+  const cause = err instanceof Error ? err.message : String(err);
+  const action = stage === "tag" ? `create the tag "${tag}"` : stage === "push-main" ? `push "${mainBranch}" (with tags) to origin` : `push "${developBranch}" to origin`;
+  const recoverySteps = stage === "tag" ? [
+    `git tag -a ${tag} -F .gitwise/release-${newVersion}.md`,
+    `git push origin ${mainBranch} --follow-tags`
+  ] : [
+    `git ls-remote --tags origin ${tag}  # check whether the tag already reached origin`,
+    `git fetch origin`,
+    `git merge origin/${mainBranch}  # do NOT rebase \u2014 that changes the hash ${tag} points to`,
+    `git push origin ${mainBranch} --follow-tags`
+  ];
+  return new GitwiseError({
+    code: "FINISH_PUSH_FAILED",
+    message: `Failed to ${action} while finishing v${newVersion}: ${cause}. The release plan file has already been deleted, so "gw release finish" cannot be re-run, and the release commit already exists locally, so "gw release prepare" will refuse with NO_COMMITS. Recover manually:
+${recoverySteps.map((s) => `  ${s}`).join("\n")}`,
+    exitCode: EXIT_CODES.GIT_FAILED,
+    cause: err,
+    details: { stage, tag, mainBranch, developBranch, newVersion }
+  });
+}
 async function finishRelease(opts) {
   const {
     cwd,
@@ -2663,15 +2955,27 @@ ${cause}`,
     await checkout(cwd, mainBranch);
   }
   if (tagAndPush) {
-    await createTag(cwd, tag, notes, { signed: signTags !== false });
-    await pushWithTags(cwd, "origin", mainBranch);
+    try {
+      await createTag(cwd, tag, notes, { signed: signTags !== false });
+    } catch (err) {
+      throw finishPushFailure({ stage: "tag", tag, mainBranch, newVersion: plan.newVersion, err });
+    }
+    try {
+      await pushWithTags(cwd, "origin", mainBranch);
+    } catch (err) {
+      throw finishPushFailure({ stage: "push-main", tag, mainBranch, newVersion: plan.newVersion, err });
+    }
     debug("release.finish.tag.pushed", {
       tag,
       branch: mainBranch,
       remote: "origin"
     });
     if (strategy.requiresDevelop()) {
-      await push(cwd, "origin", developBranch);
+      try {
+        await push(cwd, "origin", developBranch);
+      } catch (err) {
+        throw finishPushFailure({ stage: "push-develop", tag, mainBranch, developBranch, newVersion: plan.newVersion, err });
+      }
     }
   }
   if (createGhRelease) {
@@ -2781,13 +3085,35 @@ async function gitignoreMatchesPrepareOutput(cwd) {
   expected = applyGitignoreEntry(expected, RELEASE_NOTES_GLOB_REL_PATH);
   return currentContent === expected;
 }
-function writeWorkspaceVersionStep(manifestPath, newVersion) {
+var CROSS_WORKSPACE_DEPENDENCY_FIELDS = [
+  "dependencies",
+  "devDependencies",
+  "optionalDependencies",
+  "peerDependencies"
+];
+function updateCrossWorkspaceDependencies(parsed, workspaceNames, newVersion) {
+  for (const field of CROSS_WORKSPACE_DEPENDENCY_FIELDS) {
+    const deps = parsed[field];
+    if (!deps || typeof deps !== "object") continue;
+    const depsRecord = deps;
+    for (const depName of Object.keys(depsRecord)) {
+      const spec = depsRecord[depName];
+      if (!workspaceNames.has(depName) || typeof spec !== "string") continue;
+      const prefix = spec.startsWith("^") || spec.startsWith("~") ? spec[0] : "";
+      depsRecord[depName] = `${prefix}${newVersion}`;
+    }
+  }
+}
+function writeWorkspaceVersionStep(manifestPath, newVersion, workspaceNames) {
   return {
     name: `write-version:${manifestPath}`,
     apply: async () => {
       const priorBytes = await readFile6(manifestPath);
       const parsed = JSON.parse(priorBytes.toString("utf-8"));
       parsed["version"] = newVersion;
+      if (workspaceNames && workspaceNames.size > 0) {
+        updateCrossWorkspaceDependencies(parsed, workspaceNames, newVersion);
+      }
       await writeJSON(manifestPath, parsed);
       return priorBytes;
     },
@@ -2826,17 +3152,28 @@ async function propagateVersionToWorkspaces(cwd, version2) {
 async function runWorkspaceVersionStepsInto(tx, cwd, version2) {
   const patterns = await readWorkspacePatterns(cwd);
   const workspaceDirs = (await expandWorkspacePatterns(cwd, patterns)).sort();
+  const workspaceNames = /* @__PURE__ */ new Set();
+  for (const dir of workspaceDirs) {
+    const pkgPath = join6(dir, "package.json");
+    if (!await fileExists(pkgPath)) continue;
+    const parsed = await readJSON(pkgPath);
+    if (typeof parsed.name === "string") workspaceNames.add(parsed.name);
+  }
   const modified = [];
   for (const dir of workspaceDirs) {
     const pkgPath = join6(dir, "package.json");
     if (await fileExists(pkgPath)) {
-      await tx.run(writeWorkspaceVersionStep(pkgPath, version2));
+      await tx.run(writeWorkspaceVersionStep(pkgPath, version2, workspaceNames));
       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));
+    for (const pluginPath of [
+      join6(dir, ".claude-plugin", "plugin.json"),
+      join6(dir, "plugin.json")
+    ]) {
+      if (await fileExists(pluginPath)) {
+        await tx.run(writeWorkspaceVersionStep(pluginPath, version2));
+        modified.push(relative(cwd, pluginPath));
+      }
     }
   }
   return modified;
@@ -2928,6 +3265,11 @@ function segmentToRegex(segment) {
   return new RegExp(`^${escaped}$`);
 }
 
+// src/commands/token-format.ts
+function formatTokens(tokens, tokensAvailable) {
+  return tokensAvailable ? `${tokens.input} in / ${tokens.output} out` : "n/a";
+}
+
 // src/providers/anthropic.ts
 import Anthropic from "@anthropic-ai/sdk";
 var DEFAULT_MAX_TOKENS = 4096;
@@ -2984,7 +3326,8 @@ var AnthropicProvider = class {
       tokens: {
         input: response.usage.input_tokens,
         output: response.usage.output_tokens
-      }
+      },
+      tokensAvailable: true
     };
   }
   resolveModel(tier) {
@@ -3003,10 +3346,36 @@ var AnthropicProvider = class {
 
 // src/providers/factory.ts
 function createProvider(config) {
-  if (config.kind === "claude-code") {
-    return new ClaudeCodeProvider(config.models, config.claudeCliPath);
+  switch (config.kind) {
+    case "claude-code":
+      return new ClaudeCodeProvider(config.models, config.claudeCliPath);
+    case "codex":
+      return new CliSubprocessProvider(codexSpec, config.models, config.codexCliPath);
+    case "copilot":
+      return new CliSubprocessProvider(copilotSpec, config.models, config.copilotCliPath);
+    case "kiro":
+      return new CliSubprocessProvider(kiroSpec, config.models, config.kiroCliPath);
+    case "api":
+      return new AnthropicProvider(config.apiKey, config.models);
+    default: {
+      const unhandled = config.kind;
+      throw new GitwiseError({
+        code: "CONFIG_INVALID",
+        message: `Unknown provider "${String(unhandled)}" in config. Re-run \`gw provider\` to choose a supported provider.`
+      });
+    }
   }
-  return new AnthropicProvider(config.apiKey, config.models);
+}
+function buildProviderConfig(merged, apiKey) {
+  return {
+    kind: merged.provider,
+    models: merged.models[merged.provider],
+    apiKey,
+    claudeCliPath: merged.claudeCliPath,
+    codexCliPath: merged.codexCliPath,
+    copilotCliPath: merged.copilotCliPath,
+    kiroCliPath: merged.kiroCliPath
+  };
 }
 
 // src/index.ts
@@ -3016,6 +3385,7 @@ export {
   DEFAULT_USER_CONFIG,
   EXIT_CODES,
   GitwiseError,
+  PROVIDER_KINDS,
   STALE_LOCK_MS,
   SUPPORTED_COMMANDS,
   Transaction,
@@ -3026,6 +3396,7 @@ export {
   applyOneCommitStep,
   applyPr,
   applyRelease,
+  buildProviderConfig,
   bumpVersion,
   commit2 as commit,
   createProvider,
@@ -3039,6 +3410,7 @@ export {
   error,
   fileExists,
   finishRelease,
+  formatTokens,
   getApiKey,
   getMergedConfig,
   git_exports as git,
@@ -3059,6 +3431,9 @@ export {
   readUserConfig,
   release,
   resolveClaudeBinary,
+  resolveCodexBinary,
+  resolveCopilotBinary,
+  resolveKiroBinary,
   resolveModelTier,
   review,
   runReleaseInProcess,