@garuda-agent/garuda 0.0.1 → 0.14.1

package/dist/inkChat-3J26R24L.js

@@ -0,0 +1,1190 @@
+#!/usr/bin/env node
+import {
+  FOCUS_REPORTING_OFF,
+  FOCUS_REPORTING_ON,
+  colorPreview,
+  focusEvent,
+  fuzzyFiles,
+  header,
+  runChat,
+  statusOf
+} from "./chunk-YM6T4J5V.js";
+import {
+  retryText,
+  serverToolOutput,
+  serverToolText,
+  summariseCall,
+  summariseResult,
+  todoLines
+} from "./chunk-FARS4R67.js";
+import "./chunk-ITITLNAR.js";
+import "./chunk-A2QAIRQL.js";
+import "./chunk-W7BPYQMW.js";
+import "./chunk-G2AX7MGS.js";
+import "./chunk-KWRJREUH.js";
+import "./chunk-EU7PA45O.js";
+import "./chunk-6TWBYMY7.js";
+import "./chunk-5DEWP3YX.js";
+import "./chunk-ZAE25JM2.js";
+import "./chunk-ATW7BNIG.js";
+import "./chunk-PZS3V6P3.js";
+import "./chunk-OUCV3FCT.js";
+import "./chunk-D5O5CIWK.js";
+import "./chunk-WMOLXTBU.js";
+import "./chunk-HUIK3WXO.js";
+import "./chunk-KKB5W47S.js";
+import "./chunk-3NJNVZTK.js";
+
+// src/cli/chat/inkChat.ts
+import { render } from "ink";
+import { createElement } from "react";
+
+// src/cli/chat/externalEditor.ts
+import { mkdtempSync, readFileSync, rmSync, writeFileSync } from "fs";
+import { tmpdir } from "os";
+import { join } from "path";
+
+// src/sandbox/terminal.ts
+import { spawnSync } from "child_process";
+function runInTerminal(argv) {
+  const [program, ...args] = argv;
+  if (program === void 0) return { exitCode: null, error: "no program" };
+  const result = spawnSync(program, args, { stdio: "inherit" });
+  if (result.error !== void 0) return { exitCode: null, error: result.error.message };
+  return { exitCode: result.status };
+}
+
+// src/cli/chat/externalEditor.ts
+function editorCommand(env = process.env) {
+  const raw = (env.VISUAL || env.EDITOR || "vi").trim();
+  return [...raw.matchAll(/"([^"]*)"|'([^']*)'|(\S+)/g)].map((m) => m[1] ?? m[2] ?? m[3] ?? "");
+}
+function editInEditor(text, options = {}) {
+  const dir = mkdtempSync(join(tmpdir(), "garuda-prompt-"));
+  const file = join(dir, "prompt.md");
+  try {
+    writeFileSync(file, text, { mode: 384 });
+    const argv = [...editorCommand(options.env), file];
+    const result = (options.run ?? runInTerminal)(argv);
+    if (result.error !== void 0) {
+      return { problem: `Could not start ${argv[0]}: ${result.error}. Set $EDITOR.` };
+    }
+    if (result.exitCode !== 0)
+      return { problem: `${argv[0]} ended with code ${result.exitCode}; the line did not change.` };
+    return { text: readFileSync(file, "utf8").replace(/\n+$/, "") };
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+}
+
+// src/cli/chat/hunkStaging.ts
+function parseHunksFromDiff(diffText, fallbackFile = "patch") {
+  const lines = diffText.split("\n");
+  let file = fallbackFile;
+  const hunks = [];
+  let current = null;
+  let hunkIndex = 0;
+  for (const line of lines) {
+    if (current === null && (line.startsWith("--- ") || line.startsWith("+++ "))) {
+      const match = /^[+-]{3}\s+[ab]\/(.+)$/.exec(line);
+      if (match?.[1]) file = match[1];
+      continue;
+    }
+    const hunkMatch = /^@@\s+-(\d+)(?:,(\d+))?\s+\+(\d+)(?:,(\d+))?\s+@@(.*)$/.exec(line);
+    if (hunkMatch) {
+      if (current) {
+        hunks.push({
+          id: hunkIndex++,
+          ...current,
+          lines: [...current.lines]
+        });
+      }
+      current = {
+        oldStart: Number.parseInt(hunkMatch[1] ?? "1", 10),
+        oldLines: Number.parseInt(hunkMatch[2] ?? "1", 10),
+        newStart: Number.parseInt(hunkMatch[3] ?? "1", 10),
+        newLines: Number.parseInt(hunkMatch[4] ?? "1", 10),
+        header: line,
+        heading: (hunkMatch[5] ?? "").trim(),
+        lines: [],
+        staged: true
+      };
+      continue;
+    }
+    if (current) {
+      if (line.startsWith("+") || line.startsWith("-") || line.startsWith(" ") || line.startsWith("\\")) {
+        current.lines.push(line);
+      }
+    }
+  }
+  if (current) {
+    hunks.push({
+      id: hunkIndex++,
+      ...current,
+      lines: [...current.lines]
+    });
+  }
+  return { file, hunks };
+}
+function createHunkStaging(diffText, fallbackFile) {
+  const { file, hunks } = parseHunksFromDiff(diffText, fallbackFile);
+  if (hunks.length === 0) return void 0;
+  return {
+    file,
+    hunks,
+    currentHunk: 0
+  };
+}
+function stageCurrentHunk(state, staged) {
+  const current = state.hunks[state.currentHunk];
+  if (current) current.staged = staged;
+  const hasStaged = state.hunks.some((h) => h.staged);
+  if (state.currentHunk < state.hunks.length - 1) {
+    state.currentHunk++;
+    return { finished: false, hasStaged };
+  }
+  return { finished: true, hasStaged };
+}
+function stageAllRemaining(state) {
+  for (let i = state.currentHunk; i < state.hunks.length; i++) {
+    const h = state.hunks[i];
+    if (h) h.staged = true;
+  }
+}
+function discardAllHunks(state) {
+  for (const h of state.hunks) {
+    h.staged = false;
+  }
+}
+function navigateHunk(state, delta) {
+  const next = state.currentHunk + delta;
+  state.currentHunk = Math.max(0, Math.min(state.hunks.length - 1, next));
+}
+
+// src/cli/chat/lineEditor.ts
+var emptyEditor = (history = []) => ({
+  text: "",
+  cursor: 0,
+  history,
+  historyIndex: -1,
+  draft: ""
+});
+function edit(state, action) {
+  const { text, cursor } = state;
+  const set = (next, at) => ({
+    ...state,
+    text: next,
+    cursor: Math.max(0, Math.min(at, next.length)),
+    historyIndex: -1
+  });
+  switch (action.type) {
+    case "insert": {
+      const add = action.text.replace(/\r\n?/g, "\n");
+      return set(text.slice(0, cursor) + add + text.slice(cursor), cursor + add.length);
+    }
+    case "backspace":
+      return cursor === 0 ? state : set(text.slice(0, cursor - 1) + text.slice(cursor), cursor - 1);
+    case "delete":
+      return cursor === text.length ? state : set(text.slice(0, cursor) + text.slice(cursor + 1), cursor);
+    case "left":
+      return { ...state, cursor: Math.max(0, cursor - 1) };
+    case "right":
+      return { ...state, cursor: Math.min(text.length, cursor + 1) };
+    case "home":
+      return { ...state, cursor: 0 };
+    case "end":
+      return { ...state, cursor: text.length };
+    case "wordLeft":
+      return { ...state, cursor: wordStart(text, cursor) };
+    case "wordRight":
+      return { ...state, cursor: wordEnd(text, cursor) };
+    case "deleteWord": {
+      const start = wordStart(text, cursor);
+      return set(text.slice(0, start) + text.slice(cursor), start);
+    }
+    case "killToStart":
+      return set(text.slice(cursor), 0);
+    case "killToEnd":
+      return set(text.slice(0, cursor), cursor);
+    case "clear":
+      return { ...emptyEditor(state.history) };
+    case "set":
+      return set(action.text, action.cursor);
+    case "up": {
+      if (state.historyIndex + 1 >= state.history.length) return state;
+      const index = state.historyIndex + 1;
+      const entry = state.history[index] ?? "";
+      return {
+        ...state,
+        text: entry,
+        cursor: entry.length,
+        historyIndex: index,
+        draft: state.historyIndex === -1 ? text : state.draft
+      };
+    }
+    case "down": {
+      if (state.historyIndex === -1) return state;
+      const index = state.historyIndex - 1;
+      const entry = index === -1 ? state.draft : state.history[index] ?? "";
+      return { ...state, text: entry, cursor: entry.length, historyIndex: index };
+    }
+  }
+}
+function submit(state) {
+  const text = state.text;
+  const history = text.trim() === "" || state.history[0] === text ? state.history : [text, ...state.history];
+  return { text, state: emptyEditor(history.slice(0, 200)) };
+}
+function wordStart(text, cursor) {
+  let i = cursor;
+  while (i > 0 && /\s/.test(text[i - 1] ?? "")) i--;
+  while (i > 0 && !/\s/.test(text[i - 1] ?? "")) i--;
+  return i;
+}
+function wordEnd(text, cursor) {
+  let i = cursor;
+  while (i < text.length && /\s/.test(text[i] ?? "")) i++;
+  while (i < text.length && !/\s/.test(text[i] ?? "")) i++;
+  return i;
+}
+
+// src/cli/chat/markdown.ts
+import { styleText } from "util";
+var ansi = (style, text) => styleText(style, text, { validateStream: false });
+function takeBlocks(buffer) {
+  const blocks = [];
+  const lines = buffer.split("\n");
+  const open = lines.pop() ?? "";
+  let current = [];
+  let inFence = false;
+  for (const line of lines) {
+    if (/^\s*(```|~~~)/.test(line)) {
+      current.push(line);
+      inFence = !inFence;
+      if (!inFence) {
+        blocks.push(current.join("\n"));
+        current = [];
+      }
+      continue;
+    }
+    if (!inFence && line.trim() === "") {
+      if (current.length > 0) blocks.push(current.join("\n"));
+      current = [];
+      continue;
+    }
+    current.push(line);
+  }
+  return { blocks, rest: [...current, open].join("\n") };
+}
+function renderMarkdown(block, paint = ansi) {
+  const lines = block.split("\n");
+  const out = [];
+  let inFence = false;
+  for (const line of lines) {
+    if (/^\s*(```|~~~)/.test(line)) {
+      inFence = !inFence;
+      continue;
+    }
+    if (inFence) {
+      out.push(`  ${paint("cyan", line)}`);
+      continue;
+    }
+    const heading = /^(#{1,6})\s+(.*)$/.exec(line);
+    if (heading) {
+      const text = inline(heading[2] ?? "", paint);
+      out.push(heading[1] === "#" ? paint(["bold", "underline"], text) : paint("bold", text));
+      continue;
+    }
+    const bullet = /^(\s*)[-*+]\s+(.*)$/.exec(line);
+    if (bullet) {
+      out.push(`${bullet[1]}\u2022 ${inline(bullet[2] ?? "", paint)}`);
+      continue;
+    }
+    const quote = /^>\s?(.*)$/.exec(line);
+    if (quote) {
+      out.push(paint("dim", `\u2502 ${quote[1] ?? ""}`));
+      continue;
+    }
+    if (/^\s*(---|\*\*\*|___)\s*$/.test(line)) {
+      out.push(paint("dim", "\u2500".repeat(40)));
+      continue;
+    }
+    out.push(inline(line, paint));
+  }
+  return out.join("\n");
+}
+function inline(text, paint = ansi) {
+  return text.split(/(`[^`]+`)/).map((part) => {
+    if (part.startsWith("`") && part.endsWith("`") && part.length > 1) {
+      return paint("cyan", part.slice(1, -1));
+    }
+    return part.replace(/\*\*([^*]+)\*\*/g, (_m, t) => paint("bold", t)).replace(
+      /(^|[^\w*])\*([^*\s][^*]*)\*(?!\w)/g,
+      (_m, pre, t) => pre + paint("italic", t)
+    ).replace(
+      /(^|[^\w])_([^_\s][^_]*)_(?!\w)/g,
+      (_m, pre, t) => pre + paint("italic", t)
+    ).replace(
+      /\[([^\]]+)\]\(([^)]+)\)/g,
+      (_m, t, url) => `${t} ${paint("dim", `(${url})`)}`
+    );
+  }).join("");
+}
+
+// src/cli/chat/palette.ts
+var PALETTE_ROWS = 10;
+function filterPalette(entries, query) {
+  const q = query.trim().replace(/^\//, "").toLowerCase();
+  if (q === "") return [...entries];
+  const byName = new Map(entries.map((e) => [e.name, e]));
+  const names = fuzzyFiles(q, [...byName.keys()], entries.length);
+  const out = names.flatMap((n) => {
+    const entry = byName.get(n);
+    return entry === void 0 ? [] : [entry];
+  });
+  if (out.length > 0) return out;
+  return entries.filter((entry) => entry.hint.toLowerCase().includes(q));
+}
+function paletteWindow(selected, count) {
+  if (count <= PALETTE_ROWS) return 0;
+  return Math.min(Math.max(0, selected - PALETTE_ROWS + 1), count - PALETTE_ROWS);
+}
+
+// src/cli/chat/store.ts
+var APPROVAL_KEY_DELAY_MS = 400;
+var APPROVAL_CHOICES = [
+  { choice: "once", label: "Yes, once" },
+  { choice: "session", label: "Yes, for this session" },
+  { choice: "deny", label: "No, deny" }
+];
+var EXIT_WINDOW_MS = 2e3;
+var ChatStore = class {
+  /** Set by runTurnInTerminal during a turn: it stops the turn. */
+  onInterrupt = () => {
+  };
+  state;
+  listeners = /* @__PURE__ */ new Set();
+  nextId = 0;
+  waiting;
+  answer;
+  lastOutput;
+  /** All palette rows while the palette is open (0.9). */
+  paletteAll = [];
+  interruptAt = 0;
+  /** A stop of the running turn was asked (Esc or Ctrl-C): Esc does not ask again. */
+  stopping = false;
+  /** Tab (0.6): the chat sets it; see complete.ts. */
+  completer;
+  /** The command palette's rows (0.9): the chat sets it. */
+  paletteSource;
+  /** Ctrl-G and /editor (0.6): the chat sets it; it edits the text in the user's editor. */
+  externalEdit;
+  paint;
+  now;
+  constructor(status, options = {}) {
+    this.paint = options.paint ?? ansi;
+    this.now = options.now ?? Date.now;
+    this.approvalKeyDelayMs = options.approvalKeyDelayMs ?? APPROVAL_KEY_DELAY_MS;
+    this.state = {
+      items: [],
+      streaming: "",
+      running: [],
+      approval: void 0,
+      queue: [],
+      editor: emptyEditor(options.history),
+      busy: false,
+      status,
+      exiting: false
+    };
+  }
+  // The external store for React (useSyncExternalStore).
+  subscribe = (listener) => {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  };
+  getState = () => this.state;
+  update(change) {
+    this.state = { ...this.state, ...change };
+    for (const listener of this.listeners) listener();
+  }
+  add(item) {
+    this.update({ items: [...this.state.items, { ...item, id: this.nextId++ }] });
+  }
+  // Input.
+  /** The next line to run: from the queue, or the next Enter. undefined means exit. */
+  nextInput() {
+    if (this.state.exiting) return Promise.resolve(void 0);
+    const [first, ...rest] = this.state.queue;
+    if (first !== void 0) {
+      this.update({ queue: rest });
+      return Promise.resolve(first);
+    }
+    return new Promise((resolve) => {
+      this.waiting = resolve;
+    });
+  }
+  editLine(action) {
+    this.update({ editor: edit(this.state.editor, action) });
+  }
+  /** Enter: run the line now, or queue it while a turn runs (type-ahead). */
+  submitLine() {
+    const { text, state } = submit(this.state.editor);
+    this.update({ editor: state });
+    if (text.trim() === "") return;
+    if (this.waiting !== void 0 && !this.state.busy) {
+      const resolve = this.waiting;
+      this.waiting = void 0;
+      resolve(text);
+    } else {
+      this.update({ queue: [...this.state.queue, text] });
+    }
+  }
+  /** Queue a line to run next, as if typed (garuda init). */
+  enqueue(text) {
+    this.update({ queue: [...this.state.queue, text] });
+  }
+  /** Esc: drop queued lines. */
+  /** Ctrl-P (0.9): open the command palette, or close it when it is open. */
+  togglePalette() {
+    if (this.state.palette !== void 0) {
+      this.closePalette();
+      return;
+    }
+    const all = this.paletteSource?.() ?? [];
+    this.paletteAll = all;
+    this.update({ palette: { query: "", entries: all, selected: 0 } });
+  }
+  closePalette() {
+    const { palette: _closed, ...rest } = this.state;
+    this.state = rest;
+    for (const listener of this.listeners) listener();
+  }
+  /** Type into the palette's filter (text), or take a character off (null). */
+  paletteQuery(text) {
+    const palette = this.state.palette;
+    if (palette === void 0) return;
+    const query = text === null ? palette.query.slice(0, -1) : palette.query + text;
+    this.update({
+      palette: { query, entries: filterPalette(this.paletteAll, query), selected: 0 }
+    });
+  }
+  movePalette(delta) {
+    const palette = this.state.palette;
+    if (palette === void 0 || palette.entries.length === 0) return;
+    const n = palette.entries.length;
+    this.update({ palette: { ...palette, selected: (palette.selected + delta + n) % n } });
+  }
+  /** Enter: run the selected command, or put it in the input line for its arguments. */
+  pickPalette() {
+    const entry = this.state.palette?.entries[this.state.palette.selected];
+    this.closePalette();
+    if (entry === void 0) return;
+    if (entry.runs) {
+      this.editLine({ type: "set", text: `/${entry.name}`, cursor: entry.name.length + 1 });
+      this.submitLine();
+    } else {
+      this.editLine({ type: "set", text: `/${entry.name} `, cursor: entry.name.length + 2 });
+    }
+  }
+  clearQueue() {
+    if (this.state.queue.length > 0) this.update({ queue: [] });
+  }
+  /**
+   * Esc (0.6). During a turn: drop queued lines and stop the turn, like the first Ctrl-C. Esc never
+   * exits Garuda: a second Esc while the turn stops does nothing.
+   */
+  stopTurn() {
+    this.clearQueue();
+    if (!this.state.busy || this.stopping) return;
+    this.stopping = true;
+    this.onInterrupt();
+  }
+  /** Tab (0.6): complete a /command or an @path at the cursor; several matches are listed. */
+  completeLine() {
+    const { text, cursor } = this.state.editor;
+    const result = this.completer?.(text, cursor);
+    if (result === void 0) return;
+    this.editLine({ type: "set", text: result.text, cursor: result.cursor });
+    if (result.candidates.length > 0) {
+      this.info(result.candidates.join(result.lines === true ? "\n" : "  "));
+    }
+  }
+  /** Ctrl-G or /editor (0.6): edit the input line in $VISUAL or $EDITOR. The text is not sent. */
+  openEditor() {
+    if (this.externalEdit === void 0) {
+      this.warn("The external editor works only in the full chat on a terminal.");
+      return;
+    }
+    const result = this.externalEdit(this.state.editor.text);
+    if (result.problem !== void 0) this.warn(result.problem);
+    if (result.text !== void 0) {
+      this.editLine({ type: "clear" });
+      this.editLine({ type: "insert", text: result.text });
+    }
+  }
+  /**
+   * Ctrl-C. During a turn: stop it (a second Ctrl-C exits, see runTurnInTerminal).
+   * At the prompt: clear the line, or exit on a second Ctrl-C within 2 s.
+   */
+  interrupt() {
+    if (this.state.busy) {
+      this.stopping = true;
+      this.onInterrupt();
+      return;
+    }
+    if (this.state.editor.text !== "") {
+      this.editLine({ type: "clear" });
+      return;
+    }
+    if (this.now() - this.interruptAt < EXIT_WINDOW_MS) {
+      this.exit();
+      return;
+    }
+    this.interruptAt = this.now();
+    this.info("Press Ctrl-C again to exit, or type /exit.");
+  }
+  /** Ctrl-D on an empty line, or the end of input. */
+  exit() {
+    this.update({ exiting: true });
+    const resolve = this.waiting;
+    this.waiting = void 0;
+    resolve?.(void 0);
+  }
+  // A turn.
+  /** Update the footer, for example after /plan. */
+  refreshStatus(status) {
+    this.update({ status });
+  }
+  /** Shift+Tab: the chat sets the handler; it switches the mode and returns the new status. */
+  onToggleMode;
+  toggleMode() {
+    const status = this.onToggleMode?.();
+    if (status !== void 0) this.update({ status });
+  }
+  /** Start a turn. `show: false` when the line is already on screen (a custom command). */
+  begin(prompt, show = true) {
+    if (show) this.add({ kind: "user", text: prompt });
+    this.stopping = false;
+    this.update({ busy: true });
+  }
+  end(status) {
+    this.flushText();
+    this.stopping = false;
+    this.update({ busy: false, running: [], status: { ...this.state.status, ...status } });
+  }
+  /** Print text as it is (it may hold its own colors), for example the start banner. */
+  print(text) {
+    this.add({ kind: "output", text });
+  }
+  /** Echo a command line, for commands that do not start a turn. */
+  echo(prompt) {
+    this.add({ kind: "user", text: prompt });
+  }
+  /** The terminal window got (true) or lost (false) focus (0.6). The Ink chat sets it. */
+  onFocus = () => {
+  };
+  /** Keep a long text for Ctrl-O, as for a tool call (0.6: /diff). */
+  keepOutput(title, text) {
+    this.lastOutput = { title, text };
+  }
+  /** Ctrl-O: print the full output of the last tool call. */
+  showLastOutput() {
+    if (this.lastOutput === void 0) {
+      this.info("No tool output yet.");
+      return;
+    }
+    const { title, text } = this.lastOutput;
+    this.add({ kind: "output", text: `${this.paint("bold", title)}
+${text}` });
+  }
+  // Renderer.
+  event(event) {
+    switch (event.type) {
+      case "thinking_delta":
+        this.thinking += event.text;
+        return;
+      case "text_delta": {
+        this.flushThinking();
+        const { blocks, rest } = takeBlocks(this.state.streaming + event.text);
+        for (const block of blocks)
+          this.add({ kind: "text", text: renderMarkdown(block, this.paint) });
+        this.update({ streaming: rest });
+        return;
+      }
+      case "tool_call":
+        this.flushText();
+        this.update({
+          running: [
+            ...this.state.running,
+            { id: event.call.id, line: `${event.call.name} ${summariseCall(event.call)}` }
+          ]
+        });
+        return;
+      case "model_retry":
+        this.update({ streaming: "" });
+        this.warn(retryText(event));
+        return;
+      case "tool_progress": {
+        const base = `${event.call.name} ${summariseCall(event.call)}`;
+        this.update({
+          running: this.state.running.map(
+            (r) => r.id === event.call.id ? { ...r, line: `${base} \xB7 ${event.text}` } : r
+          )
+        });
+        return;
+      }
+      case "tool_result": {
+        const summary = summariseResult(event.call, event.outcome);
+        const line = `${this.paint("cyan", "\u25CF")} ${this.paint("bold", event.call.name)} ${summariseCall(event.call)}`;
+        const result = `  ${this.paint("dim", "\u23BF")} ${event.outcome.isError ? this.paint("red", summary) : this.paint("dim", summary)}`;
+        const todos = todoLines(event.call, event.outcome).map((l) => `    ${l}`);
+        const shown = this.details || event.outcome.isError ? [result] : [];
+        this.add({ kind: "tool", text: [line, ...shown, ...todos].join("\n") });
+        this.lastOutput = {
+          title: `${event.call.name} ${summariseCall(event.call)}`,
+          text: event.outcome.content
+        };
+        this.update({ running: this.state.running.filter((r) => r.id !== event.call.id) });
+        return;
+      }
+      case "compaction": {
+        const { stage, beforeTokens, afterTokens } = event.result;
+        this.info(`Context compacted (${stage}): ${beforeTokens} \u2192 about ${afterTokens} tokens.`);
+        return;
+      }
+      case "step_end":
+        this.flushText();
+        return;
+      case "notice":
+        this.info(event.text);
+        return;
+      case "server_tool": {
+        this.flushText();
+        const { call, result } = serverToolText(event);
+        const failed = event.result?.error !== void 0;
+        const head = `${this.paint("cyan", "\u25CF")} ${this.paint("bold", call)}`;
+        this.add({
+          kind: "tool",
+          text: this.details || failed ? `${head}
+  ${this.paint("dim", "\u23BF")} ${this.paint(failed ? "red" : "dim", result)}` : head
+        });
+        this.lastOutput = { title: call, text: serverToolOutput(event) };
+        return;
+      }
+    }
+  }
+  /** /details (0.9): show the result line of each tool call (errors always show). */
+  details = true;
+  info(text) {
+    this.note("info", text);
+  }
+  warn(text) {
+    this.note("warn", text);
+  }
+  error(text) {
+    this.note("error", text);
+  }
+  note(level, text) {
+    this.flushText();
+    const trimmed = text.replace(/^\n+/, "");
+    const style = level === "info" ? "dim" : level === "warn" ? "yellow" : "red";
+    this.add({ kind: "note", level, text: this.paint(style, trimmed) });
+  }
+  /** Readable thinking of the current block (0.9, /thinking show). */
+  thinking = "";
+  /** Show the thinking so far as a dimmed item: the first lines, Ctrl-O for all (0.9). */
+  flushThinking() {
+    const text = this.thinking.trim();
+    this.thinking = "";
+    if (text === "") return;
+    this.add({ kind: "output", text: thinkingPreview(text, (s) => this.paint("dim", s)) });
+    this.lastOutput = { title: "thinking", text };
+  }
+  flushText() {
+    this.flushThinking();
+    const rest = this.state.streaming;
+    if (rest.trim() !== "")
+      this.add({ kind: "text", text: renderMarkdown(rest.trim(), this.paint) });
+    if (rest !== "") this.update({ streaming: "" });
+  }
+  // Approver.
+  /**
+   * One question at a time (0.14.1, review): calls in a parallel batch can both ask, and a second
+   * question replaced the first, whose call then waited forever. Now the second one waits.
+   */
+  ask(request, signal) {
+    const next = this.asking === 0 ? this.askNow(request, signal) : this.askQueue.then(() => this.askNow(request, signal));
+    this.asking++;
+    this.askQueue = next.catch(() => {
+    }).finally(() => {
+      this.asking--;
+    });
+    return next;
+  }
+  /**
+   * False in the first moment after a question appears: keys typed for the next prompt must not
+   * answer it ("a" in "add a test" allowed the call for the session; 0.14.1, review).
+   */
+  takesApprovalKeys() {
+    const shownAt = this.state.approval?.shownAt;
+    return shownAt === void 0 || this.now() - shownAt >= this.approvalKeyDelayMs;
+  }
+  askQueue = Promise.resolve();
+  asking = 0;
+  approvalKeyDelayMs;
+  askNow(request, signal) {
+    this.flushText();
+    this.add({ kind: "output", text: `${header(request)}
+${colorPreview(request)}` });
+    return new Promise((resolve, reject) => {
+      const onAbort = () => {
+        this.answer = void 0;
+        this.update({ approval: void 0 });
+        reject(signal.reason);
+      };
+      if (signal.aborted) {
+        onAbort();
+        return;
+      }
+      signal.addEventListener("abort", onAbort, { once: true });
+      this.answer = (choice) => {
+        signal.removeEventListener("abort", onAbort);
+        const label = this.state.approval?.choices.find((c) => c.choice === choice)?.label ?? choice;
+        this.answer = void 0;
+        this.update({ approval: void 0 });
+        this.add({
+          kind: "note",
+          level: "info",
+          text: choice === "deny" ? this.paint("red", `\u2717 ${label}`) : this.paint("green", `\u2714 ${label}`)
+        });
+        resolve(choice);
+      };
+      const host = request.target.kind === "url" ? request.target.host : void 0;
+      const shown = APPROVAL_CHOICES.filter((c) => request.choices?.includes(c.choice) ?? true);
+      const choices = shown.map((c) => ({
+        choice: c.choice,
+        label: request.labels?.[c.choice] ?? (c.choice === "session" && host !== void 0 ? `Yes, allow ${host} for this session` : c.label)
+      }));
+      this.update({ approval: { request, choices, selected: 0, shownAt: this.now() } });
+    });
+  }
+  moveApproval(delta) {
+    const approval = this.state.approval;
+    if (approval === void 0) return;
+    const n = approval.choices.length;
+    this.update({ approval: { ...approval, selected: (approval.selected + delta + n) % n } });
+  }
+  /** Answer with the highlighted choice, or with a given one. */
+  choose(choice) {
+    const approval = this.state.approval;
+    if (approval === void 0 || this.answer === void 0) return;
+    if (choice !== void 0 && !approval.choices.some((c) => c.choice === choice)) return;
+    this.answer(choice ?? approval.choices[approval.selected]?.choice ?? "deny");
+  }
+  /**
+   * Enter hunk-by-hunk review (0.14). Only when the tool can apply single hunks (the request has
+   * `selectHunks`, U0): otherwise the choice of hunks would not change what is written.
+   */
+  startHunkReview() {
+    const approval = this.state.approval;
+    if (approval === void 0 || approval.request.selectHunks === void 0) return false;
+    const fallback = approval.request.target.kind === "path" ? approval.request.target.path : "diff";
+    const hunkReview = createHunkStaging(approval.request.preview, fallback);
+    if (hunkReview === void 0) return false;
+    this.update({ approval: { ...approval, hunkReview } });
+    return true;
+  }
+  /** Exit hunk staging back to standard approval choice view. */
+  closeHunkReview() {
+    const approval = this.state.approval;
+    if (approval === void 0 || approval.hunkReview === void 0) return;
+    this.update({ approval: { ...approval, hunkReview: void 0 } });
+  }
+  /** Stage or unstage the current hunk in hunk review mode. */
+  stageHunk(staged) {
+    const approval = this.state.approval;
+    if (approval === void 0 || approval.hunkReview === void 0) return;
+    const { finished } = stageCurrentHunk(approval.hunkReview, staged);
+    if (finished) {
+      this.finishHunkReview();
+    } else {
+      this.update({ approval: { ...approval, hunkReview: { ...approval.hunkReview } } });
+    }
+  }
+  /** Stage all remaining hunks and approve. */
+  stageAllHunks() {
+    const approval = this.state.approval;
+    if (approval === void 0 || approval.hunkReview === void 0) return;
+    stageAllRemaining(approval.hunkReview);
+    this.finishHunkReview();
+  }
+  /**
+   * Answer from the staged hunks (U0): all staged = the whole change; none = deny; some = only those
+   * hunks, passed to the tool through `selectHunks`, so a rejected hunk never reaches the disk.
+   */
+  finishHunkReview() {
+    const approval = this.state.approval;
+    if (approval === void 0 || approval.hunkReview === void 0) return;
+    const staged = approval.hunkReview.hunks.filter((h) => h.staged).map((h) => h.id);
+    if (staged.length === 0) {
+      this.choose("deny");
+      return;
+    }
+    if (staged.length < approval.hunkReview.hunks.length) {
+      approval.request.selectHunks?.(staged);
+    }
+    this.choose("once");
+  }
+  /** Discard all hunks and deny. */
+  discardAllHunks() {
+    const approval = this.state.approval;
+    if (approval === void 0 || approval.hunkReview === void 0) return;
+    discardAllHunks(approval.hunkReview);
+    this.choose("deny");
+  }
+  /** Navigate between hunks in hunk review mode. */
+  moveHunk(delta) {
+    const approval = this.state.approval;
+    if (approval === void 0 || approval.hunkReview === void 0) return;
+    navigateHunk(approval.hunkReview, delta);
+    this.update({ approval: { ...approval, hunkReview: { ...approval.hunkReview } } });
+  }
+};
+var THINKING_LINES = 4;
+function thinkingPreview(text, dim) {
+  const lines = text.split("\n").filter((l) => l.trim() !== "");
+  const shown = lines.slice(0, THINKING_LINES).map((l) => l.length > 160 ? `${l.slice(0, 159)}\u2026` : l);
+  const more = lines.length > THINKING_LINES ? [`\u2026 ${lines.length - THINKING_LINES} more line(s): Ctrl-O`] : [];
+  return [...shown, ...more].map((l, i) => dim(`${i === 0 ? "\u273B" : " "} ${l}`)).join("\n");
+}
+
+// src/cli/chat/ui.tsx
+import { Box, Static, Text, useInput, usePaste } from "ink";
+import { useEffect, useState, useSyncExternalStore } from "react";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+function App({ store }) {
+  const state = useSyncExternalStore(store.subscribe, store.getState);
+  useInput((input, key) => onKey(store, state, input, key));
+  usePaste((text) => {
+    if (store.getState().approval === void 0) store.editLine({ type: "insert", text });
+  });
+  const spinning = state.busy && state.approval === void 0;
+  const frame = useSpinner(spinning);
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsx(Static, { items: state.items, children: (item) => /* @__PURE__ */ jsx(ItemView, { item }, item.id) }),
+    /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+      state.streaming !== "" && /* @__PURE__ */ jsx(Text, { children: state.streaming }),
+      state.running.map((tool) => /* @__PURE__ */ jsxs(Text, { children: [
+        /* @__PURE__ */ jsx(Text, { color: "cyan", children: frame }),
+        " ",
+        tool.line
+      ] }, tool.id)),
+      spinning && state.running.length === 0 && state.streaming === "" && /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+        /* @__PURE__ */ jsx(Text, { color: "cyan", children: frame }),
+        " Working\u2026 (Ctrl-C stops)"
+      ] }),
+      state.approval !== void 0 && state.approval.hunkReview !== void 0 && /* @__PURE__ */ jsx(HunkStagingView, { staging: state.approval.hunkReview }),
+      state.approval !== void 0 && state.approval.hunkReview === void 0 && /* @__PURE__ */ jsx(
+        ApprovalView,
+        {
+          question: state.approval.request.question ?? "Allow?",
+          choices: state.approval.choices,
+          selected: state.approval.selected,
+          hasHunks: state.approval.request.selectHunks !== void 0
+        }
+      ),
+      state.queue.map((line, i) => (
+        // biome-ignore lint/suspicious/noArrayIndexKey: queued lines can repeat.
+        /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+          "  ",
+          "queued: ",
+          firstLine(line)
+        ] }, i)
+      )),
+      state.approval === void 0 && !state.exiting && state.palette !== void 0 && /* @__PURE__ */ jsx(PaletteView, { palette: state.palette }),
+      state.approval === void 0 && !state.exiting && state.palette === void 0 && /* @__PURE__ */ jsx(InputLine, { state }),
+      /* @__PURE__ */ jsx(Footer, { state })
+    ] })
+  ] });
+}
+function ItemView({ item }) {
+  switch (item.kind) {
+    case "user":
+      return /* @__PURE__ */ jsx(Box, { marginTop: 1, children: /* @__PURE__ */ jsxs(Text, { bold: true, children: [
+        "\u203A ",
+        item.text
+      ] }) });
+    case "text":
+      return /* @__PURE__ */ jsx(Box, { marginTop: 1, children: /* @__PURE__ */ jsx(Text, { children: item.text }) });
+    default:
+      return /* @__PURE__ */ jsx(Text, { children: item.text });
+  }
+}
+function HunkStagingView({ staging }) {
+  const current = staging.hunks[staging.currentHunk];
+  if (!current) return null;
+  const total = staging.hunks.length;
+  const stagedCount = staging.hunks.filter((h) => h.staged).length;
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", marginTop: 1, children: [
+    /* @__PURE__ */ jsxs(Box, { justifyContent: "space-between", children: [
+      /* @__PURE__ */ jsxs(Text, { bold: true, color: "cyan", children: [
+        "Hunk ",
+        staging.currentHunk + 1,
+        " of ",
+        total,
+        " \xB7 ",
+        staging.file
+      ] }),
+      /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+        "[",
+        stagedCount,
+        "/",
+        total,
+        " staged]"
+      ] })
+    ] }),
+    /* @__PURE__ */ jsx(Text, { color: "cyan", children: current.header }),
+    /* @__PURE__ */ jsx(Box, { flexDirection: "column", paddingLeft: 1, children: current.lines.map((line, i) => {
+      const color = line.startsWith("+") ? "green" : line.startsWith("-") ? "red" : void 0;
+      return (
+        // biome-ignore lint/suspicious/noArrayIndexKey: diff lines can be identical
+        /* @__PURE__ */ jsx(Text, { ...color ? { color } : {}, children: line }, i)
+      );
+    }) }),
+    /* @__PURE__ */ jsx(Text, { dimColor: true, children: "[y] stage hunk \xB7 [n] skip \xB7 [a] stage all \xB7 [d] discard all \xB7 [\u2190/\u2192] prev/next \xB7 [Esc] back" })
+  ] });
+}
+function ApprovalView({
+  question,
+  choices,
+  selected,
+  hasHunks = false
+}) {
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", marginTop: 1, children: [
+    /* @__PURE__ */ jsx(Text, { bold: true, children: question }),
+    choices.map((c, i) => /* @__PURE__ */ jsxs(Text, { ...i === selected ? { color: "cyan" } : {}, children: [
+      i === selected ? "\u276F " : "  ",
+      i + 1,
+      ". ",
+      c.label
+    ] }, c.choice)),
+    /* @__PURE__ */ jsx(Text, { dimColor: true, children: approvalKeys(
+      choices.map((c) => c.choice),
+      hasHunks
+    ) })
+  ] });
+}
+function approvalKeys(choices, hasHunks = false) {
+  const letters = { once: "y", session: "a", deny: "n or Esc" };
+  const numbers = choices.map((_, i) => i + 1).join(" ");
+  const keys = choices.map((c, i) => `${letters[c] ?? "?"} = ${i + 1}`).join(" \xB7 ");
+  const hunksHint = hasHunks ? " \xB7 h = stage hunks" : "";
+  return `\u2191\u2193 and Enter, or ${numbers} \xB7 ${keys}${hunksHint}`;
+}
+function PaletteView({ palette }) {
+  const first = paletteWindow(palette.selected, palette.entries.length);
+  const rows = palette.entries.slice(first, first + PALETTE_ROWS);
+  const width = Math.max(8, ...rows.map((e) => e.name.length + 1));
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", marginTop: 1, children: [
+    /* @__PURE__ */ jsxs(Text, { children: [
+      /* @__PURE__ */ jsx(Text, { color: "cyan", children: "Command \u203A " }),
+      palette.query,
+      /* @__PURE__ */ jsx(Text, { inverse: true, children: " " })
+    ] }),
+    rows.length === 0 && /* @__PURE__ */ jsx(Text, { dimColor: true, children: " No command matches." }),
+    rows.map((entry, i) => {
+      const selected = first + i === palette.selected;
+      return /* @__PURE__ */ jsxs(Text, { ...selected ? { color: "cyan" } : {}, children: [
+        selected ? "\u276F " : "  ",
+        `/${entry.name}`.padEnd(width + 1),
+        /* @__PURE__ */ jsx(Text, { dimColor: true, children: entry.hint })
+      ] }, entry.name);
+    }),
+    /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+      palette.entries.length > PALETTE_ROWS ? `${palette.selected + 1} of ${palette.entries.length} \xB7 ` : "",
+      "type to filter \xB7 \u2191\u2193 \xB7 Enter picks \xB7 Esc closes"
+    ] })
+  ] });
+}
+function InputLine({ state }) {
+  const { text, cursor } = state.editor;
+  const at = text[cursor];
+  return /* @__PURE__ */ jsx(Box, { marginTop: 1, children: /* @__PURE__ */ jsxs(Text, { children: [
+    /* @__PURE__ */ jsx(Text, { color: "cyan", children: "\u203A " }),
+    text.slice(0, cursor),
+    /* @__PURE__ */ jsx(Text, { inverse: true, children: at === void 0 || at === "\n" ? " " : at }),
+    at === "\n" ? "\n" : "",
+    text.slice(cursor + 1)
+  ] }) });
+}
+function Footer({ state }) {
+  const { model, sandbox, contextPercent, costUsd, mode } = state.status;
+  const parts = [model, sandbox];
+  if (contextPercent !== void 0) parts.push(`context ${contextPercent}%`);
+  if (costUsd !== void 0) parts.push(`$${costUsd.toFixed(costUsd < 0.01 ? 4 : 2)}`);
+  const keys = state.busy ? "Esc stop \xB7 Ctrl-O output" : "\\ then Enter: new line \xB7 Ctrl-G editor \xB7 Ctrl-P commands";
+  return /* @__PURE__ */ jsxs(Text, { children: [
+    mode === "plan" ? /* @__PURE__ */ jsxs(Text, { color: "yellow", bold: true, children: [
+      "PLAN",
+      " "
+    ] }) : null,
+    /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+      parts.join(" \xB7 "),
+      " ",
+      "  ",
+      keys
+    ] })
+  ] });
+}
+var FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+function useSpinner(active) {
+  const [i, setI] = useState(0);
+  useEffect(() => {
+    if (!active) return;
+    const timer = setInterval(() => setI((n) => (n + 1) % FRAMES.length), 80);
+    return () => clearInterval(timer);
+  }, [active]);
+  return FRAMES[i] ?? "\u280B";
+}
+var firstLine = (text) => {
+  const [first = "", ...rest] = text.split("\n");
+  return rest.length > 0 ? `${first} \u2026` : first;
+};
+function onKey(store, state, input, key) {
+  const focus = focusEvent(input);
+  if (focus !== void 0 && !key.ctrl && !key.meta) {
+    store.onFocus(focus);
+    return;
+  }
+  if (key.ctrl && input === "c") {
+    store.interrupt();
+    return;
+  }
+  if (state.palette !== void 0 && state.approval === void 0) {
+    if (key.escape || key.ctrl && input === "p") store.closePalette();
+    else if (key.upArrow) store.movePalette(-1);
+    else if (key.downArrow) store.movePalette(1);
+    else if (key.return) store.pickPalette();
+    else if (key.backspace || key.delete) store.paletteQuery(null);
+    else if (input !== "" && !key.ctrl && !key.meta && !/[\r\n\t]/.test(input))
+      store.paletteQuery(input);
+    return;
+  }
+  if (state.approval !== void 0) {
+    if (!store.takesApprovalKeys()) return;
+    if (state.approval.hunkReview !== void 0) {
+      if (key.leftArrow || key.upArrow) store.moveHunk(-1);
+      else if (key.rightArrow || key.downArrow) store.moveHunk(1);
+      else if (input === "y" || key.return) store.stageHunk(true);
+      else if (input === "n") store.stageHunk(false);
+      else if (input === "a") store.stageAllHunks();
+      else if (input === "d") store.discardAllHunks();
+      else if (key.escape || input === "q") store.closeHunkReview();
+      return;
+    }
+    if (key.upArrow) store.moveApproval(-1);
+    else if (key.downArrow) store.moveApproval(1);
+    else if (key.return) store.choose();
+    else if (/^[1-9]$/.test(input)) {
+      const picked = state.approval.choices[Number(input) - 1];
+      if (picked !== void 0) store.choose(picked.choice);
+    } else if (input === "y") store.choose("once");
+    else if (input === "a") store.choose("session");
+    else if (input === "n" || key.escape) store.choose("deny");
+    else if (input === "h" || input === "p") store.startHunkReview();
+    return;
+  }
+  if (key.ctrl) {
+    const actions = {
+      o: () => store.showLastOutput(),
+      p: () => store.togglePalette(),
+      g: () => store.openEditor(),
+      a: () => store.editLine({ type: "home" }),
+      e: () => store.editLine({ type: "end" }),
+      u: () => store.editLine({ type: "killToStart" }),
+      k: () => store.editLine({ type: "killToEnd" }),
+      w: () => store.editLine({ type: "deleteWord" }),
+      d: () => state.editor.text === "" && !state.busy ? store.exit() : store.editLine({ type: "delete" })
+    };
+    actions[input]?.();
+    return;
+  }
+  if (key.return) {
+    const before = state.editor.text.slice(0, state.editor.cursor);
+    if (key.meta) store.editLine({ type: "insert", text: "\n" });
+    else if (before.endsWith("\\")) {
+      store.editLine({ type: "backspace" });
+      store.editLine({ type: "insert", text: "\n" });
+    } else store.submitLine();
+  } else if (key.escape) {
+    if (state.busy) store.stopTurn();
+    else store.clearQueue();
+  } else if (key.backspace || key.delete) store.editLine({ type: "backspace" });
+  else if (key.leftArrow) store.editLine({ type: key.meta ? "wordLeft" : "left" });
+  else if (key.rightArrow) store.editLine({ type: key.meta ? "wordRight" : "right" });
+  else if (key.upArrow) store.editLine({ type: "up" });
+  else if (key.downArrow) store.editLine({ type: "down" });
+  else if (key.tab) {
+    if (key.shift) store.toggleMode();
+    else store.completeLine();
+  } else if (/[\r\n]/.test(input)) typeAhead(store, input);
+  else if (input !== "" && !key.meta) store.editLine({ type: "insert", text: input });
+}
+function typeAhead(store, chunk) {
+  const parts = chunk.split(/\r\n|\r|\n/);
+  parts.forEach((part, i) => {
+    const last = i === parts.length - 1;
+    if (!last && part.endsWith("\\")) {
+      store.editLine({ type: "insert", text: `${part.slice(0, -1)}
+` });
+      return;
+    }
+    if (part !== "") store.editLine({ type: "insert", text: part });
+    if (!last) store.submitLine();
+  });
+}
+
+// src/cli/chat/inkChat.ts
+async function runInkChat(runtime, approver, setEventTarget, banner, sessionPath, exitNow, firstInput, notifier, focus) {
+  const store = new ChatStore(statusOf(runtime));
+  store.print(banner);
+  if (firstInput !== void 0) store.enqueue(firstInput);
+  approver.current = store;
+  setEventTarget(store);
+  const ink = render(createElement(App, { store }), { exitOnCtrlC: false });
+  const reportFocus = (on) => {
+    if (focus !== void 0) process.stdout.write(on ? FOCUS_REPORTING_ON : FOCUS_REPORTING_OFF);
+  };
+  if (focus !== void 0) store.onFocus = (focused) => focus.update(focused);
+  reportFocus(true);
+  store.externalEdit = (text) => {
+    const stdin = process.stdin;
+    const raw = stdin.isTTY === true && stdin.isRaw;
+    if (raw) stdin.setRawMode(false);
+    stdin.pause();
+    reportFocus(false);
+    try {
+      return editInEditor(text);
+    } finally {
+      if (raw) stdin.setRawMode(true);
+      stdin.resume();
+      focus?.update(true);
+      reportFocus(true);
+      ink.clear();
+    }
+  };
+  const exitClean = () => {
+    ink.unmount();
+    return exitNow();
+  };
+  try {
+    await runChat(runtime, store, sessionPath, exitClean, notifier);
+  } finally {
+    reportFocus(false);
+    ink.unmount();
+  }
+}
+export {
+  runInkChat
+};
+//# sourceMappingURL=inkChat-3J26R24L.js.map