pivotdude-git-ai 1.0.1

package/dist/index.js

@@ -0,0 +1,2474 @@
+// @bun
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
+var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: __accessProp.bind(mod, key),
+        enumerable: true
+      });
+  if (canCache)
+    cache.set(mod, to);
+  return to;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+
+// node_modules/ignore/index.js
+var require_ignore = __commonJS((exports, module) => {
+  function makeArray(subject) {
+    return Array.isArray(subject) ? subject : [subject];
+  }
+  var UNDEFINED = undefined;
+  var EMPTY = "";
+  var SPACE = " ";
+  var ESCAPE = "\\";
+  var REGEX_TEST_BLANK_LINE = /^\s+$/;
+  var REGEX_INVALID_TRAILING_BACKSLASH = /(?:[^\\]|^)\\$/;
+  var REGEX_REPLACE_LEADING_EXCAPED_EXCLAMATION = /^\\!/;
+  var REGEX_REPLACE_LEADING_EXCAPED_HASH = /^\\#/;
+  var REGEX_SPLITALL_CRLF = /\r?\n/g;
+  var REGEX_TEST_INVALID_PATH = /^\.{0,2}\/|^\.{1,2}$/;
+  var REGEX_TEST_TRAILING_SLASH = /\/$/;
+  var SLASH = "/";
+  var TMP_KEY_IGNORE = "node-ignore";
+  if (typeof Symbol !== "undefined") {
+    TMP_KEY_IGNORE = Symbol.for("node-ignore");
+  }
+  var KEY_IGNORE = TMP_KEY_IGNORE;
+  var define = (object, key, value) => {
+    Object.defineProperty(object, key, { value });
+    return value;
+  };
+  var REGEX_REGEXP_RANGE = /([0-z])-([0-z])/g;
+  var RETURN_FALSE = () => false;
+  var sanitizeRange = (range) => range.replace(REGEX_REGEXP_RANGE, (match, from, to) => from.charCodeAt(0) <= to.charCodeAt(0) ? match : EMPTY);
+  var cleanRangeBackSlash = (slashes) => {
+    const { length } = slashes;
+    return slashes.slice(0, length - length % 2);
+  };
+  var REPLACERS = [
+    [
+      /^\uFEFF/,
+      () => EMPTY
+    ],
+    [
+      /((?:\\\\)*?)(\\?\s+)$/,
+      (_, m1, m2) => m1 + (m2.indexOf("\\") === 0 ? SPACE : EMPTY)
+    ],
+    [
+      /(\\+?)\s/g,
+      (_, m1) => {
+        const { length } = m1;
+        return m1.slice(0, length - length % 2) + SPACE;
+      }
+    ],
+    [
+      /[\\$.|*+(){^]/g,
+      (match) => `\\${match}`
+    ],
+    [
+      /(?!\\)\?/g,
+      () => "[^/]"
+    ],
+    [
+      /^\//,
+      () => "^"
+    ],
+    [
+      /\//g,
+      () => "\\/"
+    ],
+    [
+      /^\^*\\\*\\\*\\\//,
+      () => "^(?:.*\\/)?"
+    ],
+    [
+      /^(?=[^^])/,
+      function startingReplacer() {
+        return !/\/(?!$)/.test(this) ? "(?:^|\\/)" : "^";
+      }
+    ],
+    [
+      /\\\/\\\*\\\*(?=\\\/|$)/g,
+      (_, index, str) => index + 6 < str.length ? "(?:\\/[^\\/]+)*" : "\\/.+"
+    ],
+    [
+      /(^|[^\\]+)(\\\*)+(?=.+)/g,
+      (_, p1, p2) => {
+        const unescaped = p2.replace(/\\\*/g, "[^\\/]*");
+        return p1 + unescaped;
+      }
+    ],
+    [
+      /\\\\\\(?=[$.|*+(){^])/g,
+      () => ESCAPE
+    ],
+    [
+      /\\\\/g,
+      () => ESCAPE
+    ],
+    [
+      /(\\)?\[([^\]/]*?)(\\*)($|\])/g,
+      (match, leadEscape, range, endEscape, close) => leadEscape === ESCAPE ? `\\[${range}${cleanRangeBackSlash(endEscape)}${close}` : close === "]" ? endEscape.length % 2 === 0 ? `[${sanitizeRange(range)}${endEscape}]` : "[]" : "[]"
+    ],
+    [
+      /(?:[^*])$/,
+      (match) => /\/$/.test(match) ? `${match}$` : `${match}(?=$|\\/$)`
+    ]
+  ];
+  var REGEX_REPLACE_TRAILING_WILDCARD = /(^|\\\/)?\\\*$/;
+  var MODE_IGNORE = "regex";
+  var MODE_CHECK_IGNORE = "checkRegex";
+  var UNDERSCORE = "_";
+  var TRAILING_WILD_CARD_REPLACERS = {
+    [MODE_IGNORE](_, p1) {
+      const prefix = p1 ? `${p1}[^/]+` : "[^/]*";
+      return `${prefix}(?=$|\\/$)`;
+    },
+    [MODE_CHECK_IGNORE](_, p1) {
+      const prefix = p1 ? `${p1}[^/]*` : "[^/]*";
+      return `${prefix}(?=$|\\/$)`;
+    }
+  };
+  var makeRegexPrefix = (pattern) => REPLACERS.reduce((prev, [matcher, replacer]) => prev.replace(matcher, replacer.bind(pattern)), pattern);
+  var isString = (subject) => typeof subject === "string";
+  var checkPattern = (pattern) => pattern && isString(pattern) && !REGEX_TEST_BLANK_LINE.test(pattern) && !REGEX_INVALID_TRAILING_BACKSLASH.test(pattern) && pattern.indexOf("#") !== 0;
+  var splitPattern = (pattern) => pattern.split(REGEX_SPLITALL_CRLF).filter(Boolean);
+
+  class IgnoreRule {
+    constructor(pattern, mark, body, ignoreCase, negative, prefix) {
+      this.pattern = pattern;
+      this.mark = mark;
+      this.negative = negative;
+      define(this, "body", body);
+      define(this, "ignoreCase", ignoreCase);
+      define(this, "regexPrefix", prefix);
+    }
+    get regex() {
+      const key = UNDERSCORE + MODE_IGNORE;
+      if (this[key]) {
+        return this[key];
+      }
+      return this._make(MODE_IGNORE, key);
+    }
+    get checkRegex() {
+      const key = UNDERSCORE + MODE_CHECK_IGNORE;
+      if (this[key]) {
+        return this[key];
+      }
+      return this._make(MODE_CHECK_IGNORE, key);
+    }
+    _make(mode, key) {
+      const str = this.regexPrefix.replace(REGEX_REPLACE_TRAILING_WILDCARD, TRAILING_WILD_CARD_REPLACERS[mode]);
+      const regex = this.ignoreCase ? new RegExp(str, "i") : new RegExp(str);
+      return define(this, key, regex);
+    }
+  }
+  var createRule = ({
+    pattern,
+    mark
+  }, ignoreCase) => {
+    let negative = false;
+    let body = pattern;
+    if (body.indexOf("!") === 0) {
+      negative = true;
+      body = body.substr(1);
+    }
+    body = body.replace(REGEX_REPLACE_LEADING_EXCAPED_EXCLAMATION, "!").replace(REGEX_REPLACE_LEADING_EXCAPED_HASH, "#");
+    const regexPrefix = makeRegexPrefix(body);
+    return new IgnoreRule(pattern, mark, body, ignoreCase, negative, regexPrefix);
+  };
+
+  class RuleManager {
+    constructor(ignoreCase) {
+      this._ignoreCase = ignoreCase;
+      this._rules = [];
+    }
+    _add(pattern) {
+      if (pattern && pattern[KEY_IGNORE]) {
+        this._rules = this._rules.concat(pattern._rules._rules);
+        this._added = true;
+        return;
+      }
+      if (isString(pattern)) {
+        pattern = {
+          pattern
+        };
+      }
+      if (checkPattern(pattern.pattern)) {
+        const rule = createRule(pattern, this._ignoreCase);
+        this._added = true;
+        this._rules.push(rule);
+      }
+    }
+    add(pattern) {
+      this._added = false;
+      makeArray(isString(pattern) ? splitPattern(pattern) : pattern).forEach(this._add, this);
+      return this._added;
+    }
+    test(path, checkUnignored, mode) {
+      let ignored = false;
+      let unignored = false;
+      let matchedRule;
+      this._rules.forEach((rule) => {
+        const { negative } = rule;
+        if (unignored === negative && ignored !== unignored || negative && !ignored && !unignored && !checkUnignored) {
+          return;
+        }
+        const matched = rule[mode].test(path);
+        if (!matched) {
+          return;
+        }
+        ignored = !negative;
+        unignored = negative;
+        matchedRule = negative ? UNDEFINED : rule;
+      });
+      const ret = {
+        ignored,
+        unignored
+      };
+      if (matchedRule) {
+        ret.rule = matchedRule;
+      }
+      return ret;
+    }
+  }
+  var throwError = (message, Ctor) => {
+    throw new Ctor(message);
+  };
+  var checkPath = (path, originalPath, doThrow) => {
+    if (!isString(path)) {
+      return doThrow(`path must be a string, but got \`${originalPath}\``, TypeError);
+    }
+    if (!path) {
+      return doThrow(`path must not be empty`, TypeError);
+    }
+    if (checkPath.isNotRelative(path)) {
+      const r = "`path.relative()`d";
+      return doThrow(`path should be a ${r} string, but got "${originalPath}"`, RangeError);
+    }
+    return true;
+  };
+  var isNotRelative = (path) => REGEX_TEST_INVALID_PATH.test(path);
+  checkPath.isNotRelative = isNotRelative;
+  checkPath.convert = (p) => p;
+
+  class Ignore {
+    constructor({
+      ignorecase = true,
+      ignoreCase = ignorecase,
+      allowRelativePaths = false
+    } = {}) {
+      define(this, KEY_IGNORE, true);
+      this._rules = new RuleManager(ignoreCase);
+      this._strictPathCheck = !allowRelativePaths;
+      this._initCache();
+    }
+    _initCache() {
+      this._ignoreCache = Object.create(null);
+      this._testCache = Object.create(null);
+    }
+    add(pattern) {
+      if (this._rules.add(pattern)) {
+        this._initCache();
+      }
+      return this;
+    }
+    addPattern(pattern) {
+      return this.add(pattern);
+    }
+    _test(originalPath, cache, checkUnignored, slices) {
+      const path = originalPath && checkPath.convert(originalPath);
+      checkPath(path, originalPath, this._strictPathCheck ? throwError : RETURN_FALSE);
+      return this._t(path, cache, checkUnignored, slices);
+    }
+    checkIgnore(path) {
+      if (!REGEX_TEST_TRAILING_SLASH.test(path)) {
+        return this.test(path);
+      }
+      const slices = path.split(SLASH).filter(Boolean);
+      slices.pop();
+      if (slices.length) {
+        const parent = this._t(slices.join(SLASH) + SLASH, this._testCache, true, slices);
+        if (parent.ignored) {
+          return parent;
+        }
+      }
+      return this._rules.test(path, false, MODE_CHECK_IGNORE);
+    }
+    _t(path, cache, checkUnignored, slices) {
+      if (path in cache) {
+        return cache[path];
+      }
+      if (!slices) {
+        slices = path.split(SLASH).filter(Boolean);
+      }
+      slices.pop();
+      if (!slices.length) {
+        return cache[path] = this._rules.test(path, checkUnignored, MODE_IGNORE);
+      }
+      const parent = this._t(slices.join(SLASH) + SLASH, cache, checkUnignored, slices);
+      return cache[path] = parent.ignored ? parent : this._rules.test(path, checkUnignored, MODE_IGNORE);
+    }
+    ignores(path) {
+      return this._test(path, this._ignoreCache, false).ignored;
+    }
+    createFilter() {
+      return (path) => !this.ignores(path);
+    }
+    filter(paths) {
+      return makeArray(paths).filter(this.createFilter());
+    }
+    test(path) {
+      return this._test(path, this._testCache, true);
+    }
+  }
+  var factory = (options) => new Ignore(options);
+  var isPathValid = (path) => checkPath(path && checkPath.convert(path), path, RETURN_FALSE);
+  var setupWindows = () => {
+    const makePosix = (str) => /^\\\\\?\\/.test(str) || /["<>|\u0000-\u001F]+/u.test(str) ? str : str.replace(/\\/g, "/");
+    checkPath.convert = makePosix;
+    const REGEX_TEST_WINDOWS_PATH_ABSOLUTE = /^[a-z]:\//i;
+    checkPath.isNotRelative = (path) => REGEX_TEST_WINDOWS_PATH_ABSOLUTE.test(path) || isNotRelative(path);
+  };
+  if (typeof process !== "undefined" && process.platform === "win32") {
+    setupWindows();
+  }
+  module.exports = factory;
+  factory.default = factory;
+  module.exports.isPathValid = isPathValid;
+  define(module.exports, Symbol.for("setupWindows"), setupWindows);
+});
+
+// src/clients/openai-usage.ts
+function parseChatCompletionUsage(json) {
+  const usage = json.usage;
+  const costUsd = usage?.cost ?? usage?.total_cost ?? json.cost ?? undefined;
+  if (!usage && costUsd === undefined)
+    return;
+  const promptTokens = usage?.prompt_tokens;
+  const completionTokens = usage?.completion_tokens;
+  const totalTokens = usage?.total_tokens ?? (promptTokens !== undefined && completionTokens !== undefined ? promptTokens + completionTokens : undefined);
+  if (promptTokens === undefined && completionTokens === undefined && totalTokens === undefined && costUsd === undefined) {
+    return;
+  }
+  return {
+    promptTokens,
+    completionTokens,
+    totalTokens,
+    costUsd
+  };
+}
+
+// src/clients/ai-client.ts
+var MAX_ATTEMPTS = 10;
+var RETRY_BASE_DELAY_MS = 1500;
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function isRetryableError(error) {
+  if (error.message === "Empty response from AI")
+    return true;
+  const statusMatch = error.message.match(/AI request failed \((\d+)\)/);
+  if (!statusMatch)
+    return true;
+  const status = Number(statusMatch[1]);
+  return status === 429 || status >= 500;
+}
+function retryDelayMs(attempt) {
+  return RETRY_BASE_DELAY_MS * attempt;
+}
+
+class AiClient {
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  async ask(prompt2, maxTokens) {
+    let lastError;
+    for (let attempt = 1;attempt <= MAX_ATTEMPTS; attempt++) {
+      try {
+        return await this.requestOnce(prompt2, maxTokens);
+      } catch (error) {
+        lastError = error instanceof Error ? error : new Error(String(error), { cause: error });
+        const canRetry = attempt < MAX_ATTEMPTS && isRetryableError(lastError);
+        if (!canRetry)
+          throw lastError;
+        const delayMs = retryDelayMs(attempt);
+        console.error(`AI request failed (${lastError.message}), retrying ${attempt + 1}/${MAX_ATTEMPTS} in ${(delayMs / 1000).toFixed(1)}s...`);
+        await sleep(delayMs);
+      }
+    }
+    throw lastError ?? new Error("AI request failed");
+  }
+  async requestOnce(prompt2, maxTokens) {
+    let res;
+    try {
+      res = await fetch(`${this.config.baseUrl}/chat/completions`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${this.config.apiKey}`
+        },
+        body: JSON.stringify({
+          model: this.config.model,
+          messages: [{ role: "user", content: prompt2 }],
+          temperature: 1,
+          max_tokens: maxTokens
+        })
+      });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      throw new Error(`AI request failed (network): ${message}`, { cause: error });
+    }
+    if (!res.ok) {
+      const body = await res.text();
+      throw new Error(`AI request failed (${res.status}): ${body}`);
+    }
+    const json = await res.json();
+    const content = json.choices?.[0]?.message?.content?.trim();
+    if (!content)
+      throw new Error("Empty response from AI");
+    return {
+      content,
+      usage: parseChatCompletionUsage(json)
+    };
+  }
+}
+
+// src/clients/cursor-sdk-client.ts
+import { join as join2 } from "path";
+
+// src/temp-files.ts
+import { unlink } from "fs/promises";
+import { tmpdir } from "os";
+import { join } from "path";
+function tempFile(prefix, extension) {
+  const suffix = `${Date.now()}-${process.pid}-${Math.random().toString(36).slice(2, 8)}`;
+  return join(tmpdir(), `${prefix}-${suffix}.${extension}`);
+}
+async function safeUnlink(path) {
+  if (!path)
+    return;
+  try {
+    await unlink(path);
+  } catch {}
+}
+
+// src/clients/cursor-sdk-client.ts
+var RUNNER_PATH = join2(import.meta.dir, "cursor-sdk-runner.mjs");
+
+class CursorSdkClient {
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  async ask(prompt2, _maxTokens) {
+    const promptPath = tempFile("git-ai-cursor-prompt", "md");
+    try {
+      await Bun.write(promptPath, prompt2);
+      const proc = Bun.spawn(["node", RUNNER_PATH, promptPath], {
+        cwd: process.cwd(),
+        env: {
+          ...process.env,
+          CURSOR_API_KEY: this.config.apiKey,
+          CURSOR_MODEL: this.config.model
+        },
+        stdout: "pipe",
+        stderr: "pipe"
+      });
+      const [stdout, stderr, exitCode] = await Promise.all([
+        new Response(proc.stdout).text(),
+        new Response(proc.stderr).text(),
+        proc.exited
+      ]);
+      if (exitCode !== 0) {
+        const details = stderr.trim() || stdout.trim() || `exit code ${exitCode}`;
+        throw new Error(`Cursor SDK request failed: ${details}`);
+      }
+      const content = stdout.trim();
+      if (!content)
+        throw new Error("Empty response from Cursor agent");
+      return { content };
+    } finally {
+      await safeUnlink(promptPath);
+    }
+  }
+}
+
+// src/clipboard.ts
+async function pipeToClipboard(command, text) {
+  try {
+    const proc = Bun.spawn(command, { stdin: "pipe", stdout: "ignore", stderr: "ignore" });
+    proc.stdin.write(text);
+    proc.stdin.end();
+    return await proc.exited === 0;
+  } catch {
+    return false;
+  }
+}
+var CLIPBOARD_COMMANDS = [
+  ["wl-copy"],
+  ["xclip", "-selection", "clipboard"],
+  ["xsel", "--clipboard", "--input"],
+  ["pbcopy"],
+  ["clip"]
+];
+async function copyToClipboard(text) {
+  for (const command of CLIPBOARD_COMMANDS) {
+    if (await pipeToClipboard(command, text))
+      return;
+  }
+  throw new Error("No clipboard tool found. Install wl-clipboard, xclip, or xsel.");
+}
+
+// src/cli.ts
+import { emitKeypressEvents } from "readline";
+
+// src/constants.ts
+var MODE_META = {
+  "branch-commit-pr": {
+    label: "Staged \u2192 new branch \u2192 commit \u2192 push \u2192 PR",
+    help: "Staged changes: create branch, commit, push, open PR",
+    maxTokens: 8096
+  },
+  "branch-commit-push": {
+    label: "Staged \u2192 new branch \u2192 commit \u2192 push",
+    help: "Staged changes: create branch, commit, push",
+    maxTokens: 500
+  },
+  "commit-push": {
+    label: "Staged \u2192 current branch \u2192 commit \u2192 push",
+    help: "Staged changes: commit and push on current branch",
+    maxTokens: 500
+  },
+  "create-pr": {
+    label: "Branch \u2192 PR",
+    help: "Existing commits on this branch: open PR to the configured base branch",
+    maxTokens: 8096
+  },
+  "update-pr": {
+    label: "Branch \u2192 refresh open PR",
+    help: "Open PR exists: regenerate title and description from branch diff",
+    maxTokens: 8096
+  }
+};
+var MODE_ORDER = [
+  "branch-commit-pr",
+  "branch-commit-push",
+  "commit-push",
+  "create-pr",
+  "update-pr"
+];
+var PROVIDER_META = {
+  openai: {
+    label: "OpenAI-compatible API",
+    help: "Use OPENAI_BASE_URL + OPENAI_API_KEY (current default flow)"
+  },
+  "cursor-sdk": {
+    label: "Cursor SDK",
+    help: "Use Cursor subscription models via CURSOR_API_KEY"
+  },
+  manual: {
+    label: "Manual",
+    help: "Copy prompt, run any AI yourself, paste the response back (uses $EDITOR / $VISUAL)"
+  }
+};
+var PROVIDER_ORDER = ["openai", "cursor-sdk", "manual"];
+
+// src/project-config.ts
+import { existsSync } from "fs";
+import { join as join3 } from "path";
+
+// src/defaults.ts
+var GIT_AI_DIR = ".git-ai";
+var LEGACY_CONFIG_FILE = ".git-ai.json";
+var CONFIG_FILE = `${GIT_AI_DIR}/config.json`;
+var DIFF_IGNORE_FILE = `${GIT_AI_DIR}/diff-ignore`;
+var PROMPTS_DIR = `${GIT_AI_DIR}/prompts`;
+var CONVENTIONS_FILE = `${GIT_AI_DIR}/conventions.md`;
+var DEFAULT_DIFF_IGNORE_PATTERNS = [
+  "bun.lock",
+  "package-lock.json",
+  "yarn.lock",
+  "pnpm-lock.yaml"
+];
+var DEFAULT_PROJECT_CONFIG = {
+  baseBranch: "main",
+  diffIgnore: [...DEFAULT_DIFF_IGNORE_PATTERNS],
+  conventions: null,
+  prTemplate: ".github/PULL_REQUEST_TEMPLATE.md",
+  stagedFix: {
+    rules: [],
+    root: null
+  }
+};
+
+// src/diff-ignore.ts
+var import_ignore = __toESM(require_ignore(), 1);
+var matcher = null;
+function initDiffIgnore(patterns) {
+  matcher = import_ignore.default().add([...patterns]);
+}
+function getMatcher() {
+  if (!matcher) {
+    throw new Error("Diff ignore patterns are not initialized. Call loadProjectConfig() first.");
+  }
+  return matcher;
+}
+function normalizePath(path) {
+  return path.replace(/\\/g, "/");
+}
+function withoutDiffIgnoredFiles(paths) {
+  return getMatcher().filter(paths.map(normalizePath));
+}
+
+// src/ignore-file.ts
+function parseIgnoreFile(content) {
+  return content.split(`
+`).map((line) => line.trim()).filter((line) => line.length > 0 && !line.startsWith("#"));
+}
+
+// src/repo-root.ts
+var cachedRepoRoot = null;
+async function getRepoRoot() {
+  if (cachedRepoRoot)
+    return cachedRepoRoot;
+  const root = (await Bun.$`git rev-parse --show-toplevel`.text()).trim();
+  if (!root)
+    throw new Error("Not inside a git repository");
+  cachedRepoRoot = root;
+  return root;
+}
+
+// src/project-config.ts
+var loadedConfig = null;
+var projectDirPath = null;
+function uniquePatterns(patterns) {
+  return [...new Set(patterns)];
+}
+function mergeConfig(input) {
+  const stagedFixInput = input?.stagedFix;
+  return {
+    baseBranch: input?.baseBranch ?? DEFAULT_PROJECT_CONFIG.baseBranch,
+    conventions: input?.conventions === undefined ? DEFAULT_PROJECT_CONFIG.conventions : input.conventions,
+    prTemplate: input?.prTemplate ?? DEFAULT_PROJECT_CONFIG.prTemplate,
+    stagedFix: {
+      rules: stagedFixInput?.rules ?? [...DEFAULT_PROJECT_CONFIG.stagedFix.rules],
+      root: stagedFixInput?.root === undefined ? DEFAULT_PROJECT_CONFIG.stagedFix.root : stagedFixInput.root
+    }
+  };
+}
+async function loadConfigInput(repoRoot) {
+  const candidates = [join3(repoRoot, CONFIG_FILE), join3(repoRoot, LEGACY_CONFIG_FILE)];
+  for (const configPath of candidates) {
+    if (!existsSync(configPath))
+      continue;
+    return await Bun.file(configPath).json();
+  }
+  return;
+}
+async function loadDiffIgnorePatterns(repoRoot, input) {
+  const patterns = [...DEFAULT_DIFF_IGNORE_PATTERNS];
+  const ignoreFilePath = join3(repoRoot, DIFF_IGNORE_FILE);
+  if (existsSync(ignoreFilePath)) {
+    const content = await Bun.file(ignoreFilePath).text();
+    patterns.push(...parseIgnoreFile(content));
+  }
+  if (input?.diffIgnore) {
+    patterns.push(...input.diffIgnore);
+  }
+  return uniquePatterns(patterns);
+}
+function getBaseBranchOrDefault(defaultBranch = "main") {
+  return loadedConfig?.baseBranch ?? defaultBranch;
+}
+async function loadProjectConfig() {
+  if (loadedConfig)
+    return loadedConfig;
+  const repoRoot = await getRepoRoot();
+  projectDirPath = join3(repoRoot, ".git-ai");
+  const input = await loadConfigInput(repoRoot);
+  const diffIgnore = await loadDiffIgnorePatterns(repoRoot, input);
+  loadedConfig = {
+    ...mergeConfig(input),
+    diffIgnore
+  };
+  initDiffIgnore(loadedConfig.diffIgnore);
+  return loadedConfig;
+}
+function getProjectConfig() {
+  if (!loadedConfig) {
+    throw new Error("Project config is not loaded. Call loadProjectConfig() first.");
+  }
+  return loadedConfig;
+}
+function resolveRepoPath(repoRelativePath) {
+  return getRepoRoot().then((root) => join3(root, repoRelativePath));
+}
+
+// src/mode-meta.ts
+function getModeMeta(mode, baseBranch = getBaseBranchOrDefault()) {
+  const meta = MODE_META[mode];
+  if (mode === "create-pr") {
+    return {
+      ...meta,
+      label: `Branch \u2192 PR to ${baseBranch}`,
+      help: `Existing commits on this branch: open PR to ${baseBranch}`
+    };
+  }
+  if (mode === "update-pr") {
+    return {
+      ...meta,
+      help: `Open PR exists: regenerate title and description from branch..${baseBranch} diff`
+    };
+  }
+  return meta;
+}
+function getMaxTokens(mode) {
+  return MODE_META[mode].maxTokens;
+}
+
+// src/editor.ts
+function resolveEditor() {
+  return process.env.VISUAL ?? process.env.EDITOR ?? "nano";
+}
+function editorCommand(filePath) {
+  const editor = resolveEditor();
+  const parts = editor.match(/(?:[^\s"']+|"[^"]*"|'[^']*')+/g) ?? [editor];
+  return [...parts.map((part) => part.replace(/^['"]|['"]$/g, "")), filePath];
+}
+async function openFileInEditor(filePath) {
+  const child = Bun.spawn(editorCommand(filePath), {
+    stdin: "inherit",
+    stdout: "inherit",
+    stderr: "inherit"
+  });
+  const exitCode = await child.exited;
+  if (exitCode !== 0) {
+    throw new Error(`Editor exited with code ${exitCode}`);
+  }
+}
+async function readFileText(filePath) {
+  return Bun.file(filePath).text();
+}
+
+// src/cli.ts
+var ANSI_RESET = "\x1B[0m";
+var ANSI_BOLD = "\x1B[1m";
+var ANSI_DIM = "\x1B[2m";
+var ANSI_CYAN = "\x1B[36m";
+var ANSI_MAGENTA = "\x1B[35m";
+var ANSI_GREEN = "\x1B[32m";
+function useColor() {
+  return !!process.stdout.isTTY && !process.env.NO_COLOR;
+}
+function paint(text, ansi) {
+  if (!useColor())
+    return text;
+  return `${ansi}${text}${ANSI_RESET}`;
+}
+function sectionTitle(text) {
+  return paint(text, `${ANSI_BOLD}${ANSI_MAGENTA}`);
+}
+function keyLabel(text) {
+  return paint(text, `${ANSI_BOLD}${ANSI_CYAN}`);
+}
+function valueLabel(text) {
+  return paint(text, ANSI_BOLD);
+}
+function hintText(text) {
+  return paint(text, ANSI_DIM);
+}
+async function printHelp() {
+  try {
+    await loadProjectConfig();
+  } catch {}
+  const modeLines = MODE_ORDER.map((mode) => {
+    const meta = getModeMeta(mode);
+    const name = mode.padEnd(20);
+    return `  ${name}${meta.help}`;
+  });
+  const providerLines = PROVIDER_ORDER.map((provider) => {
+    const meta = PROVIDER_META[provider];
+    const name = provider.padEnd(20);
+    return `  ${name}${meta.help}`;
+  });
+  console.log([
+    "Usage:",
+    "  git-ai",
+    ...MODE_ORDER.map((mode) => `  git-ai --mode ${mode}`),
+    "  git-ai --provider cursor-sdk",
+    "  git-ai --dry-run --mode commit-push",
+    "",
+    "In a monorepo you can also wire a package script, e.g. bun run git:ai",
+    "",
+    "Project config (optional): .git-ai/ at the git repository root",
+    "  .git-ai/config.json       settings (baseBranch, stagedFix, ...)",
+    "  .git-ai/diff-ignore       .gitignore-style paths omitted from AI diffs",
+    "  .git-ai/prompts/*.md      per-mode prompt overrides",
+    "  .git-ai/conventions.md    commit/branch conventions for the AI",
+    "",
+    "Flags:",
+    "  --dry-run, -n             Print the AI prompt only (no AI call, no git actions)",
+    "",
+    "Modes:",
+    ...modeLines,
+    "",
+    "AI providers:",
+    ...providerLines,
+    "",
+    "Legend:",
+    "  Staged \u2014 changes added with git add",
+    "  Branch \u2014 commits already on the current branch"
+  ].join(`
+`));
+}
+function parseDryRunFromArgs(args) {
+  return args.includes("--dry-run") || args.includes("-n");
+}
+function printDryRunPrompt(promptText) {
+  console.log(`--- git-ai prompt (dry-run) ---
+`);
+  console.log(promptText);
+  console.log(`
+--- end prompt ---`);
+}
+function parseModeFromArgs(args) {
+  const modeArgIndex = args.findIndex((arg) => arg === "--mode");
+  if (modeArgIndex >= 0) {
+    const value = args[modeArgIndex + 1];
+    if (!value)
+      throw new Error("Missing value for --mode");
+    return parseModeValue(value);
+  }
+  const modeInline = args.find((arg) => arg.startsWith("--mode="));
+  if (modeInline) {
+    return parseModeValue(modeInline.slice("--mode=".length));
+  }
+  const positional = args.find((arg) => !arg.startsWith("-"));
+  if (positional) {
+    return parseModeValue(positional);
+  }
+  return null;
+}
+function parseModeValue(value) {
+  if (value === "branch-commit-pr" || value === "branch-commit-push" || value === "commit-push" || value === "create-pr" || value === "update-pr") {
+    return value;
+  }
+  throw new Error(`Unknown mode "${value}". Expected: branch-commit-pr | branch-commit-push | commit-push | create-pr | update-pr`);
+}
+function parseProviderFromArgs(args) {
+  const providerArgIndex = args.findIndex((arg) => arg === "--provider");
+  if (providerArgIndex >= 0) {
+    const value = args[providerArgIndex + 1];
+    if (!value)
+      throw new Error("Missing value for --provider");
+    return parseProviderValue(value);
+  }
+  const providerInline = args.find((arg) => arg.startsWith("--provider="));
+  if (providerInline) {
+    return parseProviderValue(providerInline.slice("--provider=".length));
+  }
+  return null;
+}
+function parseProviderValue(value) {
+  if (value === "openai" || value === "cursor-sdk" || value === "manual") {
+    return value;
+  }
+  throw new Error(`Unknown provider "${value}". Expected: openai | cursor-sdk | manual`);
+}
+function parseYesNoInput(raw) {
+  const value = raw?.trim().toLowerCase();
+  if (!value)
+    return null;
+  if (value === "yes" || value === "y" || value === "1")
+    return true;
+  if (value === "no" || value === "n" || value === "2")
+    return false;
+  return null;
+}
+async function promptSelection(params) {
+  const { headerLines, options, fallbackQuestion, fallbackParser } = params;
+  if (!process.stdin.isTTY || !process.stdout.isTTY) {
+    if (typeof prompt !== "function") {
+      throw new Error("Interactive prompt is unavailable. Pass explicit CLI arguments.");
+    }
+    while (true) {
+      const answer = prompt(fallbackQuestion);
+      if (answer === null) {
+        throw new Error("Input closed (EOF). Pass explicit CLI arguments.");
+      }
+      const parsed = fallbackParser(answer);
+      if (parsed !== null)
+        return parsed;
+    }
+  }
+  let selectedIndex = 0;
+  let renderedLines = 0;
+  const shortcuts = new Map;
+  options.forEach((option) => {
+    for (const key of option.shortcuts ?? []) {
+      shortcuts.set(key.toLowerCase(), option.value);
+    }
+  });
+  const render = () => {
+    if (renderedLines > 0) {
+      process.stdout.write(`\x1B[${renderedLines}A`);
+    }
+    const lines = [
+      ...headerLines,
+      ...options.map((option, index) => {
+        if (index === selectedIndex) {
+          return `${paint("->", ANSI_GREEN)} ${paint(option.label, `${ANSI_BOLD}${ANSI_CYAN}`)}`;
+        }
+        return `   ${hintText(option.label)}`;
+      })
+    ];
+    for (const line of lines) {
+      process.stdout.write("\x1B[2K");
+      process.stdout.write(`${line}
+`);
+    }
+    renderedLines = lines.length;
+  };
+  const previousRawMode = process.stdin.isRaw;
+  emitKeypressEvents(process.stdin);
+  process.stdin.setRawMode(true);
+  process.stdin.resume();
+  process.stdout.write("\x1B[?25l");
+  render();
+  return await new Promise((resolve, reject) => {
+    const cleanup = () => {
+      process.stdin.off("keypress", onKeyPress);
+      process.stdin.setRawMode(previousRawMode ?? false);
+      process.stdin.pause();
+      process.stdout.write("\x1B[?25h");
+      process.stdout.write(`
+`);
+    };
+    const onKeyPress = (_, key) => {
+      if (key.ctrl && key.name === "c") {
+        cleanup();
+        reject(new Error("Selection cancelled"));
+        return;
+      }
+      if (key.name === "up") {
+        selectedIndex = (selectedIndex - 1 + options.length) % options.length;
+        render();
+        return;
+      }
+      if (key.name === "down") {
+        selectedIndex = (selectedIndex + 1) % options.length;
+        render();
+        return;
+      }
+      if (key.name === "return" || key.name === "enter") {
+        const selected = options[selectedIndex];
+        cleanup();
+        resolve(selected.value);
+        return;
+      }
+      if (key.name) {
+        const mapped = shortcuts.get(key.name.toLowerCase());
+        if (mapped !== undefined) {
+          cleanup();
+          resolve(mapped);
+        }
+      }
+    };
+    process.stdin.on("keypress", onKeyPress);
+  });
+}
+async function promptForMode(currentBranch) {
+  return promptSelection({
+    headerLines: [
+      sectionTitle("[MODE] Choose action"),
+      `${keyLabel("Current branch:")} ${valueLabel(currentBranch ?? "unknown")}`,
+      hintText("Staged = git add first \xB7 Branch = commits on this branch"),
+      hintText("Use Up/Down and Enter to choose")
+    ],
+    options: MODE_ORDER.map((mode, index) => ({
+      value: mode,
+      label: getModeMeta(mode).label,
+      shortcuts: [String(index + 1)]
+    })),
+    fallbackQuestion: `Current branch: ${currentBranch ?? "unknown"}. Select [1-5]: `,
+    fallbackParser: (answer) => {
+      const normalized = answer?.trim();
+      if (normalized === "1")
+        return "branch-commit-pr";
+      if (normalized === "2")
+        return "branch-commit-push";
+      if (normalized === "3")
+        return "commit-push";
+      if (normalized === "4")
+        return "create-pr";
+      if (normalized === "5")
+        return "update-pr";
+      return null;
+    }
+  });
+}
+async function promptForProvider() {
+  return promptSelection({
+    headerLines: [
+      sectionTitle("[PROVIDER] Choose AI source"),
+      hintText("OpenAI-compatible uses your API endpoint"),
+      hintText("Cursor SDK uses models from your Cursor subscription"),
+      hintText("Manual lets you copy the prompt and paste the response"),
+      hintText("Use Up/Down and Enter to choose")
+    ],
+    options: PROVIDER_ORDER.map((provider, index) => ({
+      value: provider,
+      label: PROVIDER_META[provider].label,
+      shortcuts: [String(index + 1)]
+    })),
+    fallbackQuestion: "Select AI provider [1-3]: ",
+    fallbackParser: (answer) => {
+      const normalized = answer?.trim();
+      if (normalized === "1")
+        return "openai";
+      if (normalized === "2")
+        return "cursor-sdk";
+      if (normalized === "3")
+        return "manual";
+      return null;
+    }
+  });
+}
+function printAiPreview(currentBranch, result, baseBranch, prNumber) {
+  if (result.mode === "create-pr" || result.mode === "update-pr") {
+    const actionLabel = result.mode === "update-pr" ? "Updated PR draft" : "Generated draft";
+    console.log("");
+    console.log(sectionTitle(`[AI PREVIEW] ${actionLabel}`));
+    console.log(`${keyLabel("Current branch:")} ${valueLabel(currentBranch)}`);
+    console.log(`${keyLabel("Base branch:")} ${valueLabel(baseBranch ?? "main")}`);
+    if (prNumber) {
+      console.log(`${keyLabel("PR:")} ${valueLabel(`#${prNumber}`)}`);
+    }
+    console.log(`${keyLabel("PR title:")} ${valueLabel(result.title)}`);
+    console.log(hintText("----------------------------------------"));
+    console.log(sectionTitle("[PR MESSAGE]"));
+    console.log(result.prDescription || "(empty)");
+    console.log("");
+    return;
+  }
+  const commitTitle = result.commitMessage.split(`
+`)[0] ?? "";
+  const targetBranch = result.mode === "branch-commit-pr" || result.mode === "branch-commit-push" ? result.branchName : null;
+  const prTitle = result.mode === "branch-commit-pr" ? result.title : null;
+  const prMessage = result.mode === "branch-commit-pr" ? result.prDescription || "(empty)" : null;
+  console.log("");
+  console.log(sectionTitle("[AI PREVIEW] Generated draft"));
+  console.log(`${keyLabel("Current branch:")} ${valueLabel(currentBranch)}`);
+  if (targetBranch) {
+    console.log(`${keyLabel("Target branch:")} ${valueLabel(targetBranch)}`);
+  }
+  console.log(`${keyLabel("Commit title:")} ${valueLabel(commitTitle)}`);
+  if (prTitle) {
+    console.log(`${keyLabel("PR title:")} ${valueLabel(prTitle)}`);
+  }
+  console.log(hintText("----------------------------------------"));
+  console.log(sectionTitle("[COMMIT MESSAGE]"));
+  console.log(result.commitMessage);
+  if (prMessage) {
+    console.log("");
+    console.log(sectionTitle("[PR MESSAGE]"));
+    console.log(prMessage);
+  }
+  console.log("");
+}
+function parseExecutionConfirmationInput(raw) {
+  const value = raw?.trim().toLowerCase();
+  if (!value)
+    return null;
+  if (value === "yes" || value === "y" || value === "1")
+    return "yes";
+  if (value === "no" || value === "n" || value === "2")
+    return "no";
+  if (value === "edit" || value === "e" || value === "3")
+    return "edit";
+  return null;
+}
+async function promptForExecutionConfirmation() {
+  const editor = resolveEditor();
+  return promptSelection({
+    headerLines: [
+      sectionTitle("[ACTION] Apply these changes?"),
+      hintText("Use Up/Down and Enter to choose")
+    ],
+    options: [
+      { value: "yes", label: "Yes", shortcuts: ["y", "1"] },
+      { value: "edit", label: "Edit fields", shortcuts: ["e", "3"] },
+      { value: "no", label: "No", shortcuts: ["n", "2"] }
+    ],
+    fallbackQuestion: `Apply these changes? [yes/edit/no] (${editor}): `,
+    fallbackParser: parseExecutionConfirmationInput
+  });
+}
+function parseEditFieldInput(raw, fields) {
+  const value = raw?.trim().toLowerCase();
+  if (!value)
+    return null;
+  if (value === "back" || value === "b" || value === "0")
+    return "back";
+  const index = Number.parseInt(value, 10);
+  if (!Number.isNaN(index) && index >= 1 && index <= fields.length) {
+    return fields[index - 1].id;
+  }
+  const byId = fields.find((field) => field.id.toLowerCase() === value);
+  if (byId)
+    return byId.id;
+  const byLabel = fields.find((field) => field.label.toLowerCase() === value);
+  if (byLabel)
+    return byLabel.id;
+  return null;
+}
+async function promptForEditField(fields) {
+  if (fields.length === 0)
+    return null;
+  if (fields.length === 1)
+    return fields[0].id;
+  const choice = await promptSelection({
+    headerLines: [
+      sectionTitle("[EDIT] What to change?"),
+      hintText("Use Up/Down and Enter to choose")
+    ],
+    options: [
+      ...fields.map((field, index) => ({
+        value: field.id,
+        label: field.label,
+        shortcuts: [String(index + 1)]
+      })),
+      { value: "back", label: "Back to preview", shortcuts: ["b", "0"] }
+    ],
+    fallbackQuestion: "Edit which field? [number/back]: ",
+    fallbackParser: (raw) => parseEditFieldInput(raw, fields)
+  });
+  return choice === "back" ? null : choice;
+}
+async function promptForCachedDraftReuse() {
+  return promptSelection({
+    headerLines: [
+      sectionTitle("[CACHE] Matching staged changes found"),
+      hintText("A previous AI draft matches the current staged changes"),
+      hintText("Reuse it to skip the AI call?"),
+      hintText("Use Up/Down and Enter to choose")
+    ],
+    options: [
+      { value: true, label: "Yes, reuse draft", shortcuts: ["y", "1"] },
+      { value: false, label: "No, generate again", shortcuts: ["n", "2"] }
+    ],
+    fallbackQuestion: "Reuse cached draft? [yes/no]: ",
+    fallbackParser: parseYesNoInput
+  });
+}
+async function promptForManualPromptAction(editor) {
+  return promptSelection({
+    headerLines: [
+      sectionTitle("[MANUAL] What next?"),
+      `${keyLabel("Editor:")} ${valueLabel(editor)}`,
+      hintText("Copy puts the prompt on the clipboard"),
+      hintText("Show prints the prompt in the terminal"),
+      hintText("Set EDITOR or VISUAL in .env or shell to change the editor"),
+      hintText("Use Up/Down and Enter to choose")
+    ],
+    options: [
+      { value: "copy", label: "Copy prompt to clipboard", shortcuts: ["c", "1"] },
+      { value: "show", label: "Show prompt", shortcuts: ["s", "2"] },
+      { value: "cancel", label: "Cancel", shortcuts: ["n", "3"] }
+    ],
+    fallbackQuestion: "Choose [1=copy / 2=show / 3=cancel]: ",
+    fallbackParser: (answer) => {
+      const normalized = answer?.trim().toLowerCase();
+      if (normalized === "1" || normalized === "c" || normalized === "copy")
+        return "copy";
+      if (normalized === "2" || normalized === "s" || normalized === "show")
+        return "show";
+      if (normalized === "3" || normalized === "n" || normalized === "cancel")
+        return "cancel";
+      return null;
+    }
+  });
+}
+async function promptForManualResponseReady() {
+  return promptSelection({
+    headerLines: [
+      sectionTitle("[MANUAL] Next step"),
+      hintText("Paste the prompt into any AI chat and send it."),
+      hintText("When you have the response, continue to open the editor and paste it there."),
+      hintText("Use Up/Down and Enter to choose")
+    ],
+    options: [
+      { value: true, label: "Continue", shortcuts: ["y", "1"] },
+      { value: false, label: "Cancel", shortcuts: ["n", "2"] }
+    ],
+    fallbackQuestion: "Continue? [yes/cancel]: ",
+    fallbackParser: (answer) => {
+      const normalized = answer?.trim().toLowerCase();
+      if (!normalized || normalized === "y" || normalized === "yes" || normalized === "1")
+        return true;
+      if (normalized === "n" || normalized === "no" || normalized === "2" || normalized === "cancel")
+        return false;
+      return null;
+    }
+  });
+}
+
+// src/result-edit.ts
+var FIELD_HINTS = {
+  branchName: "Edit branch name. Save and close when done.",
+  commitMessage: "Edit commit message (title and optional body). Save and close when done.",
+  prTitle: "Edit PR title. Save and close when done.",
+  prDescription: "Edit PR description. Save and close when done."
+};
+function assertMode(result, mode) {
+  if (result.mode !== mode) {
+    throw new Error(`Expected result mode ${mode}, got ${result.mode}`);
+  }
+}
+function commitTitleLine(commitMessage) {
+  return commitMessage.split(`
+`)[0]?.trim() ?? "";
+}
+function editableFieldsForResult(result) {
+  switch (result.mode) {
+    case "commit-push":
+      return [
+        {
+          id: "commitMessage",
+          label: "Commit message",
+          hint: FIELD_HINTS.commitMessage,
+          getValue: (draft) => draft.mode === "commit-push" ? draft.commitMessage : "",
+          setValue: (draft, value) => {
+            assertMode(draft, "commit-push");
+            return { ...draft, commitMessage: value.trim() };
+          }
+        }
+      ];
+    case "branch-commit-push":
+      return [
+        {
+          id: "branchName",
+          label: "Branch name",
+          hint: FIELD_HINTS.branchName,
+          getValue: (draft) => draft.mode === "branch-commit-push" ? draft.branchName : "",
+          setValue: (draft, value) => {
+            assertMode(draft, "branch-commit-push");
+            return { ...draft, branchName: value.trim() };
+          }
+        },
+        {
+          id: "commitMessage",
+          label: "Commit message",
+          hint: FIELD_HINTS.commitMessage,
+          getValue: (draft) => draft.mode === "branch-commit-push" ? draft.commitMessage : "",
+          setValue: (draft, value) => {
+            assertMode(draft, "branch-commit-push");
+            return { ...draft, commitMessage: value.trim() };
+          }
+        }
+      ];
+    case "branch-commit-pr":
+      return [
+        {
+          id: "branchName",
+          label: "Branch name",
+          hint: FIELD_HINTS.branchName,
+          getValue: (draft) => draft.mode === "branch-commit-pr" ? draft.branchName : "",
+          setValue: (draft, value) => {
+            assertMode(draft, "branch-commit-pr");
+            return { ...draft, branchName: value.trim() };
+          }
+        },
+        {
+          id: "commitMessage",
+          label: "Commit message",
+          hint: FIELD_HINTS.commitMessage,
+          getValue: (draft) => draft.mode === "branch-commit-pr" ? draft.commitMessage : "",
+          setValue: (draft, value) => {
+            assertMode(draft, "branch-commit-pr");
+            const commitMessage = value.trim();
+            return {
+              ...draft,
+              commitMessage,
+              title: commitTitleLine(commitMessage) || draft.title
+            };
+          }
+        },
+        {
+          id: "prTitle",
+          label: "PR title",
+          hint: FIELD_HINTS.prTitle,
+          getValue: (draft) => draft.mode === "branch-commit-pr" ? draft.title : "",
+          setValue: (draft, value) => {
+            assertMode(draft, "branch-commit-pr");
+            return { ...draft, title: value.trim() };
+          }
+        },
+        {
+          id: "prDescription",
+          label: "PR description",
+          hint: FIELD_HINTS.prDescription,
+          getValue: (draft) => draft.mode === "branch-commit-pr" ? draft.prDescription : "",
+          setValue: (draft, value) => {
+            assertMode(draft, "branch-commit-pr");
+            return { ...draft, prDescription: value.trim() };
+          }
+        }
+      ];
+    case "create-pr":
+    case "update-pr":
+      return [
+        {
+          id: "prTitle",
+          label: "PR title",
+          hint: FIELD_HINTS.prTitle,
+          getValue: (draft) => draft.mode === "create-pr" || draft.mode === "update-pr" ? draft.title : "",
+          setValue: (draft, value) => {
+            assertMode(draft, result.mode);
+            return { ...draft, title: value.trim() };
+          }
+        },
+        {
+          id: "prDescription",
+          label: "PR description",
+          hint: FIELD_HINTS.prDescription,
+          getValue: (draft) => draft.mode === "create-pr" || draft.mode === "update-pr" ? draft.prDescription : "",
+          setValue: (draft, value) => {
+            assertMode(draft, result.mode);
+            return { ...draft, prDescription: value.trim() };
+          }
+        }
+      ];
+  }
+}
+function stripEditComments(content) {
+  return content.split(`
+`).filter((line) => !line.trimStart().startsWith("#")).join(`
+`).trim();
+}
+async function editTextInEditor(hint, initial) {
+  const editPath = tempFile("git-ai-edit", "md");
+  try {
+    await Bun.write(editPath, `# ${hint}
+
+${initial}`);
+    console.log(`Opening ${resolveEditor()}...`);
+    await openFileInEditor(editPath);
+    const edited = stripEditComments(await readFileText(editPath));
+    if (!edited) {
+      throw new Error("Edited text is empty");
+    }
+    return edited;
+  } finally {
+    await safeUnlink(editPath);
+  }
+}
+async function editResultField(result, fieldId) {
+  const field = editableFieldsForResult(result).find((item) => item.id === fieldId);
+  if (!field) {
+    throw new Error(`Unknown edit field: ${fieldId}`);
+  }
+  const edited = await editTextInEditor(field.hint, field.getValue(result));
+  return field.setValue(result, edited);
+}
+async function editResultInteractively(result) {
+  const fields = editableFieldsForResult(result);
+  const fieldId = await promptForEditField(fields.map((field) => ({ id: field.id, label: field.label })));
+  if (!fieldId)
+    return null;
+  return editResultField(result, fieldId);
+}
+async function confirmParsedResult(mode, initial, preview) {
+  let result = initial;
+  while (true) {
+    preview(result);
+    const action = await promptForExecutionConfirmation();
+    if (action === "no")
+      return null;
+    if (action === "edit") {
+      try {
+        const edited = await editResultInteractively(result);
+        if (edited) {
+          if (edited.mode !== mode) {
+            throw new Error(`Edited draft does not match mode ${mode}`);
+          }
+          result = edited;
+        }
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Edit canceled";
+        console.log(`${message}.`);
+      }
+      continue;
+    }
+    return result;
+  }
+}
+
+// src/clients/manual-client.ts
+var RESPONSE_HEADER = `# Paste the AI response below this line, save, and close the editor.
+
+`;
+async function readStdinUntilEof() {
+  return await new Promise((resolve, reject) => {
+    const chunks = [];
+    process.stdin.setEncoding("utf8");
+    process.stdin.resume();
+    process.stdin.on("data", (chunk) => chunks.push(String(chunk)));
+    process.stdin.on("end", () => resolve(chunks.join("").trim()));
+    process.stdin.on("error", reject);
+  });
+}
+async function collectResponseFromEditor(responsePath) {
+  await openFileInEditor(responsePath);
+  const content = stripEditComments((await readFileText(responsePath)).replace(RESPONSE_HEADER, ""));
+  if (!content)
+    throw new Error("Empty manual AI response");
+  return content;
+}
+async function collectResponseFromStdin() {
+  console.log(`Paste the AI response below, then press Ctrl+D when done:
+`);
+  const content = await readStdinUntilEof();
+  if (!content)
+    throw new Error("Empty manual AI response");
+  return content;
+}
+function printManualPrompt(prompt2, promptPath) {
+  console.log("");
+  console.log("[MANUAL] Copy the prompt below and paste it into any AI chat.");
+  console.log("[MANUAL] Send it, wait for the response, then choose Continue in the next step.");
+  console.log(`[MANUAL] Prompt file: ${promptPath}`);
+  console.log("----------------------------------------");
+  console.log(prompt2);
+  console.log("----------------------------------------");
+  console.log("");
+}
+async function collectManualResponseInteractive(prompt2, promptPath, responsePath) {
+  const editor = resolveEditor();
+  const action = await promptForManualPromptAction(editor);
+  if (action === "cancel") {
+    throw new Error("Manual input canceled");
+  }
+  if (action === "copy") {
+    await copyToClipboard(prompt2);
+    console.log("[MANUAL] Prompt copied to clipboard.");
+  } else {
+    printManualPrompt(prompt2, promptPath);
+    const ready = await promptForManualResponseReady();
+    if (!ready) {
+      throw new Error("Manual input canceled");
+    }
+  }
+  console.log(`[MANUAL] Opening ${editor}...`);
+  return await collectResponseFromEditor(responsePath);
+}
+
+class ManualAiClient {
+  async ask(prompt2, _maxTokens) {
+    const promptPath = tempFile("git-ai-prompt", "md");
+    const responsePath = tempFile("git-ai-response", "md");
+    try {
+      await Bun.write(promptPath, prompt2);
+      await Bun.write(responsePath, RESPONSE_HEADER);
+      if (process.stdin.isTTY && process.stdout.isTTY) {
+        return { content: await collectManualResponseInteractive(prompt2, promptPath, responsePath) };
+      }
+      return { content: await collectResponseFromStdin() };
+    } finally {
+      await safeUnlink(promptPath);
+      await safeUnlink(responsePath);
+    }
+  }
+}
+
+// src/config.ts
+function getOpenAiConfig() {
+  const baseUrl = process.env.OPENAI_BASE_URL;
+  const apiKey = process.env.OPENAI_API_KEY;
+  if (!baseUrl)
+    throw new Error("OPENAI_BASE_URL env var is required for OpenAI-compatible provider");
+  if (!apiKey)
+    throw new Error("OPENAI_API_KEY env var is required for OpenAI-compatible provider");
+  return {
+    baseUrl: baseUrl.replace(/\/+$/, ""),
+    apiKey,
+    model: process.env.OPENAI_MODEL ?? "gpt-4o-mini"
+  };
+}
+function getCursorSdkConfig() {
+  const apiKey = process.env.CURSOR_API_KEY;
+  if (!apiKey)
+    throw new Error("CURSOR_API_KEY env var is required for Cursor SDK provider");
+  return {
+    apiKey,
+    model: process.env.CURSOR_MODEL ?? "composer-2.5"
+  };
+}
+
+// src/ai-factory.ts
+function createAiSource(provider) {
+  switch (provider) {
+    case "openai":
+      return new AiClient(getOpenAiConfig());
+    case "cursor-sdk":
+      return new CursorSdkClient(getCursorSdkConfig());
+    case "manual":
+      return new ManualAiClient;
+  }
+}
+
+// src/token-report.ts
+var ANSI_RESET2 = "\x1B[0m";
+var ANSI_BOLD2 = "\x1B[1m";
+var ANSI_DIM2 = "\x1B[2m";
+var ANSI_MAGENTA2 = "\x1B[35m";
+function useColor2() {
+  return !!process.stdout.isTTY && !process.env.NO_COLOR;
+}
+function paint2(text, ansi) {
+  if (!useColor2())
+    return text;
+  return `${ansi}${text}${ANSI_RESET2}`;
+}
+function dim(text) {
+  return paint2(text, ANSI_DIM2);
+}
+function tag(text) {
+  return paint2(text, `${ANSI_BOLD2}${ANSI_MAGENTA2}`);
+}
+function formatTokenCount(count) {
+  if (count >= 1e4)
+    return `${Math.round(count / 1000)}k`;
+  if (count >= 1000)
+    return `${(count / 1000).toFixed(1)}k`;
+  return count.toLocaleString("en-US");
+}
+function formatUsd(cost) {
+  if (cost === 0)
+    return "$0";
+  if (cost < 0.01)
+    return `$${cost.toFixed(4)}`;
+  if (cost < 1)
+    return `$${cost.toFixed(3)}`;
+  return `$${cost.toFixed(2)}`;
+}
+function joinParts(parts) {
+  return parts.filter(Boolean).join(dim(" \xB7 "));
+}
+function hasUsageData(usage) {
+  return usage.promptTokens !== undefined || usage.completionTokens !== undefined || usage.totalTokens !== undefined || usage.costUsd !== undefined;
+}
+function printTokenUsage(usage, model) {
+  if (!hasUsageData(usage))
+    return;
+  const total = usage.totalTokens ?? (usage.promptTokens !== undefined && usage.completionTokens !== undefined ? usage.promptTokens + usage.completionTokens : undefined);
+  const parts = [
+    usage.promptTokens !== undefined ? `${formatTokenCount(usage.promptTokens)} in` : "",
+    usage.completionTokens !== undefined ? `${formatTokenCount(usage.completionTokens)} out` : "",
+    total !== undefined ? `${formatTokenCount(total)} total` : "",
+    usage.costUsd !== undefined ? formatUsd(usage.costUsd) : "",
+    model ?? ""
+  ];
+  console.log(`${tag("[tokens]")} ${joinParts(parts)}`);
+}
+
+// src/ai-session.ts
+function modelLabelForProvider(provider) {
+  if (provider === "openai")
+    return getOpenAiConfig().model;
+  if (provider === "cursor-sdk")
+    return getCursorSdkConfig().model;
+  return;
+}
+function showResponseTokenResult(provider, response) {
+  if (!response.usage)
+    return;
+  printTokenUsage(response.usage, modelLabelForProvider(provider));
+}
+
+// src/shell-error.ts
+function streamText(value) {
+  if (!value)
+    return "";
+  return typeof value === "string" ? value : value.toString();
+}
+function isShellError(error) {
+  return typeof error === "object" && error !== null && "exitCode" in error && typeof error.exitCode === "number";
+}
+function formatShellError(command, error) {
+  if (!isShellError(error)) {
+    return error instanceof Error ? error.message : String(error);
+  }
+  const stderr = streamText(error.stderr).trim();
+  const stdout = streamText(error.stdout).trim();
+  const detail = stderr || stdout || `exit code ${error.exitCode}`;
+  return `Command failed (exit ${error.exitCode}): ${command}
+
+${detail}`;
+}
+var STEP_ERROR_LOGGED = Symbol("gitAiStepErrorLogged");
+function markStepErrorLogged(error) {
+  error[STEP_ERROR_LOGGED] = true;
+}
+function wasStepErrorLogged(error) {
+  return typeof error === "object" && error !== null && error[STEP_ERROR_LOGGED] === true;
+}
+function formatStepError(error) {
+  if (error instanceof Error)
+    return error.message;
+  return String(error);
+}
+
+// src/clients/git-client.ts
+class GitClient {
+  async runShell(command, action) {
+    try {
+      return await action();
+    } catch (error) {
+      throw new Error(formatShellError(command, error), { cause: error });
+    }
+  }
+  async run(args) {
+    const command = `git ${args.join(" ")}`;
+    return this.runShell(command, () => Bun.$`git ${args}`.text());
+  }
+  currentBranch() {
+    return this.run(["branch", "--show-current"]);
+  }
+  async diffStat(args, changedFiles) {
+    const files = withoutDiffIgnoredFiles(await changedFiles());
+    if (files.length === 0)
+      return "";
+    return this.run([...args, "--stat", "--", ...files]);
+  }
+  async diffFull(args, changedFiles) {
+    const files = withoutDiffIgnoredFiles(await changedFiles());
+    if (files.length === 0)
+      return "";
+    return this.run([...args, "--", ...files]);
+  }
+  stagedStat() {
+    return this.diffStat(["diff", "--cached"], () => this.stagedFileNames());
+  }
+  stagedDiff() {
+    return this.diffFull(["diff", "--cached"], () => this.stagedFileNames());
+  }
+  rangeLog(base) {
+    return this.run(["log", `${base}..HEAD`, "--oneline", "--no-decorate"]);
+  }
+  rangeChangedFileNames(base) {
+    return this.run(["diff", `${base}...HEAD`, "--name-only"]).then((text) => text.split(`
+`).map((line) => line.trim()).filter(Boolean));
+  }
+  rangeStat(base) {
+    return this.diffStat(["diff", `${base}...HEAD`], () => this.rangeChangedFileNames(base));
+  }
+  rangeDiff(base) {
+    return this.diffFull(["diff", `${base}...HEAD`], () => this.rangeChangedFileNames(base));
+  }
+  async hasCommitsAhead(base) {
+    const count = (await this.run(["rev-list", "--count", `${base}..HEAD`])).trim();
+    return Number.parseInt(count, 10) > 0;
+  }
+  checkoutBranch(name) {
+    return this.run(["checkout", "-b", name]);
+  }
+  checkoutExisting(name) {
+    return this.run(["checkout", name]);
+  }
+  deleteBranch(name) {
+    return this.run(["branch", "-D", name]);
+  }
+  stagedFileNames() {
+    return this.run(["diff", "--cached", "--name-only"]).then((text) => text.split(`
+`).map((line) => line.trim()).filter(Boolean));
+  }
+  addFiles(paths) {
+    if (paths.length === 0)
+      return Promise.resolve("");
+    return this.run(["add", "--", ...paths]);
+  }
+  commitFromFile(filePath) {
+    return this.run(["commit", "-F", filePath]);
+  }
+  pushCurrentBranch() {
+    return this.run(["push"]);
+  }
+  pushCurrentBranchWithUpstream(branch) {
+    return this.run(["push", "-u", "origin", branch]);
+  }
+  pushBranch(branch) {
+    return this.run(["push", "-u", "origin", branch]);
+  }
+  createPr(title, bodyFile, baseBranch = "main") {
+    const command = `gh pr create --base ${baseBranch} --title ${title} --body-file ${bodyFile}`;
+    return this.runShell(command, () => Bun.$`gh pr create --base ${baseBranch} --title ${title} --body-file ${bodyFile}`.text());
+  }
+  async currentOpenPr() {
+    try {
+      const json = await Bun.$`gh pr view --json number,title,body,url,baseRefName`.text();
+      const parsed = JSON.parse(json.trim());
+      return {
+        number: parsed.number,
+        title: parsed.title ?? "",
+        body: parsed.body ?? "",
+        url: parsed.url ?? "",
+        baseBranch: parsed.baseRefName ?? "main"
+      };
+    } catch {
+      return null;
+    }
+  }
+  updatePr(title, bodyFile) {
+    const command = `gh pr edit --title ${title} --body-file ${bodyFile}`;
+    return this.runShell(command, () => Bun.$`gh pr edit --title ${title} --body-file ${bodyFile}`.text());
+  }
+}
+
+// src/prompt-builder.ts
+import { existsSync as existsSync2 } from "fs";
+import { join as join4 } from "path";
+
+// src/prompt-files.ts
+var MODE_PROMPT_FILES = {
+  "branch-commit-pr": "branch-commit-pr.md",
+  "branch-commit-push": "branch-commit-push.md",
+  "commit-push": "commit-push.md",
+  "create-pr": "create-pr.md",
+  "update-pr": "create-pr.md"
+};
+
+// src/prompt-builder.ts
+var templateCache = new Map;
+async function loadBundledModeTemplate(fileName) {
+  const templatePath = join4(import.meta.dir, "prompts", fileName);
+  const content = await Bun.file(templatePath).text();
+  if (!content.trim()) {
+    throw new Error(`Prompt template is empty: ${templatePath}`);
+  }
+  return content.trim();
+}
+async function loadModeTemplate(mode) {
+  const fileName = MODE_PROMPT_FILES[mode];
+  const cached = templateCache.get(fileName);
+  if (cached)
+    return cached;
+  const repoRoot = await getRepoRoot();
+  const projectPromptPath = join4(repoRoot, PROMPTS_DIR, fileName);
+  const content = existsSync2(projectPromptPath) ? await Bun.file(projectPromptPath).text() : await loadBundledModeTemplate(fileName);
+  if (!content.trim()) {
+    throw new Error(`Prompt template is empty: ${fileName}`);
+  }
+  templateCache.set(fileName, content.trim());
+  return content.trim();
+}
+async function loadPrTemplate() {
+  const { prTemplate } = getProjectConfig();
+  const templatePath = await resolveRepoPath(prTemplate);
+  try {
+    if (!existsSync2(templatePath))
+      return null;
+    const content = await Bun.file(templatePath).text();
+    return content.trim() || null;
+  } catch {
+    return null;
+  }
+}
+var BRANCH_PR_SECTIONS = ["Commit log", "Diff stat", "Full diff", "Git conventions", "PR template"];
+var SECTIONS = {
+  "branch-commit-pr": ["Diff stat", "Full diff", "Git conventions", "PR template"],
+  "branch-commit-push": ["Diff stat", "Full diff", "Git conventions"],
+  "commit-push": ["Diff stat", "Full diff", "Git conventions"],
+  "create-pr": [...BRANCH_PR_SECTIONS],
+  "update-pr": [...BRANCH_PR_SECTIONS]
+};
+async function buildPrompt(mode, stat, diff, conventions, branchPrContext) {
+  const modeSection = await loadModeTemplate(mode);
+  const parts = ["You help developers with git.", "", modeSection, ""];
+  if ((mode === "create-pr" || mode === "update-pr") && branchPrContext) {
+    parts.push(`Base branch: ${branchPrContext.baseBranch}`, "", `### ${BRANCH_PR_SECTIONS[0]}`, "```", branchPrContext.log.trim() || "(no commits)", "```", "", `### ${BRANCH_PR_SECTIONS[1]}`, "```", stat.trim() || "(no file changes)", "```", "", `### ${BRANCH_PR_SECTIONS[2]}`, "```", diff.trim() || "(no diff)", "```", "", `### ${BRANCH_PR_SECTIONS[3]}`, "```", conventions, "```");
+    const prTemplate = await loadPrTemplate();
+    if (prTemplate) {
+      parts.push("", `### ${BRANCH_PR_SECTIONS[4]}`, "```", prTemplate, "```");
+    }
+    return parts.join(`
+`);
+  }
+  parts.push(`### ${SECTIONS[mode][0]}`, "```", stat.trim(), "```", "", `### ${SECTIONS[mode][1]}`, "```", diff.trim() || "(no diff)", "```", "", `### ${SECTIONS[mode][2]}`, "```", conventions, "```");
+  if (mode === "branch-commit-pr") {
+    const prTemplate = await loadPrTemplate();
+    if (prTemplate) {
+      parts.push("", `### ${SECTIONS[mode][3]}`, "```", prTemplate, "```");
+    }
+  }
+  return parts.join(`
+`);
+}
+
+// src/draft-cache.ts
+import { createHash } from "crypto";
+import { join as join5 } from "path";
+import { tmpdir as tmpdir2 } from "os";
+var cacheFilePath = null;
+async function getCacheFilePath() {
+  if (cacheFilePath)
+    return cacheFilePath;
+  const repoRoot = await getRepoRoot();
+  const repoId = createHash("sha256").update(repoRoot).digest("hex").slice(0, 12);
+  cacheFilePath = join5(tmpdir2(), `git-ai-draft-${repoId}.json`);
+  return cacheFilePath;
+}
+function normalizeForFingerprint(value) {
+  return value.trim().replace(/\r\n/g, `
+`);
+}
+function stagedDiffFingerprint(stat, diff) {
+  const normalizedStat = normalizeForFingerprint(stat);
+  const normalizedDiff = normalizeForFingerprint(diff);
+  const diffHash = createHash("sha256").update(normalizedDiff).digest("hex").slice(0, 16);
+  return `${normalizedStat}
+---
+${diffHash}`;
+}
+async function loadCachedDraft(fingerprint, mode) {
+  try {
+    const file = Bun.file(await getCacheFilePath());
+    if (!await file.exists())
+      return null;
+    const parsed = await file.json();
+    if (parsed.fingerprint !== fingerprint || parsed.mode !== mode)
+      return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+async function saveCachedDraft(fingerprint, mode, result) {
+  const payload = { fingerprint, mode, result };
+  await Bun.write(await getCacheFilePath(), JSON.stringify(payload, null, 2));
+}
+
+// src/parser.ts
+function stripSingleCodeFence(raw) {
+  return raw.replace(/^```[\w-]*\n?/, "").replace(/\n?```\s*$/, "").trim();
+}
+function matchTaggedLine(raw, tag2, valuePattern = "(.+)") {
+  return raw.match(new RegExp(`^${tag2}\\s*:\\s*${valuePattern}$`, "im"));
+}
+function normalizeCommitTitle(rawTitle) {
+  const title = stripSingleCodeFence(rawTitle).replace(/^`(.+)`$/, "$1").trim();
+  const conventional = title.match(/^([a-z]+)(\[[^\]]+\]|\([^)]+\))?:\s+(.+)$/i);
+  if (!conventional)
+    return title;
+  const [, type, scope = "", description] = conventional;
+  return `${type.toLowerCase()}${scope}: ${description.trim()}`;
+}
+function extractFallbackCommit(raw) {
+  const cleaned = stripSingleCodeFence(raw);
+  const lines = cleaned.split(/\r?\n/);
+  const conventionalIndex = lines.findIndex((line) => /^[a-z]+(?:\[[^\]]+\]|\([^)]+\))?:\s+\S/i.test(line.trim()));
+  const firstNonEmptyIndex = lines.findIndex((line) => line.trim().length > 0);
+  const start = conventionalIndex >= 0 ? conventionalIndex : firstNonEmptyIndex;
+  if (start < 0)
+    return null;
+  let title = lines[start].trim().replace(/^[-*]\s+/, "");
+  if (/^commit(?:\s+message)?\s*:?\s*$/i.test(title)) {
+    const nextNonEmpty = lines.slice(start + 1).findIndex((line) => line.trim().length > 0);
+    if (nextNonEmpty >= 0) {
+      title = lines[start + 1 + nextNonEmpty].trim().replace(/^[-*]\s+/, "");
+    }
+  }
+  if (!title)
+    return null;
+  const body = stripSingleCodeFence(lines.slice(start + 1).join(`
+`).trim());
+  return { title: normalizeCommitTitle(title), body };
+}
+function parseCommitMessage(raw) {
+  const commitLine = matchTaggedLine(raw, "COMMIT");
+  if (!commitLine) {
+    const fallback = extractFallbackCommit(raw);
+    if (!fallback) {
+      console.error(`Could not parse AI response:
+`, raw);
+      throw new Error("Expected COMMIT: line or plain commit message in AI response");
+    }
+    return fallback.body ? `${fallback.title}
+${fallback.body}` : fallback.title;
+  }
+  const title = normalizeCommitTitle(commitLine[1].trim());
+  const start = raw.indexOf(commitLine[0]) + commitLine[0].length;
+  const rest = stripSingleCodeFence(raw.slice(start).trim());
+  return rest ? `${title}
+${rest}` : title;
+}
+function parseBranchCommitPush(raw) {
+  const branchLine = matchTaggedLine(raw, "BRANCH");
+  const commitLine = matchTaggedLine(raw, "COMMIT");
+  if (!branchLine || !commitLine) {
+    console.error(`Could not parse AI response:
+`, raw);
+    throw new Error("Expected BRANCH: and COMMIT: lines in AI response");
+  }
+  const title = normalizeCommitTitle(commitLine[1].trim());
+  const branchName = stripSingleCodeFence(branchLine[1].trim());
+  const commitStart = raw.indexOf(commitLine[0]) + commitLine[0].length;
+  const commitBody = stripSingleCodeFence(raw.slice(commitStart).trim());
+  return {
+    mode: "branch-commit-push",
+    branchName,
+    commitMessage: commitBody ? `${title}
+${commitBody}` : title
+  };
+}
+function parseTaggedSection(raw, tag2) {
+  const lines = raw.split(/\r?\n/);
+  const headerLineIndex = lines.findIndex((line) => new RegExp(`^${tag2}\\s*:`, "i").test(line));
+  if (headerLineIndex < 0)
+    return "";
+  const headerLine = lines[headerLineIndex];
+  const inline = headerLine.replace(new RegExp(`^${tag2}\\s*:\\s*`, "i"), "").trim();
+  if (inline)
+    return stripSingleCodeFence(inline);
+  return stripSingleCodeFence(lines.slice(headerLineIndex + 1).join(`
+`).trim());
+}
+function parseBranchCommitPr(raw) {
+  const branchLine = matchTaggedLine(raw, "BRANCH");
+  const commitLine = matchTaggedLine(raw, "COMMIT");
+  if (!branchLine || !commitLine) {
+    console.error(`Could not parse AI response:
+`, raw);
+    throw new Error("Expected BRANCH: and COMMIT: lines in AI response");
+  }
+  const title = normalizeCommitTitle(commitLine[1].trim());
+  const branchName = stripSingleCodeFence(branchLine[1].trim());
+  const commitStart = raw.indexOf(commitLine[0]) + commitLine[0].length;
+  const prLine = matchTaggedLine(raw, "PR_DESC", "(.*)");
+  const prStart = prLine ? raw.indexOf(prLine[0]) : -1;
+  const bodySlice = prStart >= 0 ? raw.slice(commitStart, prStart) : raw.slice(commitStart);
+  const commitBody = stripSingleCodeFence(bodySlice.trim());
+  const prDescription = parseTaggedSection(raw, "PR_DESC");
+  return {
+    mode: "branch-commit-pr",
+    branchName,
+    title,
+    commitMessage: commitBody ? `${title}
+${commitBody}` : title,
+    prDescription
+  };
+}
+function parsePrText(raw, mode) {
+  const titleLine = matchTaggedLine(raw, "PR_TITLE");
+  if (!titleLine) {
+    console.error(`Could not parse AI response:
+`, raw);
+    throw new Error("Expected PR_TITLE: line in AI response");
+  }
+  const title = normalizeCommitTitle(titleLine[1].trim());
+  const prDescription = parseTaggedSection(raw, "PR_DESC");
+  return {
+    mode,
+    title,
+    prDescription
+  };
+}
+function parseCreatePr(raw) {
+  return parsePrText(raw, "create-pr");
+}
+function parseUpdatePr(raw) {
+  return parsePrText(raw, "update-pr");
+}
+function parseResult(mode, raw) {
+  if (mode === "create-pr") {
+    return parseCreatePr(raw);
+  }
+  if (mode === "update-pr") {
+    return parseUpdatePr(raw);
+  }
+  if (mode === "branch-commit-pr") {
+    return parseBranchCommitPr(raw);
+  }
+  if (mode === "branch-commit-push") {
+    return parseBranchCommitPush(raw);
+  }
+  return {
+    mode: "commit-push",
+    commitMessage: parseCommitMessage(raw)
+  };
+}
+
+// src/progress.ts
+var ANSI_RESET3 = "\x1B[0m";
+var ANSI_DIM3 = "\x1B[2m";
+var ANSI_CYAN2 = "\x1B[36m";
+var ANSI_GREEN2 = "\x1B[32m";
+var ANSI_RED = "\x1B[31m";
+var BRAILLE_BASE = 10240;
+var SIX_DOT_ORDER = [0, 3, 1, 4, 2, 5];
+function isInteractiveOutput() {
+  return !!process.stdout.isTTY;
+}
+function formatElapsedMs(ms) {
+  return `${(ms / 1000).toFixed(1)}s`;
+}
+function color(text, ansi) {
+  return `${ansi}${text}${ANSI_RESET3}`;
+}
+function logStepFailure(error) {
+  const message = formatStepError(error);
+  console.error(color(message, ANSI_RED));
+  if (error instanceof Error) {
+    markStepErrorLogged(error);
+  }
+}
+function buildSixDotBraille(frameIndex) {
+  const filledDots = frameIndex % (SIX_DOT_ORDER.length + 1);
+  let mask = 0;
+  for (let i = 0;i < filledDots; i++) {
+    mask |= 1 << SIX_DOT_ORDER[i];
+  }
+  return String.fromCodePoint(BRAILLE_BASE + mask);
+}
+async function runStep(label, action) {
+  const startedAt = Date.now();
+  if (!isInteractiveOutput()) {
+    console.log(`${label}...`);
+    try {
+      const result = await action();
+      console.log(`[done] ${label} (${formatElapsedMs(Date.now() - startedAt)})`);
+      return result;
+    } catch (error) {
+      console.error(`[failed] ${label} (${formatElapsedMs(Date.now() - startedAt)})`);
+      logStepFailure(error);
+      throw error;
+    }
+  }
+  let frameIndex = 0;
+  const render = () => {
+    const frame = buildSixDotBraille(frameIndex);
+    const elapsed = formatElapsedMs(Date.now() - startedAt);
+    frameIndex += 1;
+    process.stdout.write(`\r\x1B[2K${color(frame, ANSI_CYAN2)} ${label} ${color(elapsed, ANSI_DIM3)}`);
+  };
+  render();
+  const timer = setInterval(render, 90);
+  timer.unref?.();
+  try {
+    const result = await action();
+    clearInterval(timer);
+    const elapsed = formatElapsedMs(Date.now() - startedAt);
+    process.stdout.write(`\r\x1B[2K${color("[ok]", ANSI_GREEN2)} ${label} ${color(`(${elapsed})`, ANSI_DIM3)}
+`);
+    return result;
+  } catch (error) {
+    clearInterval(timer);
+    const elapsed = formatElapsedMs(Date.now() - startedAt);
+    process.stdout.write(`\r\x1B[2K${color("[x]", ANSI_RED)} ${label} ${color(`(${elapsed})`, ANSI_DIM3)}
+`);
+    logStepFailure(error);
+    throw error;
+  }
+}
+
+// src/conventions.ts
+import { existsSync as existsSync3 } from "fs";
+import { join as join6 } from "path";
+async function loadBundledConventions() {
+  const path = `${import.meta.dir}/prompts/git-conventions.md`;
+  return Bun.file(path).text();
+}
+async function readConventions() {
+  const { conventions } = getProjectConfig();
+  if (conventions) {
+    const path = await resolveRepoPath(conventions);
+    if (!existsSync3(path)) {
+      throw new Error(`Conventions file not found: ${conventions}`);
+    }
+    return Bun.file(path).text();
+  }
+  const repoRoot = await getRepoRoot();
+  const projectConventions = join6(repoRoot, CONVENTIONS_FILE);
+  if (existsSync3(projectConventions)) {
+    return Bun.file(projectConventions).text();
+  }
+  return loadBundledConventions();
+}
+
+// src/workflow-prompt.ts
+async function readStagedPromptInputs(git) {
+  const stagedFiles = await runStep("Reading staged file list", () => git.stagedFileNames());
+  if (stagedFiles.length === 0) {
+    console.log("No staged changes. Stage files first with git add.");
+    return null;
+  }
+  if (withoutDiffIgnoredFiles(stagedFiles).length === 0) {
+    console.log("Only ignored files (e.g. lockfiles) are staged; git-ai has nothing meaningful to analyze.");
+    return null;
+  }
+  const stat = await runStep("Reading staged changes summary", () => git.stagedStat());
+  const diff = await runStep("Reading staged diff", () => git.stagedDiff());
+  const conventions = await runStep("Loading git conventions", () => readConventions());
+  return { stat, diff, conventions };
+}
+async function buildStagedPrompt(git, mode) {
+  const inputs = await readStagedPromptInputs(git);
+  if (!inputs)
+    return null;
+  return runStep("Loading AI prompt template", () => buildPrompt(mode, inputs.stat, inputs.diff, inputs.conventions));
+}
+async function buildBranchPrPrompt(git, branch, mode, options = {}) {
+  const { baseBranch } = getProjectConfig();
+  if (branch === baseBranch) {
+    console.log(`Cannot build a PR prompt from ${baseBranch}. Switch to a feature branch first.`);
+    return null;
+  }
+  if (options.requireOpenPr) {
+    const openPr = await runStep("Finding open PR", () => git.currentOpenPr());
+    if (!openPr) {
+      console.log("No open PR found for this branch. Use create-pr mode instead.");
+      return null;
+    }
+    console.log(`Open PR: #${openPr.number} ${openPr.url}
+`);
+  }
+  const hasCommits = await runStep(`Checking commits ahead of ${baseBranch}`, () => git.hasCommitsAhead(baseBranch));
+  if (!hasCommits) {
+    console.log(`No commits on ${branch} that are not in ${baseBranch}.`);
+    return null;
+  }
+  const log = await runStep(`Reading commit log (${baseBranch}..HEAD)`, () => git.rangeLog(baseBranch));
+  const stat = await runStep(`Reading diff stat (${baseBranch}...HEAD)`, () => git.rangeStat(baseBranch));
+  const diff = await runStep(`Reading full diff (${baseBranch}...HEAD)`, () => git.rangeDiff(baseBranch));
+  const conventions = await runStep("Loading git conventions", () => readConventions());
+  return runStep("Loading AI prompt template", () => buildPrompt(mode, stat, diff, conventions, { baseBranch, log }));
+}
+
+// src/staged-fix.ts
+var import_ignore2 = __toESM(require_ignore(), 1);
+import { existsSync as existsSync4 } from "fs";
+import { join as join7 } from "path";
+function ruleMatches(rule, stagedFiles) {
+  if (rule.paths.length === 0)
+    return false;
+  const matcher2 = import_ignore2.default().add(rule.paths);
+  return stagedFiles.some((file) => matcher2.ignores(file));
+}
+function commandsForStagedFiles(stagedFiles) {
+  const { stagedFix } = getProjectConfig();
+  const commands = new Set;
+  for (const rule of stagedFix.rules) {
+    if (ruleMatches(rule, stagedFiles)) {
+      commands.add(rule.command);
+    }
+  }
+  if (stagedFix.root && ruleMatches(stagedFix.root, stagedFiles)) {
+    commands.add(stagedFix.root.command);
+  }
+  return [...commands];
+}
+async function runCommand(repoRoot, command) {
+  const result = await Bun.$`sh -c ${command}`.cwd(repoRoot).quiet().nothrow();
+  if (result.exitCode !== 0) {
+    const detail = result.stderr.toString().trim() || result.stdout.toString().trim();
+    if (detail) {
+      console.error(`[warn] ${command} exited with code ${result.exitCode}
+${detail}`);
+    }
+  }
+}
+async function fixStagedWorkspaces(stagedFiles) {
+  if (stagedFiles.length === 0)
+    return;
+  const commands = commandsForStagedFiles(stagedFiles);
+  if (commands.length === 0)
+    return;
+  const repoRoot = await getRepoRoot();
+  await Promise.all(commands.map((command) => runCommand(repoRoot, command)));
+}
+async function restageFiles(git, stagedFiles) {
+  if (stagedFiles.length === 0)
+    return;
+  const repoRoot = await getRepoRoot();
+  const pathsToAdd = stagedFiles.filter((file) => existsSync4(join7(repoRoot, file)));
+  if (pathsToAdd.length === 0)
+    return;
+  await git.addFiles(pathsToAdd);
+}
+async function fixAndRestageStaged(git, stagedFiles) {
+  await fixStagedWorkspaces(stagedFiles);
+  await restageFiles(git, stagedFiles);
+}
+
+// src/workflow.ts
+async function prepareStagedForCommit(git, stagedFiles) {
+  await runStep("Applying format/lint fixes to staged files", () => fixAndRestageStaged(git, stagedFiles));
+}
+async function commitFromFileWithRetry(git, commitFile, stagedFiles) {
+  try {
+    await git.commitFromFile(commitFile);
+    return;
+  } catch (firstError) {
+    await runStep("Retrying commit after format/lint fixes", () => fixAndRestageStaged(git, stagedFiles));
+    try {
+      await git.commitFromFile(commitFile);
+      return;
+    } catch {
+      throw firstError;
+    }
+  }
+}
+async function rollbackNewBranch(git, sourceBranch, newBranch) {
+  try {
+    const current = (await git.currentBranch()).trim();
+    if (current === newBranch) {
+      await runStep(`Rolling back to ${sourceBranch}`, () => git.checkoutExisting(sourceBranch));
+    }
+    await runStep(`Deleting branch ${newBranch}`, () => git.deleteBranch(newBranch));
+  } catch {
+    console.error(`Could not fully roll back branch ${newBranch}. You may need to delete it manually.`);
+  }
+}
+async function runStagedCommit(git, commitFile, stagedFiles, sourceBranch, newBranch) {
+  try {
+    await runStep("Creating commit", () => commitFromFileWithRetry(git, commitFile, stagedFiles));
+  } catch (error) {
+    if (newBranch) {
+      await rollbackNewBranch(git, sourceBranch, newBranch);
+    }
+    throw error;
+  }
+}
+async function executeCommitPush(git, branch, commitMessage, context) {
+  const commitFile = tempFile("git-ai-commit", "msg");
+  try {
+    await Bun.write(commitFile, commitMessage);
+    await prepareStagedForCommit(git, context.stagedFiles);
+    await runStagedCommit(git, commitFile, context.stagedFiles, context.sourceBranch);
+    try {
+      await runStep("Pushing current branch", () => git.pushCurrentBranch());
+    } catch {
+      await runStep("Pushing with upstream tracking", () => git.pushCurrentBranchWithUpstream(branch));
+    }
+  } finally {
+    await safeUnlink(commitFile);
+  }
+}
+async function executeBranchCommitPush(git, result, context) {
+  const commitFile = tempFile("git-ai-branch-commit", "msg");
+  try {
+    await Bun.write(commitFile, result.commitMessage);
+    await prepareStagedForCommit(git, context.stagedFiles);
+    await runStep(`Creating branch ${result.branchName}`, () => git.checkoutBranch(result.branchName));
+    await runStagedCommit(git, commitFile, context.stagedFiles, context.sourceBranch, result.branchName);
+    await runStep(`Pushing branch ${result.branchName}`, () => git.pushBranch(result.branchName));
+  } finally {
+    await safeUnlink(commitFile);
+  }
+}
+async function executeCreatePr(git, branch, baseBranch, result) {
+  const prFile = tempFile("git-ai-pr-desc", "md");
+  try {
+    await Bun.write(prFile, result.prDescription || result.title);
+    try {
+      await runStep("Pushing current branch", () => git.pushCurrentBranch());
+    } catch {
+      await runStep("Pushing with upstream tracking", () => git.pushCurrentBranchWithUpstream(branch));
+    }
+    await runStep("Creating PR", () => git.createPr(result.title, prFile, baseBranch));
+  } finally {
+    await safeUnlink(prFile);
+  }
+}
+async function executeUpdatePr(git, branch, result) {
+  const prFile = tempFile("git-ai-pr-desc", "md");
+  try {
+    await Bun.write(prFile, result.prDescription || result.title);
+    try {
+      await runStep("Pushing current branch", () => git.pushCurrentBranch());
+    } catch {
+      await runStep("Pushing with upstream tracking", () => git.pushCurrentBranchWithUpstream(branch));
+    }
+    await runStep("Updating PR", () => git.updatePr(result.title, prFile));
+  } finally {
+    await safeUnlink(prFile);
+  }
+}
+async function executeBranchCommitPr(git, result, context) {
+  const commitFile = tempFile("git-ai-branch-commit", "msg");
+  const prFile = tempFile("git-ai-pr-desc", "md");
+  try {
+    await Bun.write(commitFile, result.commitMessage);
+    await Bun.write(prFile, result.prDescription || result.commitMessage);
+    await prepareStagedForCommit(git, context.stagedFiles);
+    await runStep(`Creating branch ${result.branchName}`, () => git.checkoutBranch(result.branchName));
+    await runStagedCommit(git, commitFile, context.stagedFiles, context.sourceBranch, result.branchName);
+    await runStep(`Pushing branch ${result.branchName}`, () => git.pushBranch(result.branchName));
+    await runStep("Creating PR", () => git.createPr(result.title, prFile));
+  } finally {
+    await safeUnlink(commitFile);
+    await safeUnlink(prFile);
+  }
+}
+
+// src/index.ts
+async function runDryRun(git, branch, mode) {
+  const promptText = mode === "create-pr" || mode === "update-pr" ? await buildBranchPrPrompt(git, branch, mode) : await buildStagedPrompt(git, mode);
+  if (!promptText)
+    return;
+  printDryRunPrompt(promptText);
+}
+async function runBranchPr(git, provider, branch, mode) {
+  const { baseBranch } = getProjectConfig();
+  let prNumber;
+  if (mode === "update-pr") {
+    const openPr = await runStep("Finding open PR", () => git.currentOpenPr());
+    if (!openPr) {
+      console.log("No open PR found for this branch. Use create-pr mode instead.");
+      return;
+    }
+    prNumber = openPr.number;
+    console.log(`Open PR: #${openPr.number} ${openPr.url}
+`);
+  }
+  const promptText = await buildBranchPrPrompt(git, branch, mode);
+  if (!promptText)
+    return;
+  const ai = createAiSource(provider);
+  const maxTokens = getMaxTokens(mode);
+  const response = provider === "manual" ? await ai.ask(promptText, maxTokens) : await runStep("Waiting for AI response", () => ai.ask(promptText, maxTokens));
+  showResponseTokenResult(provider, response);
+  const raw = response.content;
+  let result = parseResult(mode, raw);
+  if (result.mode !== mode) {
+    throw new Error(`Unexpected ${mode} result: ${result.mode}`);
+  }
+  const confirmed = await confirmParsedResult(mode, result, (draft) => {
+    printAiPreview(branch, draft, baseBranch, prNumber);
+  });
+  if (!confirmed) {
+    console.log("Canceled. No git actions were executed.");
+    return;
+  }
+  result = confirmed;
+  if (mode === "update-pr") {
+    if (result.mode !== "update-pr") {
+      throw new Error(`Unexpected update-pr result: ${result.mode}`);
+    }
+    await executeUpdatePr(git, branch, result);
+    return;
+  }
+  if (result.mode !== "create-pr") {
+    throw new Error(`Unexpected create-pr result: ${result.mode}`);
+  }
+  await executeCreatePr(git, branch, baseBranch, result);
+}
+async function runStagedWorkflow(git, provider, branch, mode) {
+  const inputs = await readStagedPromptInputs(git);
+  if (!inputs)
+    return;
+  const { stat, diff, conventions } = inputs;
+  const fingerprint = stagedDiffFingerprint(stat, diff);
+  const cached = await loadCachedDraft(fingerprint, mode);
+  let result;
+  if (cached) {
+    const reuse = await promptForCachedDraftReuse();
+    if (reuse) {
+      result = cached.result;
+      console.log("");
+      console.log(`Reusing cached AI draft for matching staged changes.
+`);
+    }
+  }
+  if (!result) {
+    const promptText = await runStep("Loading AI prompt template", () => buildPrompt(mode, stat, diff, conventions));
+    const ai = createAiSource(provider);
+    const maxTokens = getMaxTokens(mode);
+    const response = provider === "manual" ? await ai.ask(promptText, maxTokens) : await runStep("Waiting for AI response", () => ai.ask(promptText, maxTokens));
+    showResponseTokenResult(provider, response);
+    result = parseResult(mode, response.content);
+    await saveCachedDraft(fingerprint, mode, result);
+  }
+  const confirmed = await confirmParsedResult(mode, result, (draft) => {
+    printAiPreview(branch, draft);
+  });
+  if (!confirmed) {
+    console.log("Canceled. No git actions were executed.");
+    return;
+  }
+  result = confirmed;
+  const stagedFiles = await runStep("Reading staged file list", () => git.stagedFileNames());
+  const context = { stagedFiles, sourceBranch: branch };
+  if (result.mode === "branch-commit-pr") {
+    await executeBranchCommitPr(git, result, context);
+    return;
+  }
+  if (result.mode === "branch-commit-push") {
+    await executeBranchCommitPush(git, result, context);
+    return;
+  }
+  if (result.mode !== "commit-push") {
+    throw new Error(`Unexpected staged workflow result: ${result.mode}`);
+  }
+  await executeCommitPush(git, branch, result.commitMessage, context);
+}
+async function run(forcedMode) {
+  const args = process.argv.slice(2);
+  if (args.includes("--help") || args.includes("-h")) {
+    await printHelp();
+    return;
+  }
+  const dryRun = parseDryRunFromArgs(args);
+  await loadProjectConfig();
+  const git = new GitClient;
+  const branch = (await git.currentBranch()).trim();
+  const mode = forcedMode ?? parseModeFromArgs(args) ?? await promptForMode(branch);
+  console.log(`Current branch: ${branch}`);
+  console.log(`Mode: ${getModeMeta(mode).label}`);
+  if (dryRun) {
+    console.log(`Dry run: prompt only (no AI, no git actions)
+`);
+    await runDryRun(git, branch, mode);
+    return;
+  }
+  const provider = parseProviderFromArgs(args) ?? await promptForProvider();
+  console.log(`AI provider: ${PROVIDER_META[provider].label}
+`);
+  if (mode === "create-pr" || mode === "update-pr") {
+    await runBranchPr(git, provider, branch, mode);
+    return;
+  }
+  await runStagedWorkflow(git, provider, branch, mode);
+}
+if (import.meta.main) {
+  run().catch((err) => {
+    if (!wasStepErrorLogged(err)) {
+      console.error(err instanceof Error ? err.message : err);
+    }
+    process.exit(1);
+  });
+}
+export {
+  run
+};