@cam5/baby-bird 0.1.0

package/dist/chunk-RWSCST2I.js

@@ -0,0 +1,1753 @@
+// src/core/schema.ts
+import { z } from "zod";
+var LlmExcerptRefSchema = z.object({
+  hunk: z.string().min(1),
+  /** Optional [start, end] range of new-file line numbers to narrow the hunk. */
+  lines: z.tuple([z.number().int().nonnegative(), z.number().int().nonnegative()]).optional(),
+  note: z.string().optional()
+});
+var LlmSectionSchema = z.object({
+  title: z.string().min(1),
+  description: z.string(),
+  files: z.array(z.string()).optional(),
+  excerpts: z.array(LlmExcerptRefSchema).optional()
+});
+var LlmTourOutputSchema = z.object({
+  title: z.string().min(1),
+  summary: z.string(),
+  sections: z.array(LlmSectionSchema).min(1)
+});
+var HunkLineSchema = z.object({
+  type: z.enum(["add", "del", "ctx"]),
+  oldNo: z.number().int().optional(),
+  newNo: z.number().int().optional(),
+  text: z.string()
+});
+var StatsSchema = z.object({
+  files: z.number().int(),
+  additions: z.number().int(),
+  deletions: z.number().int()
+});
+var TourSourceSchema = z.discriminatedUnion("kind", [
+  z.object({
+    kind: z.literal("range"),
+    base: z.string(),
+    head: z.string(),
+    baseSha: z.string(),
+    headSha: z.string(),
+    mergeBase: z.string().optional(),
+    resolvedBy: z.enum(["explicit", "pull-request", "ancestor-branch", "default-branch"])
+  }),
+  z.object({
+    kind: z.literal("working"),
+    headSha: z.string(),
+    staged: z.boolean(),
+    resolvedBy: z.enum(["explicit", "dirty-tree"])
+  })
+]);
+var TourSchema = z.object({
+  version: z.literal(1),
+  generatedAt: z.string(),
+  source: TourSourceSchema,
+  generator: z.object({ preset: z.string().nullable(), command: z.array(z.string()) }),
+  pullRequest: z.object({ number: z.number().int(), title: z.string(), url: z.string() }).optional(),
+  title: z.string(),
+  summary: z.string(),
+  stats: StatsSchema,
+  sections: z.array(
+    z.object({
+      id: z.string(),
+      title: z.string(),
+      description: z.string(),
+      files: z.array(z.string()),
+      stats: StatsSchema,
+      excerpts: z.array(
+        z.object({
+          file: z.string(),
+          hunkId: z.string(),
+          note: z.string().optional(),
+          oldStart: z.number().int(),
+          newStart: z.number().int(),
+          lines: z.array(HunkLineSchema)
+        })
+      )
+    })
+  )
+});
+function formatIssues(error) {
+  return error.issues.map((issue) => {
+    const path = issue.path.length ? issue.path.map(String).join(".") : "(root)";
+    return `${path}: ${issue.message}`;
+  }).join("; ");
+}
+
+// src/core/errors.ts
+var BbError = class extends Error {
+  exitCode;
+  hint;
+  constructor(message, opts = {}) {
+    super(message, opts.cause === void 0 ? void 0 : { cause: opts.cause });
+    this.name = new.target.name;
+    this.exitCode = opts.exitCode ?? 1;
+    this.hint = opts.hint;
+  }
+};
+var UsageError = class extends BbError {
+  constructor(message, hint) {
+    super(message, { exitCode: 2, hint });
+  }
+};
+var ConfigError = class extends BbError {
+  constructor(message, hint) {
+    super(message, { exitCode: 2, hint });
+  }
+};
+var NotARepoError = class extends BbError {
+  constructor(cwd) {
+    super(`Not a git repository: ${cwd}`, { exitCode: 3, hint: "Run bb inside a git repository, or pass --cwd <dir>." });
+  }
+};
+var GitError = class extends BbError {
+  constructor(message, opts = {}) {
+    super(message, { exitCode: 3, ...opts });
+  }
+};
+var NoChangesError = class extends BbError {
+  constructor(message, hint) {
+    super(message, { exitCode: 3, hint });
+  }
+};
+var LlmFailedError = class extends BbError {
+  constructor(message, opts = {}) {
+    super(message, { exitCode: 4, ...opts });
+  }
+};
+var BadLlmOutputError = class extends BbError {
+  raw;
+  constructor(message, raw, hint) {
+    super(message, { exitCode: 5, hint });
+    this.raw = raw;
+  }
+};
+
+// src/core/config.ts
+import { readFile } from "fs/promises";
+import { homedir } from "os";
+import { join } from "path";
+import { z as z2 } from "zod";
+var CLAUDE_BASE = ["claude", "-p", "--no-session-persistence", "--setting-sources", "", "--tools", ""];
+var BUILTIN_PRESETS = Object.freeze({
+  claude: {
+    command: [...CLAUDE_BASE],
+    description: "Claude Code CLI with its default model"
+  },
+  "claude-sonnet": {
+    command: [...CLAUDE_BASE, "--model", "sonnet", "--effort", "high"],
+    description: "Claude Code CLI, Sonnet at high effort"
+  },
+  "claude-opus": {
+    command: [...CLAUDE_BASE, "--model", "opus", "--effort", "high"],
+    description: "Claude Code CLI, Opus at high effort"
+  },
+  "claude-fable": {
+    command: [...CLAUDE_BASE, "--model", "fable", "--effort", "high"],
+    description: "Claude Code CLI, Fable at high effort"
+  },
+  "claude-haiku": {
+    command: [...CLAUDE_BASE, "--model", "haiku"],
+    description: "Claude Code CLI, Haiku (fast and cheap)"
+  },
+  llm: {
+    command: ["llm"],
+    description: "Simon Willison's llm CLI with its default model"
+  }
+});
+var PromptViaSchema = z2.enum(["stdin", "arg"]);
+var LlmPresetSchema = z2.object({
+  command: z2.array(z2.string()).min(1),
+  promptVia: PromptViaSchema.optional(),
+  description: z2.string().optional()
+});
+var ConfigSchema = z2.object({
+  llm: z2.object({
+    preset: z2.string().min(1),
+    presets: z2.record(z2.string(), LlmPresetSchema),
+    args: z2.array(z2.string()),
+    command: z2.array(z2.string()).min(1).nullable(),
+    promptVia: PromptViaSchema.nullable(),
+    timeoutMs: z2.number().int().positive(),
+    maxPromptBytes: z2.number().int().positive(),
+    env: z2.record(z2.string(), z2.string())
+  }),
+  codehost: z2.object({
+    provider: z2.enum(["gh", "none"])
+  }),
+  git: z2.object({
+    defaultBranch: z2.string().nullable(),
+    exclude: z2.array(z2.string())
+  }),
+  render: z2.object({
+    color: z2.enum(["auto", "always", "never"]),
+    pager: z2.enum(["auto", "always", "never"]),
+    maxExcerptLines: z2.number().int().positive(),
+    width: z2.number().int().positive().nullable()
+  }),
+  cache: z2.object({
+    enabled: z2.boolean(),
+    dir: z2.string().nullable()
+  })
+});
+var PartialConfigSchema = z2.object({
+  llm: ConfigSchema.shape.llm.partial().optional(),
+  codehost: ConfigSchema.shape.codehost.partial().optional(),
+  git: ConfigSchema.shape.git.partial().optional(),
+  render: ConfigSchema.shape.render.partial().optional(),
+  cache: ConfigSchema.shape.cache.partial().optional()
+});
+var DEFAULT_CONFIG = {
+  llm: {
+    preset: "claude",
+    presets: {},
+    args: [],
+    command: null,
+    promptVia: null,
+    timeoutMs: 18e4,
+    maxPromptBytes: 2e5,
+    env: {}
+  },
+  codehost: { provider: "gh" },
+  git: {
+    defaultBranch: null,
+    exclude: [
+      "**/pnpm-lock.yaml",
+      "**/package-lock.json",
+      "**/yarn.lock",
+      "**/Cargo.lock",
+      "**/*.min.*",
+      "**/dist/**",
+      "**/*.snap",
+      "**/*.map"
+    ]
+  },
+  render: { color: "auto", pager: "auto", maxExcerptLines: 60, width: null },
+  cache: { enabled: true, dir: null }
+};
+function userConfigPath(env = process.env) {
+  const base = env.XDG_CONFIG_HOME && env.XDG_CONFIG_HOME.trim() !== "" ? env.XDG_CONFIG_HOME : join(homedir(), ".config");
+  return join(base, "baby-bird", "config.json");
+}
+function defaultCacheDir(env = process.env) {
+  const base = env.XDG_CACHE_HOME && env.XDG_CACHE_HOME.trim() !== "" ? env.XDG_CACHE_HOME : join(homedir(), ".cache");
+  return join(base, "baby-bird");
+}
+function projectConfigPath(gitRoot2) {
+  return join(gitRoot2, ".baby-bird", "config.json");
+}
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function deepMerge(base, patch) {
+  if (!isPlainObject(base) || !isPlainObject(patch)) {
+    return patch === void 0 ? base : patch;
+  }
+  const out = { ...base };
+  for (const [key, value] of Object.entries(patch)) {
+    if (value === void 0) continue;
+    const existing = out[key];
+    out[key] = isPlainObject(existing) && isPlainObject(value) ? deepMerge(existing, value) : value;
+  }
+  return out;
+}
+async function readFileLayer(name, path) {
+  let text;
+  try {
+    text = await readFile(path, "utf8");
+  } catch (err) {
+    if (err.code === "ENOENT") {
+      return { name, path, found: false, data: {} };
+    }
+    throw new ConfigError(`Could not read ${path}: ${err.message}`);
+  }
+  let json;
+  try {
+    json = JSON.parse(text);
+  } catch (err) {
+    throw new ConfigError(`Invalid JSON in ${path}: ${err.message}`);
+  }
+  const parsed = PartialConfigSchema.safeParse(json);
+  if (!parsed.success) {
+    throw new ConfigError(`Invalid config in ${path}: ${formatIssues(parsed.error)}`);
+  }
+  return { name, path, found: true, data: parsed.data };
+}
+var TRUTHY = /* @__PURE__ */ new Set(["1", "true", "yes", "on"]);
+function envLayer(env) {
+  const data = {};
+  const applied = [];
+  const llm = {};
+  if (env.BB_PRESET) {
+    llm.preset = env.BB_PRESET;
+    applied.push("BB_PRESET");
+  }
+  if (env.BB_LLM_COMMAND) {
+    const argv = shellSplit(env.BB_LLM_COMMAND);
+    if (argv.length === 0) throw new ConfigError("BB_LLM_COMMAND is set but empty");
+    llm.command = argv;
+    applied.push("BB_LLM_COMMAND");
+  }
+  if (Object.keys(llm).length) data.llm = llm;
+  if (env.BB_CODEHOST) {
+    const provider = env.BB_CODEHOST;
+    data.codehost = { provider };
+    applied.push("BB_CODEHOST");
+  }
+  const cache = {};
+  if (env.BB_CACHE_DIR) {
+    cache.dir = env.BB_CACHE_DIR;
+    applied.push("BB_CACHE_DIR");
+  }
+  if (env.BB_NO_CACHE !== void 0 && TRUTHY.has(env.BB_NO_CACHE.toLowerCase())) {
+    cache.enabled = false;
+    applied.push("BB_NO_CACHE");
+  }
+  if (Object.keys(cache).length) data.cache = cache;
+  if (env.NO_COLOR !== void 0 && env.NO_COLOR !== "") {
+    data.render = { color: "never" };
+    applied.push("NO_COLOR");
+  }
+  return { name: "env", found: applied.length > 0, detail: applied.join(", "), data };
+}
+async function loadConfig(opts = {}) {
+  const env = opts.env ?? process.env;
+  const layers = [{ name: "defaults", found: true, data: DEFAULT_CONFIG }];
+  layers.push(await readFileLayer("user", userConfigPath(env)));
+  if (opts.gitRoot) {
+    layers.push(await readFileLayer("project", projectConfigPath(opts.gitRoot)));
+  }
+  layers.push(envLayer(env));
+  if (opts.overrides) {
+    const found = Object.keys(opts.overrides).length > 0;
+    layers.push({ name: "flags", found, data: opts.overrides });
+  }
+  let merged = {};
+  for (const layer of layers) merged = deepMerge(merged, layer.data);
+  const parsed = ConfigSchema.safeParse(merged);
+  if (!parsed.success) {
+    throw new ConfigError(`Invalid configuration: ${formatIssues(parsed.error)}`);
+  }
+  const config = parsed.data;
+  return { config, layers, cacheDir: config.cache.dir ?? defaultCacheDir(env) };
+}
+function allPresets(config) {
+  return { ...BUILTIN_PRESETS, ...config.llm.presets };
+}
+function resolveLlm(config) {
+  const { llm } = config;
+  const common = { timeoutMs: llm.timeoutMs, maxPromptBytes: llm.maxPromptBytes, env: llm.env };
+  if (llm.command) {
+    return { command: [...llm.command, ...llm.args], promptVia: llm.promptVia ?? "stdin", preset: null, ...common };
+  }
+  const presets = allPresets(config);
+  const preset = presets[llm.preset];
+  if (!preset) {
+    const names = Object.keys(presets).sort().join(", ");
+    throw new ConfigError(`Unknown LLM preset "${llm.preset}"`, `Available presets: ${names}. Define your own under llm.presets, or set llm.command.`);
+  }
+  return {
+    command: [...preset.command, ...llm.args],
+    promptVia: llm.promptVia ?? preset.promptVia ?? "stdin",
+    preset: llm.preset,
+    ...common
+  };
+}
+function shellSplit(input) {
+  const out = [];
+  let cur = "";
+  let inToken = false;
+  let quote = null;
+  for (let i = 0; i < input.length; i++) {
+    const ch = input[i];
+    if (quote === "'") {
+      if (ch === "'") quote = null;
+      else cur += ch;
+      continue;
+    }
+    if (quote === '"') {
+      if (ch === '"') quote = null;
+      else if (ch === "\\" && i + 1 < input.length && '"\\$`'.includes(input[i + 1])) cur += input[++i];
+      else cur += ch;
+      continue;
+    }
+    if (ch === "'" || ch === '"') {
+      quote = ch;
+      inToken = true;
+    } else if (ch === "\\" && i + 1 < input.length) {
+      cur += input[++i];
+      inToken = true;
+    } else if (/\s/.test(ch)) {
+      if (inToken) {
+        out.push(cur);
+        cur = "";
+        inToken = false;
+      }
+    } else {
+      cur += ch;
+      inToken = true;
+    }
+  }
+  if (quote) throw new ConfigError(`Unterminated quote in command: ${input}`);
+  if (inToken) out.push(cur);
+  return out;
+}
+
+// src/core/cache.ts
+import { createHash } from "crypto";
+import { mkdir, readdir, readFile as readFile2, rename, rm, writeFile } from "fs/promises";
+import { join as join2 } from "path";
+var TourCache = class {
+  constructor(dir) {
+    this.dir = dir;
+    this.toursDir = join2(dir, "tours");
+  }
+  dir;
+  toursDir;
+  static keyFor(prompt, command) {
+    return createHash("sha256").update(createHash("sha256").update(prompt).digest("hex")).update("\0").update(JSON.stringify(command)).digest("hex");
+  }
+  pathFor(key) {
+    return join2(this.toursDir, `${key}.json`);
+  }
+  async get(key) {
+    let text;
+    try {
+      text = await readFile2(this.pathFor(key), "utf8");
+    } catch (err) {
+      if (err.code === "ENOENT") return null;
+      throw err;
+    }
+    try {
+      const parsed = TourSchema.safeParse(JSON.parse(text));
+      return parsed.success ? parsed.data : null;
+    } catch {
+      return null;
+    }
+  }
+  async put(key, tour) {
+    await mkdir(this.toursDir, { recursive: true });
+    const final = this.pathFor(key);
+    const tmp = `${final}.${process.pid}.${Date.now()}.tmp`;
+    await writeFile(tmp, JSON.stringify(tour, null, 2) + "\n", "utf8");
+    await rename(tmp, final);
+    return final;
+  }
+  async list() {
+    let names;
+    try {
+      names = await readdir(this.toursDir);
+    } catch (err) {
+      if (err.code === "ENOENT") return [];
+      throw err;
+    }
+    const entries = [];
+    for (const name of names) {
+      if (!name.endsWith(".json")) continue;
+      const key = name.slice(0, -".json".length);
+      const tour = await this.get(key);
+      if (tour) entries.push({ key, path: this.pathFor(key), tour });
+    }
+    entries.sort((a, b) => b.tour.generatedAt.localeCompare(a.tour.generatedAt));
+    return entries;
+  }
+  async clear() {
+    const entries = await this.list();
+    await rm(this.toursDir, { recursive: true, force: true });
+    return entries.length;
+  }
+};
+
+// src/core/json.ts
+function extractJson(text) {
+  const trimmed = text.trim();
+  if (!trimmed) throw new BadLlmOutputError("The model returned empty output.", text);
+  const candidates = [trimmed];
+  for (const m of trimmed.matchAll(/```(?:json|JSON)?\s*\n?([\s\S]*?)```/g)) candidates.push(m[1].trim());
+  const balanced = firstBalancedObject(trimmed);
+  if (balanced) candidates.push(balanced);
+  const first = trimmed.indexOf("{");
+  const last = trimmed.lastIndexOf("}");
+  if (first !== -1 && last > first) candidates.push(trimmed.slice(first, last + 1));
+  for (const c of candidates) {
+    const parsed = tryParse(c) ?? tryParse(repairUnescapedQuotes(c));
+    if (parsed === void 0) continue;
+    return unwrapEnvelope(parsed);
+  }
+  throw new BadLlmOutputError("Could not find a JSON object in the model output.", text, "Run with --debug to see the raw output.");
+}
+function repairUnescapedQuotes(s) {
+  let out = "";
+  let inString = false;
+  for (let i = 0; i < s.length; i++) {
+    const ch = s[i];
+    if (!inString) {
+      if (ch === '"') inString = true;
+      out += ch;
+      continue;
+    }
+    if (ch === "\\") {
+      out += ch + (s[i + 1] ?? "");
+      i++;
+      continue;
+    }
+    if (ch === '"') {
+      let j = i + 1;
+      while (j < s.length && (s[j] === " " || s[j] === "	" || s[j] === "\r" || s[j] === "\n")) j++;
+      const next = s[j];
+      if (next === void 0 || next === "," || next === "}" || next === "]" || next === ":") {
+        inString = false;
+        out += ch;
+      } else {
+        out += '\\"';
+      }
+      continue;
+    }
+    out += ch;
+  }
+  return out;
+}
+function tryParse(s) {
+  try {
+    return JSON.parse(s);
+  } catch {
+    return void 0;
+  }
+}
+function unwrapEnvelope(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return value;
+  const obj = value;
+  if ("sections" in obj) return obj;
+  for (const key of ["result", "response", "content", "text", "output"]) {
+    const inner = obj[key];
+    if (typeof inner === "string" && inner.includes("{")) {
+      try {
+        return extractJson(inner);
+      } catch {
+      }
+    }
+    if (typeof inner === "object" && inner !== null) return unwrapEnvelope(inner);
+  }
+  return obj;
+}
+function firstBalancedObject(s) {
+  const start = s.indexOf("{");
+  if (start === -1) return null;
+  let depth = 0;
+  let inString = false;
+  for (let i = start; i < s.length; i++) {
+    const ch = s[i];
+    if (inString) {
+      if (ch === "\\") i++;
+      else if (ch === '"') inString = false;
+      continue;
+    }
+    if (ch === '"') inString = true;
+    else if (ch === "{") depth++;
+    else if (ch === "}") {
+      depth--;
+      if (depth === 0) return s.slice(start, i + 1);
+    }
+  }
+  return null;
+}
+
+// src/git/parse.ts
+var HUNK_RE = /^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@ ?(.*)$/;
+function unquote(path) {
+  if (!path.startsWith('"') || !path.endsWith('"')) return path;
+  const inner = path.slice(1, -1);
+  return inner.replace(/\\([abfnrtv\\"]|[0-7]{3})/g, (_, esc) => {
+    switch (esc) {
+      case "a":
+        return "\x07";
+      case "b":
+        return "\b";
+      case "f":
+        return "\f";
+      case "n":
+        return "\n";
+      case "r":
+        return "\r";
+      case "t":
+        return "	";
+      case "v":
+        return "\v";
+      case "\\":
+        return "\\";
+      case '"':
+        return '"';
+      default:
+        return String.fromCharCode(parseInt(esc, 8));
+    }
+  });
+}
+function stripPrefix(path, prefix) {
+  const p = unquote(path);
+  return p.startsWith(prefix) ? p.slice(2) : p;
+}
+function splitGitHeader(rest) {
+  if (rest.startsWith('"')) {
+    const m = /^("(?:[^"\\]|\\.)*") ("(?:[^"\\]|\\.)*")$/.exec(rest);
+    if (m) return { oldPath: stripPrefix(m[1], "a/"), newPath: stripPrefix(m[2], "b/") };
+  }
+  let idx = rest.indexOf(" b/");
+  while (idx !== -1) {
+    const left = rest.slice(0, idx);
+    const right = rest.slice(idx + 1);
+    if (left.startsWith("a/") && right.startsWith("b/") && left.slice(2) === right.slice(2)) {
+      return { oldPath: left.slice(2), newPath: right.slice(2) };
+    }
+    idx = rest.indexOf(" b/", idx + 1);
+  }
+  const first = rest.indexOf(" b/");
+  if (first === -1) return { oldPath: rest, newPath: rest };
+  return { oldPath: stripPrefix(rest.slice(0, first), "a/"), newPath: stripPrefix(rest.slice(first + 1), "b/") };
+}
+function parseDiff(raw) {
+  const lines = raw.split("\n");
+  const files = [];
+  let pending = null;
+  let hunk = null;
+  let oldNo = 0;
+  let newNo = 0;
+  const flush = () => {
+    if (!pending) return;
+    const id = `F${files.length + 1}`;
+    let additions = 0;
+    let deletions = 0;
+    pending.hunks.forEach((h, i) => {
+      h.id = `${id}.H${i + 1}`;
+      for (const l of h.lines) {
+        if (l.type === "add") additions++;
+        else if (l.type === "del") deletions++;
+      }
+    });
+    const status = pending.status;
+    const path = status === "deleted" ? pending.oldPath : pending.newPath;
+    const file = {
+      id,
+      path,
+      status,
+      binary: pending.binary,
+      additions,
+      deletions,
+      hunks: pending.hunks
+    };
+    if (status === "renamed") file.oldPath = pending.oldPath;
+    files.push(file);
+    pending = null;
+    hunk = null;
+  };
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (line.startsWith("diff --git ")) {
+      flush();
+      const { oldPath, newPath } = splitGitHeader(line.slice("diff --git ".length));
+      pending = { oldPath, newPath, status: "modified", binary: false, hunks: [] };
+      continue;
+    }
+    if (!pending) continue;
+    if (hunk) {
+      const c = line[0];
+      if (c === " " || c === "+" || c === "-" || line === "" && i < lines.length - 1 && hunkHasRoom(hunk)) {
+        const text = line.slice(1);
+        const entry = c === "+" ? { type: "add", newNo: newNo++, text } : c === "-" ? { type: "del", oldNo: oldNo++, text } : { type: "ctx", oldNo: oldNo++, newNo: newNo++, text: c === void 0 ? "" : text };
+        hunk.lines.push(entry);
+        continue;
+      }
+      if (line.startsWith("\\")) continue;
+      hunk = null;
+    }
+    const hm = HUNK_RE.exec(line);
+    if (hm) {
+      hunk = {
+        id: "",
+        oldStart: Number(hm[1]),
+        oldLines: hm[2] === void 0 ? 1 : Number(hm[2]),
+        newStart: Number(hm[3]),
+        newLines: hm[4] === void 0 ? 1 : Number(hm[4]),
+        header: (hm[5] ?? "").trim(),
+        lines: []
+      };
+      oldNo = hunk.oldStart;
+      newNo = hunk.newStart;
+      pending.hunks.push(hunk);
+      continue;
+    }
+    if (line.startsWith("--- ")) {
+      const p = line.slice(4);
+      if (p === "/dev/null") pending.status = "added";
+      else pending.oldPath = stripPrefix(p, "a/");
+      continue;
+    }
+    if (line.startsWith("+++ ")) {
+      const p = line.slice(4);
+      if (p === "/dev/null") pending.status = "deleted";
+      else pending.newPath = stripPrefix(p, "b/");
+      continue;
+    }
+    if (line.startsWith("rename from ")) {
+      pending.oldPath = unquote(line.slice("rename from ".length));
+      pending.status = "renamed";
+      continue;
+    }
+    if (line.startsWith("rename to ")) {
+      pending.newPath = unquote(line.slice("rename to ".length));
+      pending.status = "renamed";
+      continue;
+    }
+    if (line.startsWith("new file mode")) {
+      pending.status = "added";
+      continue;
+    }
+    if (line.startsWith("deleted file mode")) {
+      pending.status = "deleted";
+      continue;
+    }
+    if (line.startsWith("Binary files ") || line.startsWith("GIT binary patch")) {
+      pending.binary = true;
+      continue;
+    }
+  }
+  flush();
+  return { files };
+}
+function hunkHasRoom(h) {
+  let o = 0;
+  let n = 0;
+  for (const l of h.lines) {
+    if (l.type !== "add") o++;
+    if (l.type !== "del") n++;
+  }
+  return o < h.oldLines || n < h.newLines;
+}
+function diffStats(diff) {
+  return diff.files.reduce(
+    (acc, f) => ({ files: acc.files + 1, additions: acc.additions + f.additions, deletions: acc.deletions + f.deletions }),
+    { files: 0, additions: 0, deletions: 0 }
+  );
+}
+
+// src/core/materialize.ts
+var OTHER_CHANGES_TITLE = "Other changes";
+function materializeTour(input) {
+  const warn = input.warn ?? (() => {
+  });
+  const byPath = /* @__PURE__ */ new Map();
+  const byOldPath = /* @__PURE__ */ new Map();
+  const hunks = /* @__PURE__ */ new Map();
+  for (const f of input.diff.files) {
+    byPath.set(f.path, f);
+    if (f.oldPath) byOldPath.set(f.oldPath, f);
+    for (const h of f.hunks) hunks.set(h.id, { file: f, hunk: h });
+  }
+  const lookupFile = (p) => byPath.get(p) ?? byPath.get(p.replace(/^\.\//, "")) ?? byOldPath.get(p);
+  const claimed = /* @__PURE__ */ new Set();
+  const sections = [];
+  for (const s of input.output.sections) {
+    const files = /* @__PURE__ */ new Set();
+    for (const p of s.files ?? []) {
+      const f = lookupFile(p);
+      if (f) files.add(f.path);
+      else warn(`Section "${s.title}" references unknown file ${p}; ignoring`);
+    }
+    const excerpts = [];
+    for (const ref of s.excerpts ?? []) {
+      const hit = hunks.get(ref.hunk.trim());
+      if (!hit) {
+        warn(`Section "${s.title}" references unknown hunk ${ref.hunk}; ignoring`);
+        continue;
+      }
+      files.add(hit.file.path);
+      const lines = sliceHunk(hit.hunk, ref.lines, input.maxExcerptLines);
+      const excerpt = {
+        file: hit.file.path,
+        hunkId: hit.hunk.id,
+        oldStart: lines[0]?.oldNo ?? firstOld(lines) ?? hit.hunk.oldStart,
+        newStart: lines[0]?.newNo ?? firstNew(lines) ?? hit.hunk.newStart,
+        lines
+      };
+      if (ref.note?.trim()) excerpt.note = ref.note.trim();
+      excerpts.push(excerpt);
+    }
+    const fileList = [...files];
+    for (const p of fileList) claimed.add(p);
+    sections.push({
+      id: `s${sections.length + 1}`,
+      title: s.title.trim(),
+      description: s.description.trim(),
+      files: fileList,
+      stats: statsFor(fileList, byPath),
+      excerpts
+    });
+  }
+  const unclaimed = input.diff.files.map((f) => f.path).filter((p) => !claimed.has(p));
+  if (unclaimed.length) {
+    sections.push({
+      id: `s${sections.length + 1}`,
+      title: OTHER_CHANGES_TITLE,
+      description: "Files in this change that the sections above do not cover.",
+      files: unclaimed,
+      stats: statsFor(unclaimed, byPath),
+      excerpts: []
+    });
+  }
+  const tour = {
+    version: 1,
+    generatedAt: (input.now?.() ?? /* @__PURE__ */ new Date()).toISOString(),
+    source: input.source,
+    generator: input.generator,
+    title: input.output.title.trim(),
+    summary: input.output.summary.trim(),
+    stats: diffStats(input.diff),
+    sections
+  };
+  if (input.pullRequest) {
+    tour.pullRequest = { number: input.pullRequest.number, title: input.pullRequest.title, url: input.pullRequest.url };
+  }
+  return tour;
+}
+function statsFor(paths, byPath) {
+  let additions = 0;
+  let deletions = 0;
+  for (const p of paths) {
+    const f = byPath.get(p);
+    if (!f) continue;
+    additions += f.additions;
+    deletions += f.deletions;
+  }
+  return { files: paths.length, additions, deletions };
+}
+function firstOld(lines) {
+  return lines.find((l) => l.oldNo !== void 0)?.oldNo;
+}
+function firstNew(lines) {
+  return lines.find((l) => l.newNo !== void 0)?.newNo;
+}
+function sliceHunk(hunk, range, maxLines) {
+  let lines = hunk.lines;
+  if (range) {
+    const [a, b] = range;
+    const start = Math.min(a, b);
+    const end = Math.max(a, b);
+    let cursor = hunk.newStart;
+    const picked = [];
+    for (const l of lines) {
+      const pos = l.type === "del" ? cursor : l.newNo ?? cursor;
+      if (l.type !== "del") cursor = (l.newNo ?? cursor) + 1;
+      if (pos >= start && pos <= end) picked.push(l);
+    }
+    if (picked.length > 0) lines = picked;
+  }
+  return lines.slice(0, maxLines);
+}
+
+// src/core/prompt/template.ts
+var PROMPT_VERSION = 2;
+var PROMPT_HEADER = `You are writing a guided code tour of a change for a reviewer who has not seen it before.
+
+A code tour is an ordered list of sections. Each section explains one coherent part of the change: what it does, why it is there, and how it connects to the rest. Sections are ordered the way a reader should encounter them: start with the change that makes everything else make sense (a new type, an interface, a data model, a configuration knob), then the code that builds on it, then wiring and plumbing, then tests and housekeeping.
+
+## Rules
+
+- Produce between 2 and 8 sections. Fewer is better when the change is small; never pad.
+- Group by concept, not by file. A section may span many files, and a file may appear in several sections.
+- Every file in the change must be claimed by at least one section. Put unrelated housekeeping (formatting, generated code, renames, dependency bumps) in one short final section rather than sprinkling it around.
+- A section's description is 2 to 5 sentences of plain prose written for a colleague. Lead with the purpose (why), then what changed, then anything a reviewer should look at carefully: behavior changes, edge cases, risk. Do not narrate line by line and do not restate the diff.
+- Choose 1 to 3 excerpts per section: the hunks that best show the idea. Reference hunks by their id exactly as given (for example "F2.H1"). Optionally narrow a hunk with "lines": [start, end] using NEW-file line numbers as they appear in the diff. Never quote code in the JSON; the real diff is rendered from your references.
+- Give each excerpt a short "note" (under 15 words) saying what to look at.
+- The tour "title" is a short imperative phrase naming the change, like a good commit subject. The "summary" is 2 to 4 sentences describing the whole change and its motivation.
+- Use the pull request description and commit messages as evidence of intent, but trust the diff over them when they disagree.
+- If parts of the diff were truncated or omitted, still assign those files to sections based on their names and stats, and only reference hunks that were shown.
+- The JSON must be strictly valid. Inside a string, escape double quotes as \\" or use single quotes when mentioning flags, code, or file names.
+
+## Output
+
+Respond with ONLY a JSON object: no prose before or after it, and no code fences.
+
+{
+  "title": "Short imperative title",
+  "summary": "What this change does and why.",
+  "sections": [
+    {
+      "title": "Section title",
+      "description": "Why, then what, then what to watch.",
+      "files": ["path/one.ts", "path/two.ts"],
+      "excerpts": [
+        { "hunk": "F1.H2", "note": "The new interface every provider implements" },
+        { "hunk": "F3.H1", "lines": [40, 58], "note": "Where the fallback kicks in" }
+      ]
+    }
+  ]
+}
+`;
+var REPAIR_SUFFIX = (reason) => `
+
+---
+
+Your previous response could not be used: ${reason}
+
+Respond again with ONLY the JSON object described above. No prose, no code fences, no comments.`;
+
+// src/core/prompt/build.ts
+var KEEP_LINES = 40;
+var MAX_PR_BODY_BYTES = 12e3;
+function buildPrompt(input) {
+  const context = renderContext(input);
+  const truncation = { truncated: [], omitted: [] };
+  const blocks = input.diff.files.map((file) => {
+    const full = renderFile(file);
+    const truncated = file.hunks.length ? renderTruncated(file) : null;
+    return {
+      file,
+      full,
+      // Only worth truncating when it actually saves space.
+      truncated: truncated && bytes(truncated) < bytes(full) ? truncated : null,
+      omitted: renderOmitted(file),
+      mode: "full"
+    };
+  });
+  const text = (b) => b.mode === "full" ? b.full : b.mode === "truncated" ? b.truncated : b.omitted;
+  const total = () => bytes(diffPreamble(truncation)) + blocks.reduce((n, b) => n + bytes(text(b)), 0);
+  const budget = input.maxBytes - bytes(PROMPT_HEADER) - bytes(context) - 8;
+  if (total() > budget) {
+    const bySize = [...blocks].sort((a, b) => bytes(b.full) - bytes(a.full));
+    for (const block of bySize) {
+      if (total() <= budget) break;
+      if (!block.truncated) continue;
+      block.mode = "truncated";
+      truncation.truncated.push(block.file.path);
+    }
+    for (const block of bySize) {
+      if (total() <= budget) break;
+      if (block.file.hunks.length === 0) continue;
+      if (block.mode === "truncated") truncation.truncated = truncation.truncated.filter((p) => p !== block.file.path);
+      block.mode = "omitted";
+      truncation.omitted.push(block.file.path);
+    }
+  }
+  const prompt = [PROMPT_HEADER, context, diffPreamble(truncation), ...blocks.map(text)].join("\n");
+  return { prompt, truncation };
+}
+function bytes(s) {
+  return Buffer.byteLength(s, "utf8");
+}
+function renderContext(input) {
+  const parts = ["# The change", ""];
+  parts.push("## Source");
+  parts.push(describeSource(input.source, input.branch));
+  parts.push("");
+  if (input.pullRequest) {
+    const pr = input.pullRequest;
+    parts.push(`## Pull request #${pr.number}: ${pr.title.trim() || "(untitled)"}`);
+    const body = pr.body.trim();
+    parts.push(body ? clip(body, MAX_PR_BODY_BYTES) : "(no description)");
+    parts.push("");
+  }
+  if (input.commits.length) {
+    parts.push("## Commits (oldest first)");
+    for (const c of [...input.commits].reverse()) parts.push(`- ${c.subject}`);
+    parts.push("");
+  }
+  const stats = diffStats(input.diff);
+  parts.push(`## Files (${stats.files} ${stats.files === 1 ? "file" : "files"}, +${stats.additions} -${stats.deletions})`);
+  const idWidth = Math.max(...input.diff.files.map((f) => f.id.length), 2);
+  for (const f of input.diff.files) {
+    const status = f.binary ? "binary" : f.status;
+    const name = f.status === "renamed" && f.oldPath ? `${f.oldPath} -> ${f.path}` : f.path;
+    const counts = f.binary ? "" : `  +${f.additions} -${f.deletions}`;
+    parts.push(`${f.id.padEnd(idWidth)}  ${status.padEnd(8)}  ${name}${counts}`);
+  }
+  parts.push("");
+  return parts.join("\n");
+}
+function describeSource(source, branch) {
+  if (source.kind === "working") {
+    const what = source.staged ? "Staged (uncommitted) changes" : "Uncommitted changes in the working tree";
+    return branch ? `${what} on branch ${branch}.` : `${what} (detached HEAD).`;
+  }
+  const mb = source.mergeBase ? ` (at merge-base ${source.mergeBase.slice(0, 7)})` : "";
+  return `${source.head} compared against ${source.base}${mb}.`;
+}
+function diffPreamble(t) {
+  const lines = ["## Diff", ""];
+  if (t.truncated.length || t.omitted.length) {
+    lines.push("Note: to fit the size budget, some diffs below were shortened.");
+    if (t.truncated.length) lines.push(`- Truncated (only the shown hunk may be referenced): ${t.truncated.join(", ")}`);
+    if (t.omitted.length) lines.push(`- Omitted entirely (assign by name and stats): ${t.omitted.join(", ")}`);
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+function fileHeading(file) {
+  const status = file.binary ? "binary" : file.status;
+  const rename2 = file.status === "renamed" && file.oldPath ? `, from ${file.oldPath}` : "";
+  const counts = file.binary ? "" : `, +${file.additions} -${file.deletions}`;
+  return `### ${file.id} ${file.path} (${status}${rename2}${counts})`;
+}
+function renderHunk(hunk, limit) {
+  const out = [`[${hunk.id}] @@ -${hunk.oldStart},${hunk.oldLines} +${hunk.newStart},${hunk.newLines} @@${hunk.header ? " " + hunk.header : ""}`];
+  const lines = limit === void 0 ? hunk.lines : hunk.lines.slice(0, limit);
+  for (const l of lines) out.push((l.type === "add" ? "+" : l.type === "del" ? "-" : " ") + l.text);
+  return out;
+}
+function renderFile(file) {
+  const out = [fileHeading(file)];
+  if (file.binary) out.push("(binary file, no textual diff)");
+  else if (file.hunks.length === 0) out.push("(no content changes)");
+  else for (const h of file.hunks) out.push(...renderHunk(h));
+  out.push("");
+  return out.join("\n");
+}
+function renderTruncated(file) {
+  const first = file.hunks[0];
+  const shown = Math.min(KEEP_LINES, first.lines.length);
+  const totalLines = file.hunks.reduce((n, h) => n + h.lines.length, 0);
+  const out = [fileHeading(file), ...renderHunk(first, shown)];
+  out.push(`... [truncated: ${totalLines - shown} more lines across ${file.hunks.length} hunk${file.hunks.length === 1 ? "" : "s"}]`);
+  out.push("");
+  return out.join("\n");
+}
+function renderOmitted(file) {
+  return [fileHeading(file), "(diff omitted for length)", ""].join("\n");
+}
+function clip(text, maxBytes) {
+  if (bytes(text) <= maxBytes) return text;
+  let cut = text.slice(0, maxBytes);
+  while (bytes(cut) > maxBytes) cut = cut.slice(0, -100);
+  return cut + "\n... [description truncated]";
+}
+
+// src/codehost/gh.ts
+import { execFile } from "child_process";
+var FIELDS = "number,title,body,url,baseRefName,headRefName,state";
+var GhCodeHost = class {
+  name = "gh";
+  timeoutMs;
+  debug;
+  constructor(opts = {}) {
+    this.timeoutMs = opts.timeoutMs ?? 15e3;
+    this.debug = opts.debug ?? (() => {
+    });
+  }
+  currentPullRequest(cwd) {
+    return new Promise((resolve) => {
+      execFile(
+        "gh",
+        ["pr", "view", "--json", FIELDS],
+        { cwd, timeout: this.timeoutMs, encoding: "utf8", maxBuffer: 8 * 1024 * 1024 },
+        (err, stdout, stderr) => {
+          if (err) {
+            const code = err.code;
+            this.debug(
+              code === "ENOENT" ? "gh is not installed; skipping pull request lookup" : `gh pr view failed: ${(stderr || err.message).trim()}`
+            );
+            resolve(null);
+            return;
+          }
+          try {
+            const j = JSON.parse(stdout);
+            resolve({
+              number: Number(j.number),
+              title: String(j.title ?? ""),
+              body: String(j.body ?? ""),
+              url: String(j.url ?? ""),
+              baseRefName: String(j.baseRefName ?? ""),
+              headRefName: String(j.headRefName ?? "")
+            });
+          } catch (parseErr) {
+            this.debug(`gh returned unparseable JSON: ${parseErr.message}`);
+            resolve(null);
+          }
+        }
+      );
+    });
+  }
+};
+
+// src/codehost/none.ts
+var NoCodeHost = class {
+  name = "none";
+  async currentPullRequest() {
+    return null;
+  }
+};
+
+// src/codehost/index.ts
+function createCodeHost(config, opts = {}) {
+  switch (config.codehost.provider) {
+    case "gh":
+      return new GhCodeHost({ debug: opts.debug });
+    case "none":
+      return new NoCodeHost();
+  }
+}
+
+// src/git/exec.ts
+import { execFile as execFile2 } from "child_process";
+var MAX_BUFFER = 512 * 1024 * 1024;
+function git(args, opts) {
+  return new Promise((resolve, reject) => {
+    execFile2("git", args, { cwd: opts.cwd, maxBuffer: MAX_BUFFER, encoding: "utf8" }, (err, stdout, stderr) => {
+      const e = err;
+      if (e && e.code === "ENOENT") {
+        reject(new GitError("git executable not found", { hint: "Install git and make sure it is on your PATH." }));
+        return;
+      }
+      const code = e ? typeof e.code === "number" ? e.code : 1 : 0;
+      if (code !== 0 && !opts.allowFailure) {
+        const detail = stderr.trim() || stdout.trim() || `exit code ${code}`;
+        reject(new GitError(`git ${args.slice(0, 2).join(" ")} failed: ${detail}`));
+        return;
+      }
+      resolve({ stdout, stderr, code });
+    });
+  });
+}
+async function gitRoot(cwd) {
+  const res = await git(["rev-parse", "--show-toplevel"], { cwd, allowFailure: true });
+  if (res.code !== 0) throw new NotARepoError(cwd);
+  return res.stdout.trim();
+}
+async function revParse(ref, cwd) {
+  const res = await git(["rev-parse", "--verify", "--quiet", `${ref}^{commit}`], { cwd, allowFailure: true });
+  return res.code === 0 ? res.stdout.trim() : null;
+}
+async function currentBranch(cwd) {
+  const res = await git(["symbolic-ref", "--short", "--quiet", "HEAD"], { cwd, allowFailure: true });
+  return res.code === 0 ? res.stdout.trim() : null;
+}
+async function mergeBase(a, b, cwd) {
+  const res = await git(["merge-base", a, b], { cwd, allowFailure: true });
+  return res.code === 0 ? res.stdout.trim() : null;
+}
+async function localBranches(cwd) {
+  const res = await git(["for-each-ref", "--format=%(refname:short)", "refs/heads/"], { cwd });
+  return res.stdout.split("\n").map((s) => s.trim()).filter(Boolean);
+}
+function excludePathspecs(exclude) {
+  return exclude.map((glob) => `:(exclude,glob)${glob}`);
+}
+async function isDirty(cwd, exclude) {
+  const res = await git(["status", "--porcelain", "--untracked-files=all", "--", ".", ...excludePathspecs(exclude)], { cwd });
+  return res.stdout.trim().length > 0;
+}
+
+// src/git/diff.ts
+import { stat } from "fs/promises";
+import { join as join3 } from "path";
+var DIFF_BASE_ARGS = ["diff", "--no-color", "--no-ext-diff", "--src-prefix=a/", "--dst-prefix=b/", "-M", "-U3"];
+var MAX_UNTRACKED_BYTES = 2 * 1024 * 1024;
+async function collectDiff(source, opts) {
+  const pathspec = ["--", ".", ...excludePathspecs(opts.exclude)];
+  let raw;
+  if (source.kind === "range") {
+    raw = (await git([...DIFF_BASE_ARGS, source.baseSha, source.headSha, ...pathspec], { cwd: opts.cwd })).stdout;
+  } else if (source.staged) {
+    raw = (await git([...DIFF_BASE_ARGS, "--cached", ...pathspec], { cwd: opts.cwd })).stdout;
+  } else {
+    raw = (await git([...DIFF_BASE_ARGS, "HEAD", ...pathspec], { cwd: opts.cwd })).stdout;
+    raw += await untrackedDiff(opts, pathspec);
+  }
+  return parseDiff(raw);
+}
+async function untrackedDiff(opts, pathspec) {
+  const list = await git(["ls-files", "--others", "--exclude-standard", "-z", ...pathspec], { cwd: opts.cwd });
+  const paths = list.stdout.split("\0").filter(Boolean);
+  let out = "";
+  for (const rel of paths) {
+    const abs = join3(opts.cwd, rel);
+    try {
+      const s = await stat(abs);
+      if (!s.isFile()) continue;
+      if (s.size > MAX_UNTRACKED_BYTES) {
+        opts.warn?.(`Skipping large untracked file ${rel} (${Math.round(s.size / 1024)} KB)`);
+        continue;
+      }
+    } catch {
+      continue;
+    }
+    const res = await git(
+      [...DIFF_BASE_ARGS, "--no-index", "--", "/dev/null", rel],
+      { cwd: opts.cwd, allowFailure: true }
+    );
+    if (res.code > 1) {
+      opts.warn?.(`Could not diff untracked file ${rel}: ${res.stderr.trim()}`);
+      continue;
+    }
+    out += res.stdout;
+  }
+  return out;
+}
+async function collectCommits(source, cwd, limit = 50) {
+  if (source.kind !== "range") return [];
+  const res = await git(
+    ["log", "--no-merges", `--max-count=${limit}`, "--format=%h%x09%s", `${source.baseSha}..${source.headSha}`],
+    { cwd, allowFailure: true }
+  );
+  if (res.code !== 0) return [];
+  return res.stdout.split("\n").filter(Boolean).map((line) => {
+    const tab = line.indexOf("	");
+    return { sha: line.slice(0, tab), subject: line.slice(tab + 1) };
+  });
+}
+
+// src/git/range.ts
+var MAX_ANCESTOR_CANDIDATES = 100;
+async function resolveRange(req, opts) {
+  const debug = opts.debug ?? (() => {
+  });
+  const { cwd } = opts;
+  const branch = await currentBranch(cwd);
+  const headSha = await revParse("HEAD", cwd);
+  if (!headSha) {
+    throw new NoChangesError("This repository has no commits yet.", "Make an initial commit first.");
+  }
+  debug(`repository ${cwd} on ${branch ?? "detached HEAD"} at ${headSha.slice(0, 12)}`);
+  if (req.working && req.staged) throw new UsageError("--working and --staged are mutually exclusive.");
+  if ((req.working || req.staged) && req.arg) throw new UsageError(`A range argument cannot be combined with --${req.working ? "working" : "staged"}.`);
+  if (req.staged) return { source: { kind: "working", headSha, staged: true, resolvedBy: "explicit" }, branch };
+  if (req.working) return { source: { kind: "working", headSha, staged: false, resolvedBy: "explicit" }, branch };
+  if (req.arg) {
+    return { source: await explicitRange(req.arg, headSha, cwd), branch };
+  }
+  if (await isDirty(cwd, opts.exclude)) {
+    debug("working tree is dirty; touring uncommitted changes");
+    return { source: { kind: "working", headSha, staged: false, resolvedBy: "dirty-tree" }, branch };
+  }
+  const defaultBranch = await detectDefaultBranch(opts.defaultBranch, cwd);
+  debug(`default branch: ${defaultBranch ?? "(none)"}`);
+  const pr = await opts.codehost.currentPullRequest(cwd);
+  if (pr?.baseRefName) {
+    const baseRef = await firstExistingRef([`origin/${pr.baseRefName}`, pr.baseRefName], cwd);
+    if (baseRef) {
+      debug(`pull request #${pr.number} targets ${pr.baseRefName}; using ${baseRef}`);
+      const source = await rangeAtMergeBase(baseRef, headSha, branch ?? "HEAD", "pull-request", cwd);
+      return { source, branch, pullRequest: pr };
+    }
+    debug(`pull request #${pr.number} targets ${pr.baseRefName}, but that ref is not available locally`);
+  }
+  const onDefault = defaultBranch !== null && branch !== null && stripRemote(defaultBranch) === branch;
+  if (!onDefault) {
+    const nearest = await nearestAncestorBranch(branch, headSha, defaultBranch, cwd, debug);
+    if (nearest) {
+      debug(`nearest ancestor branch: ${nearest}`);
+      const source = await rangeAtMergeBase(nearest, headSha, branch ?? "HEAD", "ancestor-branch", cwd);
+      return { source, branch };
+    }
+  }
+  if (defaultBranch && !onDefault) {
+    const source = await rangeAtMergeBase(defaultBranch, headSha, branch ?? "HEAD", "default-branch", cwd);
+    return { source, branch };
+  }
+  throw new NoChangesError(
+    onDefault ? `You're on ${branch} in ${cwd} with a clean working tree; nothing to tour.` : "Could not infer what to compare against.",
+    "Pass a range explicitly, e.g. `bb HEAD~3`, `bb main..feature` or `bb --working`."
+  );
+}
+async function explicitRange(arg, headSha, cwd) {
+  const three = arg.indexOf("...");
+  const two = three === -1 ? arg.indexOf("..") : -1;
+  if (three !== -1) {
+    const base = arg.slice(0, three) || "HEAD";
+    const head = arg.slice(three + 3) || "HEAD";
+    const headResolved = await requireRef(head, cwd);
+    return rangeAtMergeBase(base, headResolved, head, "explicit", cwd);
+  }
+  if (two !== -1) {
+    const base = arg.slice(0, two) || "HEAD";
+    const head = arg.slice(two + 2) || "HEAD";
+    const baseSha = await requireRef(base, cwd);
+    const headResolved = await requireRef(head, cwd);
+    if (baseSha === headResolved) throw new NoChangesError(`${base} and ${head} point at the same commit.`);
+    return { kind: "range", base, head, baseSha, headSha: headResolved, resolvedBy: "explicit" };
+  }
+  return rangeAtMergeBase(arg, headSha, "HEAD", "explicit", cwd);
+}
+async function requireRef(ref, cwd) {
+  const sha = await revParse(ref, cwd);
+  if (!sha) throw new UsageError(`Unknown git ref: ${ref}`);
+  return sha;
+}
+async function rangeAtMergeBase(base, headSha, headLabel, resolvedBy, cwd) {
+  const baseTip = await requireRef(base, cwd);
+  const mb = await mergeBase(baseTip, headSha, cwd) ?? baseTip;
+  if (mb === headSha) {
+    throw new NoChangesError(
+      `${headLabel} has no commits on top of ${base}.`,
+      base === headLabel ? void 0 : `Did you mean \`bb ${base}..${headLabel}\`?`
+    );
+  }
+  const source = { kind: "range", base, head: headLabel, baseSha: mb, headSha, resolvedBy };
+  if (mb !== baseTip) source.mergeBase = mb;
+  return source;
+}
+async function firstExistingRef(candidates, cwd) {
+  for (const ref of candidates) {
+    if (await revParse(ref, cwd)) return ref;
+  }
+  return null;
+}
+function stripRemote(ref) {
+  return ref.startsWith("origin/") ? ref.slice("origin/".length) : ref;
+}
+async function detectDefaultBranch(configured, cwd) {
+  if (configured) return await revParse(configured, cwd) ? configured : null;
+  const sym = await git(["symbolic-ref", "--quiet", "--short", "refs/remotes/origin/HEAD"], { cwd, allowFailure: true });
+  if (sym.code === 0 && sym.stdout.trim()) return sym.stdout.trim();
+  return firstExistingRef(["main", "master", "trunk", "origin/main", "origin/master"], cwd);
+}
+async function nearestAncestorBranch(branch, headSha, defaultBranch, cwd, debug) {
+  const branches = (await localBranches(cwd)).filter((b) => b !== branch);
+  if (branches.length === 0) return null;
+  if (branches.length > MAX_ANCESTOR_CANDIDATES) {
+    debug(`skipping ancestor search: ${branches.length} local branches`);
+    return null;
+  }
+  let best = null;
+  for (const name of branches) {
+    const mb = await mergeBase(name, headSha, cwd);
+    if (!mb || mb === headSha) continue;
+    const count = await git(["rev-list", "--count", `${mb}..${headSha}`], { cwd, allowFailure: true });
+    const distance = count.code === 0 ? Number(count.stdout.trim()) : Number.POSITIVE_INFINITY;
+    const isDefault = defaultBranch !== null && stripRemote(defaultBranch) === name;
+    if (!best || distance < best.distance || distance === best.distance && isDefault) {
+      best = { name, distance };
+    }
+  }
+  return best?.name ?? null;
+}
+
+// src/llm/command.ts
+import { spawn } from "child_process";
+var STDERR_TAIL_LINES = 20;
+var CommandProvider = class {
+  constructor(opts) {
+    this.opts = opts;
+    if (opts.command.length === 0) throw new LlmFailedError("LLM command is empty.");
+  }
+  opts;
+  describe() {
+    return this.opts.command.map(shellQuote).join(" ");
+  }
+  complete(prompt) {
+    const { promptVia, timeoutMs } = this.opts;
+    const argv = promptVia === "arg" ? this.opts.command.map((a) => a.replaceAll("{prompt}", prompt)) : this.opts.command;
+    const [bin, ...args] = argv;
+    const debug = this.opts.debug ?? (() => {
+    });
+    const started = Date.now();
+    debug(`running ${this.describe()} (prompt ${Buffer.byteLength(prompt)} bytes via ${promptVia})`);
+    return new Promise((resolve, reject) => {
+      const env = { ...process.env, ...this.opts.env };
+      delete env.CLAUDECODE;
+      const child = spawn(bin, args, { cwd: this.opts.cwd, env, stdio: ["pipe", "pipe", "pipe"] });
+      const out = [];
+      const err = [];
+      let settled = false;
+      const finish = (fn) => {
+        if (settled) return;
+        settled = true;
+        clearTimeout(timer);
+        fn();
+      };
+      const timer = setTimeout(() => {
+        child.kill("SIGTERM");
+        finish(() => reject(new LlmFailedError(`LLM command timed out after ${Math.round(timeoutMs / 1e3)}s: ${this.describe()}`, {
+          hint: "Raise llm.timeoutMs in your config, or pick a faster preset."
+        })));
+      }, timeoutMs);
+      child.stdout.on("data", (b) => out.push(b));
+      child.stderr.on("data", (b) => err.push(b));
+      child.on("error", (e) => {
+        finish(() => {
+          if (e.code === "ENOENT") {
+            reject(new LlmFailedError(`LLM command not found: ${bin}`, { hint: "Install it, or choose another preset with --preset / llm.preset.", cause: e }));
+          } else {
+            reject(new LlmFailedError(`Could not run ${this.describe()}: ${e.message}`, { cause: e }));
+          }
+        });
+      });
+      child.on("close", (code, signal) => {
+        finish(() => {
+          const stdout = Buffer.concat(out).toString("utf8");
+          const stderr = Buffer.concat(err).toString("utf8");
+          debug(`command exited with ${signal ? `signal ${signal}` : `code ${code}`} after ${Date.now() - started}ms; ${stdout.length} bytes of stdout`);
+          if (code !== 0) {
+            const tail = stderr.trim().split("\n").slice(-STDERR_TAIL_LINES).join("\n");
+            reject(new LlmFailedError(`LLM command failed (${signal ? `signal ${signal}` : `exit ${code}`}): ${this.describe()}${tail ? "\n" + tail : ""}`));
+            return;
+          }
+          resolve(stdout);
+        });
+      });
+      if (promptVia === "stdin") {
+        child.stdin.on("error", () => {
+        });
+        child.stdin.end(prompt);
+      } else {
+        child.stdin.end();
+      }
+    });
+  }
+};
+function shellQuote(arg) {
+  if (arg === "") return '""';
+  return /^[\w@%+=:,./-]+$/.test(arg) ? arg : `'${arg.replaceAll("'", `'\\''`)}'`;
+}
+
+// src/llm/index.ts
+function createProvider(llm, opts = {}) {
+  return new CommandProvider({
+    command: llm.command,
+    promptVia: llm.promptVia,
+    timeoutMs: llm.timeoutMs,
+    env: llm.env,
+    cwd: opts.cwd,
+    debug: opts.debug
+  });
+}
+
+// src/core/tour.ts
+async function prepareTour(opts) {
+  const debug = opts.debug ?? (() => {
+  });
+  const warn = opts.warn ?? (() => {
+  });
+  const { config } = opts;
+  const llm = resolveLlm(config);
+  const codehost = opts.codehost ?? createCodeHost(config, { debug });
+  const resolved = await resolveRange(opts.range ?? {}, {
+    cwd: opts.cwd,
+    exclude: config.git.exclude,
+    defaultBranch: config.git.defaultBranch,
+    codehost,
+    debug
+  });
+  debug(`source: ${JSON.stringify(resolved.source)}`);
+  const diff = await collectDiff(resolved.source, { cwd: opts.cwd, exclude: config.git.exclude, warn });
+  if (diff.files.length === 0) {
+    throw new NoChangesError("The selected range has no changes (after excludes).", "Check git.exclude in your config, or pass a different range.");
+  }
+  const commits = await collectCommits(resolved.source, opts.cwd);
+  const context = { source: resolved.source, branch: resolved.branch, diff, commits };
+  if (resolved.pullRequest) context.pullRequest = resolved.pullRequest;
+  const built = buildPrompt({ ...context, maxBytes: llm.maxPromptBytes });
+  if (built.truncation.truncated.length || built.truncation.omitted.length) {
+    warn(`Prompt exceeded ${llm.maxPromptBytes} bytes; truncated ${built.truncation.truncated.length} and omitted ${built.truncation.omitted.length} file diff(s).`);
+  }
+  const cacheKey = TourCache.keyFor(`v${PROMPT_VERSION}
+${built.prompt}`, llm.command);
+  debug(`prompt ${Buffer.byteLength(built.prompt)} bytes, cache key ${cacheKey.slice(0, 12)}`);
+  return { context, built, command: llm.command, preset: llm.preset, cacheKey };
+}
+async function generateTour(opts, prepared) {
+  const debug = opts.debug ?? (() => {
+  });
+  const warn = opts.warn ?? (() => {
+  });
+  const { config } = opts;
+  const prep = prepared ?? await prepareTour(opts);
+  const useCache = config.cache.enabled && !opts.noCache;
+  const cache = useCache ? new TourCache(opts.cacheDir) : null;
+  if (cache && !opts.refresh) {
+    const hit = await cache.get(prep.cacheKey);
+    if (hit) {
+      debug(`cache hit: ${cache.pathFor(prep.cacheKey)}`);
+      return { tour: hit, fromCache: true, cacheKey: prep.cacheKey, cachePath: cache.pathFor(prep.cacheKey), prompt: prep.built.prompt };
+    }
+    debug("cache miss");
+  }
+  const llm = resolveLlm(config);
+  const provider = opts.provider ?? createProvider(llm, { cwd: opts.cwd, debug });
+  const output = await completeWithRepair(provider, prep.built.prompt, debug);
+  const tour = materializeTour({
+    output,
+    diff: prep.context.diff,
+    source: prep.context.source,
+    generator: { preset: prep.preset, command: prep.command },
+    pullRequest: prep.context.pullRequest,
+    maxExcerptLines: config.render.maxExcerptLines,
+    warn
+  });
+  let cachePath = null;
+  if (cache) {
+    cachePath = await cache.put(prep.cacheKey, tour);
+    debug(`cached: ${cachePath}`);
+  }
+  return { tour, fromCache: false, cacheKey: cache ? prep.cacheKey : null, cachePath, prompt: prep.built.prompt };
+}
+async function completeWithRepair(provider, prompt, debug) {
+  let raw = await provider.complete(prompt);
+  debug(`raw model output (attempt 1):
+${raw}`);
+  const first = parseOutput(raw);
+  if (first.ok) return first.value;
+  debug(`attempt 1 unusable: ${first.reason}; retrying with repair prompt`);
+  raw = await provider.complete(prompt + REPAIR_SUFFIX(first.reason));
+  debug(`raw model output (attempt 2):
+${raw}`);
+  const second = parseOutput(raw);
+  if (second.ok) return second.value;
+  throw new BadLlmOutputError(`The model did not return a usable tour: ${second.reason}`, raw, "Run with --debug to see the raw output, or try another preset.");
+}
+function parseOutput(raw) {
+  let json;
+  try {
+    json = extractJson(raw);
+  } catch (err) {
+    return { ok: false, reason: err instanceof Error ? err.message : String(err) };
+  }
+  const parsed = LlmTourOutputSchema.safeParse(json);
+  if (!parsed.success) return { ok: false, reason: `JSON did not match the schema (${formatIssues(parsed.error)})` };
+  return { ok: true, value: parsed.data };
+}
+
+// src/render/cli.ts
+import pc from "picocolors";
+var MIN_WIDTH = 40;
+var MAX_WIDTH = 120;
+var CliRenderer = class {
+  render(tour, opts) {
+    const c = pc.createColors(opts.color);
+    const width = Math.max(MIN_WIDTH, Math.min(MAX_WIDTH, opts.width));
+    const out = [];
+    out.push(...renderHeader(tour, c, width, opts.fromCache ?? false));
+    out.push("");
+    if (opts.section !== void 0) {
+      const section = tour.sections[opts.section - 1];
+      if (!section) {
+        throw new UsageError(`No section ${opts.section}; this tour has ${tour.sections.length} section${tour.sections.length === 1 ? "" : "s"}.`);
+      }
+      out.push(...renderSection(section, opts.section, tour.sections.length, c, width));
+    } else {
+      out.push(...renderToc(tour, c, width));
+      out.push("");
+      tour.sections.forEach((s, i) => {
+        out.push(...renderSection(s, i + 1, tour.sections.length, c, width));
+        out.push("");
+      });
+    }
+    return out.join("\n").replace(/\n+$/, "") + "\n";
+  }
+};
+function renderHeader(tour, c, width, fromCache) {
+  const lines = [];
+  lines.push(c.bold(`\u{1F423} ${tour.title}`));
+  lines.push(c.dim(describeSource2(tour.source)));
+  if (tour.pullRequest) {
+    lines.push(c.dim(`PR #${tour.pullRequest.number}: ${tour.pullRequest.title}${tour.pullRequest.url ? "  " + tour.pullRequest.url : ""}`));
+  }
+  const parts = [statsLine(tour.stats, c), `${tour.sections.length} section${tour.sections.length === 1 ? "" : "s"}`];
+  const meta = [];
+  if (tour.generator.preset) meta.push(tour.generator.preset);
+  else if (tour.generator.command[0]) meta.push(tour.generator.command[0]);
+  meta.push(fromCache ? `cached ${relativeTime(tour.generatedAt)}` : "generated just now");
+  lines.push(`${parts.join(c.dim(" \xB7 "))}${c.dim(" \xB7 " + meta.join(", "))}`);
+  if (tour.summary) {
+    lines.push("");
+    lines.push(...wrap(tour.summary, width));
+  }
+  return lines;
+}
+function renderToc(tour, c, width) {
+  const lines = [c.bold("Contents")];
+  const numWidth = String(tour.sections.length).length;
+  for (const [i, s] of tour.sections.entries()) {
+    const n = String(i + 1).padStart(numWidth);
+    const label = `  ${n}. ${s.title}`;
+    const right = `${s.stats.files} file${s.stats.files === 1 ? "" : "s"} \xB7 ${statsLine(s.stats, c, true)}`;
+    const rightPlain = `${s.stats.files} file${s.stats.files === 1 ? "" : "s"} \xB7 +${s.stats.additions} -${s.stats.deletions}`;
+    const gap = Math.max(2, width - visibleLength(label) - rightPlain.length);
+    lines.push(label + " ".repeat(gap) + c.dim(right));
+  }
+  return lines;
+}
+function renderSection(s, index, count, c, width) {
+  const lines = [];
+  lines.push(c.dim("\u2500".repeat(width)));
+  lines.push(c.bold(`${index}. ${s.title}`) + c.dim(`   (${index}/${count})`));
+  lines.push(`   ${c.dim(`${s.stats.files} file${s.stats.files === 1 ? "" : "s"} \xB7 `)}${statsLine(s.stats, c, true)}`);
+  if (s.description) {
+    lines.push("");
+    lines.push(...wrap(s.description, width - 3).map((l) => l ? "   " + l : ""));
+  }
+  if (s.files.length) {
+    lines.push("");
+    for (const f of s.files) lines.push(`   ${c.cyan(f)}`);
+  }
+  for (const e of s.excerpts) {
+    lines.push("");
+    lines.push(...renderExcerpt(e, c, width));
+  }
+  return lines;
+}
+function renderExcerpt(e, c, width) {
+  const lines = [];
+  const title = `   ${c.cyan(e.file)}${c.dim(":" + e.newStart)}`;
+  lines.push(e.note ? `${title}  ${c.italic(c.dim(e.note))}` : title);
+  const maxNo = Math.max(...e.lines.map((l) => Math.max(l.oldNo ?? 0, l.newNo ?? 0)), 1);
+  const w = String(maxNo).length;
+  const budget = Math.max(20, width - (3 + w * 2 + 5));
+  for (const l of e.lines) {
+    const oldNo = l.oldNo === void 0 ? " ".repeat(w) : String(l.oldNo).padStart(w);
+    const newNo = l.newNo === void 0 ? " ".repeat(w) : String(l.newNo).padStart(w);
+    const sign = l.type === "add" ? "+" : l.type === "del" ? "-" : " ";
+    const text = truncate(expandTabs(l.text), budget);
+    const gutter = c.dim(`   ${oldNo} ${newNo} \u2502`);
+    const body = `${sign}${text}`;
+    lines.push(`${gutter}${l.type === "add" ? c.green(body) : l.type === "del" ? c.red(body) : body}`);
+  }
+  return lines;
+}
+function statsLine(stats, c, omitFiles = false) {
+  const counts = `${c.green(`+${stats.additions}`)} ${c.red(`-${stats.deletions}`)}`;
+  return omitFiles ? counts : `${stats.files} file${stats.files === 1 ? "" : "s"} \xB7 ${counts}`;
+}
+function describeSource2(source) {
+  if (source.kind === "working") {
+    return source.staged ? "Staged changes vs HEAD" : "Working tree vs HEAD (uncommitted changes)";
+  }
+  const how = source.resolvedBy === "pull-request" ? "base from pull request" : source.resolvedBy === "ancestor-branch" ? "nearest ancestor branch" : source.resolvedBy === "default-branch" ? "default branch" : null;
+  const mb = source.mergeBase ? ` (merge-base ${source.mergeBase.slice(0, 7)})` : "";
+  return `${source.head} vs ${source.base}${mb}${how ? ` \xB7 ${how}` : ""}`;
+}
+function wrap(text, width) {
+  const out = [];
+  for (const para of text.split(/\n\s*\n/)) {
+    const words = para.split(/\s+/).filter(Boolean);
+    let line = "";
+    for (const word of words) {
+      if (line && line.length + 1 + word.length > width) {
+        out.push(line);
+        line = word;
+      } else {
+        line = line ? `${line} ${word}` : word;
+      }
+    }
+    if (line) out.push(line);
+    out.push("");
+  }
+  while (out.length && out[out.length - 1] === "") out.pop();
+  return out;
+}
+function truncate(s, max) {
+  return s.length > max ? s.slice(0, Math.max(0, max - 1)) + "\u2026" : s;
+}
+function expandTabs(s) {
+  return s.replaceAll("	", "    ");
+}
+function visibleLength(s) {
+  return s.replace(/\x1b\[[0-9;]*m/g, "").length;
+}
+function relativeTime(iso, now = /* @__PURE__ */ new Date()) {
+  const ms = now.getTime() - new Date(iso).getTime();
+  if (!Number.isFinite(ms) || ms < 0) return "just now";
+  const s = Math.round(ms / 1e3);
+  if (s < 60) return "just now";
+  const m = Math.round(s / 60);
+  if (m < 60) return `${m} min ago`;
+  const h = Math.round(m / 60);
+  if (h < 48) return `${h} h ago`;
+  const d = Math.round(h / 24);
+  return `${d} days ago`;
+}
+
+// src/render/pager.ts
+import { spawn as spawn2 } from "child_process";
+async function writeMaybePaged(output, opts) {
+  const env = opts.env ?? process.env;
+  const lineCount = output.split("\n").length;
+  const shouldPage = opts.mode === "always" || opts.mode === "auto" && opts.isTTY && lineCount > opts.rows - 1;
+  if (!shouldPage) {
+    await writeStdout(output);
+    return;
+  }
+  const pagerCmd = env.PAGER && env.PAGER.trim() || "less";
+  const cmd = pagerCmd === "less" && !env.LESS ? "less -RFX" : pagerCmd;
+  await new Promise((resolve) => {
+    const child = spawn2(cmd, { shell: true, stdio: ["pipe", "inherit", "inherit"], env });
+    let fellBack = false;
+    child.on("error", () => {
+      fellBack = true;
+      process.stdout.write(output);
+      resolve();
+    });
+    child.on("close", () => {
+      if (!fellBack) resolve();
+    });
+    child.stdin.on("error", () => {
+    });
+    child.stdin.end(output);
+  });
+}
+function writeStdout(output) {
+  return new Promise((resolve) => {
+    process.stdout.write(output, () => resolve());
+  });
+}
+
+export {
+  LlmTourOutputSchema,
+  TourSchema,
+  formatIssues,
+  BbError,
+  UsageError,
+  ConfigError,
+  NotARepoError,
+  GitError,
+  NoChangesError,
+  LlmFailedError,
+  BadLlmOutputError,
+  BUILTIN_PRESETS,
+  ConfigSchema,
+  PartialConfigSchema,
+  DEFAULT_CONFIG,
+  userConfigPath,
+  defaultCacheDir,
+  projectConfigPath,
+  deepMerge,
+  loadConfig,
+  allPresets,
+  resolveLlm,
+  shellSplit,
+  TourCache,
+  extractJson,
+  parseDiff,
+  diffStats,
+  OTHER_CHANGES_TITLE,
+  materializeTour,
+  sliceHunk,
+  PROMPT_VERSION,
+  buildPrompt,
+  describeSource,
+  GhCodeHost,
+  NoCodeHost,
+  createCodeHost,
+  gitRoot,
+  revParse,
+  currentBranch,
+  collectDiff,
+  collectCommits,
+  resolveRange,
+  detectDefaultBranch,
+  CommandProvider,
+  createProvider,
+  prepareTour,
+  generateTour,
+  CliRenderer,
+  describeSource2,
+  wrap,
+  relativeTime,
+  writeMaybePaged,
+  writeStdout
+};
+//# sourceMappingURL=chunk-RWSCST2I.js.map