amness 0.0.0-stage → 0.1.2

package/dist/cli/tui/keys.js

@@ -0,0 +1,134 @@
+export const PASTE_ON = "\x1b[?2004h", PASTE_OFF = "\x1b[?2004l";
+/** Mouse reporting: button events + drag motion, SGR encoding (so coordinates beyond 223 work). */
+export const MOUSE_ON = "\x1b[?1000h\x1b[?1002h\x1b[?1006h", MOUSE_OFF = "\x1b[?1006l\x1b[?1002l\x1b[?1000l";
+/** SGR mouse report `ESC [ < b ; x ; y (M|m)` -> event. Coordinates are 0-based cells. */
+function mouseFrom(params, fin) {
+    const [b, x, y] = params.slice(1).split(";").map(Number);
+    if (![b, x, y].every(Number.isFinite))
+        return undefined;
+    const base = { x: x - 1, y: y - 1 };
+    if (b & 4)
+        base.shift = true;
+    if (b & 8)
+        base.alt = true;
+    if (b & 16)
+        base.ctrl = true;
+    if (b & 64)
+        return { ...base, button: "none", action: (b & 1) === 0 ? "wheelup" : "wheeldown" };
+    const button = ["left", "middle", "right", "none"][b & 3];
+    return { ...base, button, action: fin === "m" ? "release" : b & 32 ? (button === "none" ? "move" : "drag") : "press" };
+}
+const mods = (m) => ({ shift: !!((m - 1) & 1) || undefined, alt: !!((m - 1) & 2) || undefined, ctrl: !!((m - 1) & 4) || undefined });
+const clean = (k) => Object.fromEntries(Object.entries(k).filter(([, v]) => v !== undefined));
+const FINAL = { A: "up", B: "down", C: "right", D: "left", H: "home", F: "end", Z: "backtab", P: "f1", Q: "f2", R: "f3", S: "f4" };
+const TILDE = { "1": "home", "2": "insert", "3": "delete", "4": "end", "5": "pageup", "6": "pagedown", "7": "home", "8": "end" };
+export class KeyParser {
+    buf = "";
+    pasting = null;
+    /** Feed raw input; returns the keys that are complete. A trailing lone ESC (or partial sequence) is held until `flush()`. */
+    feed(chunk) {
+        this.buf += chunk;
+        const out = [];
+        for (;;) {
+            if (this.pasting !== null) {
+                const end = this.buf.indexOf("\x1b[201~");
+                if (end < 0) {
+                    this.pasting += this.buf;
+                    this.buf = "";
+                    return out;
+                }
+                out.push({ name: "paste", text: (this.pasting + this.buf.slice(0, end)).replace(/\r\n?/g, "\n") });
+                this.buf = this.buf.slice(end + 6);
+                this.pasting = null;
+                continue;
+            }
+            if (!this.buf)
+                return out;
+            const r = this.one();
+            if (!r)
+                return out; // incomplete: wait for more bytes
+            this.buf = this.buf.slice(r.len);
+            if (r.key)
+                out.push(r.key);
+        }
+    }
+    /** Called after a short idle: whatever is pending (a lone ESC) is a real key press. */
+    flush() {
+        if (this.buf === "\x1b") {
+            this.buf = "";
+            return [{ name: "escape" }];
+        }
+        if (this.pasting === null && this.buf) {
+            const b = this.buf;
+            this.buf = "";
+            return [{ name: "char", text: b }];
+        }
+        return [];
+    }
+    get pending() { return this.buf.length > 0; }
+    one() {
+        const b = this.buf, c = b[0];
+        if (c === "\x1b") {
+            if (b.length === 1)
+                return null;
+            if (b[1] === "[") {
+                const m = b.slice(2).match(/^([0-9;:?<=>]*)([A-Za-z~])/);
+                if (!m)
+                    return b.length < 24 ? null : { len: 1, key: { name: "escape" } };
+                const len = 2 + m[0].length, [p0 = "", p1 = ""] = m[1].split(";"), fin = m[2];
+                if (m[1] === "200" && fin === "~") {
+                    this.pasting = "";
+                    return { len };
+                }
+                if (m[1].startsWith("<") && (fin === "M" || fin === "m")) {
+                    const mouse = mouseFrom(m[1], fin);
+                    return { len, key: mouse ? { name: "mouse", mouse } : undefined };
+                }
+                const mod = p1 ? Number(p1.split(":")[0]) : 1;
+                if (fin === "u") { // kitty keyboard protocol
+                    const code = Number(p0), name = code === 13 ? "enter" : code === 9 ? "tab" : code === 27 ? "escape" : code === 127 ? "backspace" : "char";
+                    return { len, key: clean(name === "char" ? { name, text: String.fromCodePoint(code), ...mods(mod) } : { name, ...mods(mod) }) };
+                }
+                const name = fin === "~" ? TILDE[p0] : FINAL[fin];
+                return { len, key: name ? clean({ name, ...mods(mod) }) : undefined };
+            }
+            if (b[1] === "O") {
+                if (b.length < 3)
+                    return null;
+                const name = FINAL[b[2]];
+                return { len: 3, key: name ? { name } : undefined };
+            }
+            if (b[1] === "\x1b")
+                return { len: 1, key: { name: "escape" } };
+            const inner = this.ctrlOrChar(b[1]); // ESC + key = alt+key
+            return { len: 2, key: inner ? clean({ ...inner, alt: true }) : undefined };
+        }
+        // a run of printable text becomes one key (typed chars arrive one by one; a burst is a paste without bracketed-paste support)
+        const run = b.match(/^[^\x00-\x1f\x7f]+/u);
+        if (run) {
+            const rest = b.slice(run[0].length);
+            if (rest && /^[\r\n]/.test(rest) && run[0].length > 1 && !this.buf.slice(run[0].length).startsWith("\x1b")) {
+                const nl = rest.match(/^[^\x1b]*/)[0]; // text + newlines in one chunk without markers: treat as a paste
+                if (/[^\r\n]/.test(nl) || nl.length > 1)
+                    return { len: run[0].length + nl.length, key: { name: "paste", text: (run[0] + nl).replace(/\r\n?/g, "\n").replace(/\n$/, "") } };
+            }
+            return { len: run[0].length, key: { name: "char", text: run[0] } };
+        }
+        return { len: 1, key: this.ctrlOrChar(c) };
+    }
+    ctrlOrChar(c) {
+        switch (c) {
+            case "\r": return { name: "enter" };
+            case "\n": return { name: "j", ctrl: true };
+            case "\t": return { name: "tab" };
+            case "\x7f": return { name: "backspace" };
+            case "\x08": return { name: "backspace", ctrl: true };
+            case "\x1b": return { name: "escape" };
+            case "\x00": return { name: "space", ctrl: true };
+        }
+        const code = c.codePointAt(0);
+        if (code >= 1 && code <= 26)
+            return { name: String.fromCharCode(96 + code), ctrl: true };
+        return code >= 32 ? { name: "char", text: c } : undefined;
+    }
+}

package/dist/cli/tui/markdown.d.ts

@@ -0,0 +1,37 @@
+import { clipWidth } from "./text.ts";
+export type HlKind = "keyword" | "string" | "number" | "comment" | "plain";
+export type Skin = {
+    bold(s: string): string;
+    italic(s: string): string;
+    strike(s: string): string;
+    code(s: string): string;
+    link(text: string, url: string): string;
+    dim(s: string): string;
+    /** styled lines for a heading (may include an underline rule) */
+    heading(level: number, text: string, width: number): string[];
+    quote(inner: string): string;
+    bullet(marker: string): string;
+    hr(width: number): string;
+    /** a whole fenced code block, already framed and highlighted */
+    codeBlock(lines: string[], lang: string, width: number): string[];
+    table(rows: string[][], width: number): string[];
+    /** hook for `inline` text in table cells etc. */
+    hl(kind: HlKind, text: string): string;
+};
+/** Tiny line-based highlighter: comments, strings, numbers, keywords. `paint` decides how each kind looks. */
+export declare function highlightWith(line: string, lang: string, paint: (k: HlKind, s: string) => string): string;
+export declare const defaultSkin: Skin;
+/** Back-compat: highlight with the default skin's colours. */
+export declare const highlight: (line: string, lang: string) => string;
+/** Inline spans: `code`, **bold**, *italic*, ~~strike~~, [text](url). Code is protected first so nothing inside it is reformatted. */
+export declare function inline(s: string, skin?: Skin): string;
+export declare function renderMarkdown(src: string, width: number, skin?: Skin): string[];
+/**
+ * Split streamed markdown into blocks that are safe to render now (everything up to the last blank line that is not
+ * inside a code fence) and the unfinished remainder, which keeps growing.
+ */
+export declare function takeCompleteBlocks(buf: string): {
+    done: string;
+    rest: string;
+};
+export { clipWidth };

package/dist/cli/tui/markdown.js

@@ -0,0 +1,155 @@
+// Markdown -> ANSI lines for assistant messages, plus block splitting so streamed text can be rendered as it arrives.
+// All styling goes through a Skin, so the same parser serves the inline UI (defaultSkin) and the themed full-screen UI.
+import { bold, cyan, dim, gray, green, magenta, yellow } from "../ui.js";
+import { cellWidth, clipWidth, strip, wrapAnsi } from "./text.js";
+const KW = {
+    js: "const let var function return if else for while do import export from as class new async await try catch finally throw type interface extends implements default switch case break continue null undefined true false this typeof instanceof of in void static public private readonly enum",
+    py: "def class return if elif else for while import from as with try except finally raise lambda None True False and or not in is pass yield async await global self",
+    sh: "if then else elif fi for while do done case esac function in export local echo cd set unset return exit",
+    rs: "fn let mut pub struct enum impl trait use mod match if else for while loop return self Self true false const static ref move async await unsafe where type",
+    go: "func var const type struct interface package import return if else for range switch case default go defer chan map nil true false select break continue",
+    json: "true false null",
+};
+const FAMILY = { js: "js", javascript: "js", jsx: "js", ts: "js", tsx: "js", typescript: "js", mjs: "js", cjs: "js", java: "js", c: "js", cpp: "js", cs: "js", kt: "js", swift: "js",
+    py: "py", python: "py", rb: "py", ruby: "py", sh: "sh", bash: "sh", zsh: "sh", shell: "sh", rs: "rs", rust: "rs", go: "go", json: "json", jsonc: "json" };
+const HASH = new Set(["py", "sh", "rb", "yaml", "yml", "toml", "python", "bash", "zsh", "ruby", "shell", "conf", "dockerfile"]);
+/** Tiny line-based highlighter: comments, strings, numbers, keywords. `paint` decides how each kind looks. */
+export function highlightWith(line, lang, paint) {
+    const fam = FAMILY[lang.toLowerCase()], kw = fam ? new Set(KW[fam].split(" ")) : new Set();
+    const comment = HASH.has(lang.toLowerCase()) ? "#.*$" : fam || !lang ? "\\/\\/.*$" : "$^";
+    const re = new RegExp(`(${comment})|("(?:\\\\.|[^"\\\\])*"|'(?:\\\\.|[^'\\\\])*'|\`(?:\\\\.|[^\`\\\\])*\`)|(\\b\\d[\\d_.]*\\b)|(\\b[A-Za-z_$][\\w$]*\\b)`, "g");
+    let out = "", last = 0;
+    for (let m; (m = re.exec(line));) {
+        out += paint("plain", line.slice(last, m.index));
+        out += m[1] ? paint("comment", m[0]) : m[2] ? paint("string", m[0]) : m[3] ? paint("number", m[0]) : kw.has(m[4]) ? paint("keyword", m[0]) : paint("plain", m[0]);
+        last = m.index + m[0].length;
+        if (m[0] === "")
+            re.lastIndex++;
+    }
+    return out + paint("plain", line.slice(last));
+}
+const red2 = (s) => `\x1b[31m${s}\x1b[0m`;
+export const defaultSkin = {
+    bold, dim, italic: (s) => `\x1b[3m${s}\x1b[23m`, strike: (s) => `\x1b[9m${s}\x1b[29m`, code: cyan, link: (t, u) => `${t} ${dim("(" + u + ")")}`,
+    heading(level, text, width) {
+        const t = text, out = [level === 1 ? bold(cyan(t)) : level === 2 ? bold(cyan(t)) : bold(t)];
+        if (level <= 2)
+            out.push(gray("─".repeat(Math.min(width, Math.max(8, cellWidth(strip(t)))))));
+        return out;
+    },
+    quote: (inner) => gray("▎ ") + dim(inner), bullet: (m) => cyan(m), hr: (w) => gray("─".repeat(Math.min(w, 60))),
+    hl: (k, s) => (k === "comment" ? gray(s) : k === "string" ? green(s) : k === "number" ? yellow(s) : k === "keyword" ? magenta(s) : s),
+    codeBlock(body, lang, width) {
+        const out = [];
+        if (lang)
+            out.push(gray("  ╭─ ") + dim(lang));
+        for (const b of body) {
+            const styled = lang === "diff" ? (b.startsWith("+") ? green(b) : b.startsWith("-") ? red2(b) : b.startsWith("@@") ? cyan(b) : gray(b)) : highlightWith(b, lang, defaultSkin.hl);
+            for (const r of wrapAnsi(styled, width - 4, 2))
+                out.push(gray("  │ ") + r);
+        }
+        if (lang || body.length)
+            out.push(gray("  ╰─"));
+        return out;
+    },
+    table(rows, width) {
+        const n = Math.max(...rows.map((r) => r.length)), widths = Array.from({ length: n }, (_, i) => Math.max(...rows.map((r) => cellWidth(inline(r[i] ?? "", defaultSkin)))));
+        const total = widths.reduce((a, b) => a + b, 0) + 3 * n + 1;
+        if (total > width)
+            return rows.map((r, i) => (i === 0 ? bold(r.join(" | ")) : r.join(" | "))); // too wide: fall back to plain rows
+        const line = (r, head) => "│ " + widths.map((w, i) => { const c = inline(r[i] ?? "", defaultSkin); return (head ? bold(c) : c) + " ".repeat(w - cellWidth(c)); }).join(" │ ") + " │";
+        const rule = (l, m, r) => gray(l + widths.map((w) => "─".repeat(w + 2)).join(m) + r);
+        return [rule("┌", "┬", "┐"), line(rows[0], true), rule("├", "┼", "┤"), ...rows.slice(1).map((r) => line(r, false)), rule("└", "┴", "┘")].map((l) => (l.startsWith("│") ? gray("│") + l.slice(1) : l));
+    },
+};
+/** Back-compat: highlight with the default skin's colours. */
+export const highlight = (line, lang) => highlightWith(line, lang, defaultSkin.hl);
+/** Inline spans: `code`, **bold**, *italic*, ~~strike~~, [text](url). Code is protected first so nothing inside it is reformatted. */
+export function inline(s, skin = defaultSkin) {
+    const codes = [];
+    s = s.replace(/`([^`\n]+)`/g, (_m, c) => `\x00${codes.push(skin.code(c)) - 1}\x00`);
+    s = s.replace(/\[([^\[\]\n]+)\]\((https?:[^)\s]+)\)/g, (_m, t, u) => skin.link(t, u));
+    s = s.replace(/\*\*([^*\n]+)\*\*|__([^_\n]+)__/g, (_m, a, b) => skin.bold(a ?? b));
+    s = s.replace(/(?<![\w*])\*([^*\s][^*\n]*?)\*(?![\w*])|(?<![\w_])_([^_\s][^_\n]*?)_(?![\w_])/g, (_m, a, b) => skin.italic(a ?? b));
+    s = s.replace(/~~([^~\n]+)~~/g, (_m, t) => skin.strike(t));
+    return s.replace(/\x00(\d+)\x00/g, (_m, i) => codes[Number(i)]);
+}
+const isTableSep = (l) => /^\s*\|?\s*:?-{2,}:?\s*(\|\s*:?-{2,}:?\s*)*\|?\s*$/.test(l) && l.includes("-") && l.includes("|");
+const cells = (l) => l.trim().replace(/^\||\|$/g, "").split("|").map((c) => c.trim());
+export function renderMarkdown(src, width, skin = defaultSkin) {
+    const out = [], L = src.replace(/\r\n?/g, "\n").split("\n");
+    const push = (line, indent = 0) => out.push(...wrapAnsi(line, width, indent));
+    let blank = false;
+    for (let i = 0; i < L.length; i++) {
+        const line = L[i];
+        const fence = line.match(/^(\s*)(`{3,}|~{3,})\s*([\w+-]*)/);
+        if (fence) {
+            const lang = fence[3], body = [];
+            for (i++; i < L.length && !/^\s*(`{3,}|~{3,})\s*$/.test(L[i]); i++)
+                body.push(L[i].slice(Math.min(fence[1].length, L[i].length - L[i].trimStart().length)));
+            out.push(...skin.codeBlock(body, lang, width));
+            blank = false;
+            continue;
+        }
+        if (!line.trim()) {
+            if (!blank && out.length)
+                out.push("");
+            blank = true;
+            continue;
+        }
+        blank = false;
+        const h = line.match(/^(#{1,6})\s+(.*?)\s*#*$/);
+        if (h) {
+            for (const r of skin.heading(h[1].length, inline(h[2], skin), width))
+                push(r);
+            continue;
+        }
+        if (/^\s*([-*_])(\s*\1){2,}\s*$/.test(line)) {
+            out.push(skin.hr(width));
+            continue;
+        }
+        if (line.includes("|") && i + 1 < L.length && isTableSep(L[i + 1])) {
+            const rows = [cells(line)];
+            i += 2;
+            for (; i < L.length && L[i].includes("|") && L[i].trim(); i++)
+                rows.push(cells(L[i]));
+            i--;
+            out.push(...skin.table(rows, width));
+            continue;
+        }
+        const q = line.match(/^\s*>\s?(.*)$/);
+        if (q) {
+            push(skin.quote(inline(q[1], skin)), 2);
+            continue;
+        }
+        const li = line.match(/^(\s*)([-*+]|\d+[.)])\s+(.*)$/);
+        if (li) {
+            const depth = Math.floor(li[1].length / 2), marker = /\d/.test(li[2]) ? li[2] : depth % 2 ? "◦" : "•";
+            const pad = "  ".repeat(depth);
+            push(`${pad}${skin.bullet(marker)} ${inline(li[3], skin)}`, pad.length + cellWidth(marker) + 1);
+            continue;
+        }
+        push(inline(line, skin));
+    }
+    while (out.length && out[out.length - 1] === "")
+        out.pop();
+    return out;
+}
+/**
+ * Split streamed markdown into blocks that are safe to render now (everything up to the last blank line that is not
+ * inside a code fence) and the unfinished remainder, which keeps growing.
+ */
+export function takeCompleteBlocks(buf) {
+    const lines = buf.split("\n");
+    let fence = false, cut = -1;
+    for (let i = 0; i < lines.length - 1; i++) { // the last element has no newline yet, so it is never complete
+        if (/^\s*(`{3,}|~{3,})/.test(lines[i]))
+            fence = !fence;
+        if (!fence && !lines[i].trim() && i > 0)
+            cut = i;
+    }
+    if (cut < 0)
+        return { done: "", rest: buf };
+    return { done: lines.slice(0, cut).join("\n"), rest: lines.slice(cut + 1).join("\n") };
+}
+export { clipWidth };

package/dist/cli/tui/mentions.d.ts

@@ -0,0 +1,15 @@
+import { type Image } from "../../src/index.ts";
+export type Attached = {
+    path: string;
+    lines: number;
+    dir?: boolean;
+    image?: boolean;
+};
+/** Turn `@path` mentions into attached file contents (the typed text stays as written). Only paths inside `cwd` are read. */
+export declare function expandMentions(text: string, cwd: string, maxChars?: number): {
+    text: string;
+    attached: Attached[];
+    images: Image[];
+    problems: string[];
+};
+export declare const attachedNote: (a: Attached[]) => string;

package/dist/cli/tui/mentions.js

@@ -0,0 +1,48 @@
+import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
+import { resolve, sep } from "node:path";
+import { MAX_IMAGES, isImagePath, readImage } from "../../src/index.js";
+/** Turn `@path` mentions into attached file contents (the typed text stays as written). Only paths inside `cwd` are read. */
+export function expandMentions(text, cwd, maxChars = 40_000) {
+    const root = resolve(cwd), attached = [], images = [], problems = [], blocks = [], seen = new Set();
+    for (const m of text.matchAll(/(^|\s)@([^\s@]+)/g)) {
+        const rel = m[2].replace(/[.,;:!?)\]]+$/, "");
+        if (seen.has(rel))
+            continue;
+        seen.add(rel);
+        const abs = resolve(root, rel);
+        if ((abs !== root && !abs.startsWith(root + sep)) || !existsSync(abs))
+            continue;
+        try {
+            if (isImagePath(abs) && statSync(abs).isFile()) {
+                if (images.length >= MAX_IMAGES) {
+                    problems.push(`${rel}: only ${MAX_IMAGES} images per message`);
+                    continue;
+                }
+                try {
+                    images.push(readImage(abs));
+                    attached.push({ path: rel, lines: 0, image: true });
+                }
+                catch (e) {
+                    problems.push(e.message);
+                }
+                continue;
+            }
+            if (statSync(abs).isDirectory()) {
+                const names = readdirSync(abs).sort().slice(0, 80);
+                blocks.push(`<directory path="${rel}">\n${names.join("\n")}\n</directory>`);
+                attached.push({ path: rel, lines: names.length, dir: true });
+            }
+            else {
+                const raw = readFileSync(abs, "utf8");
+                if (raw.includes("\0"))
+                    continue;
+                const body = raw.length > maxChars ? raw.slice(0, maxChars) + `\n… [truncated: ${raw.length - maxChars} more characters; use read_file for the rest]` : raw;
+                blocks.push(`<file path="${rel}">\n${body}\n</file>`);
+                attached.push({ path: rel, lines: raw.split("\n").length - (raw.endsWith("\n") ? 1 : 0) });
+            }
+        }
+        catch { /* unreadable: leave the mention as plain text */ }
+    }
+    return { text: blocks.length ? `${text}\n\n<attached>\n${blocks.join("\n")}\n</attached>` : text, attached, images, problems };
+}
+export const attachedNote = (a) => (a.length ? "attached " + a.map((x) => `${x.path} (${x.image ? "image" : x.dir ? `${x.lines} entr${x.lines === 1 ? "y" : "ies"}` : `${x.lines} line${x.lines === 1 ? "" : "s"}`})`).join(", ") : "");

package/dist/cli/tui/modal.d.ts

@@ -0,0 +1,26 @@
+import type { Canvas } from "./canvas.ts";
+import { type Overlay } from "./overlays.ts";
+import type { Theme } from "./themes.ts";
+export type ModalHit = {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+    kind: "option" | "item" | "scrollup" | "scrolldown";
+    index: number;
+};
+export type ModalResult = {
+    hits: ModalHit[];
+    cursor?: {
+        x: number;
+        y: number;
+    };
+    box: {
+        x: number;
+        y: number;
+        w: number;
+        h: number;
+    };
+};
+/** Draw whichever overlay is active as a centered modal. Returns clickable regions. */
+export declare function drawModal(c: Canvas, t: Theme, o: Overlay, frame: number): ModalResult | undefined;

package/dist/cli/tui/modal.js

@@ -0,0 +1,107 @@
+// Modal dialogs for the full-screen UI: a dimmed backdrop, a shadowed card, real previews, clickable choices.
+import { A, mix } from "./ansi.js";
+import { renderDiffRows, langOf } from "./diffview.js";
+import { renderMarkdown, highlightWith } from "./markdown.js";
+import { ChoiceOverlay, InputOverlay, PickerOverlay, TextOverlay } from "./overlays.js";
+import { BOLD, F, chip, fit, split, themeSkin } from "./rich.js";
+import { cellWidth, clipWidth, wrapAnsi } from "./text.js";
+/** Draw whichever overlay is active as a centered modal. Returns clickable regions. */
+export function drawModal(c, t, o, frame) {
+    const dimTo = t.bg === -1 ? 0x000000 : t.bg;
+    const card = (w, h, border, title, icon) => {
+        const x = Math.floor((c.w - w) / 2), y = Math.max(1, Math.floor((c.h - h) / 2.2));
+        c.dim(0, 0, c.w, c.h, 0.62, dimTo, t.text === -1 ? 0xdddddd : t.text, t.bg === -1 ? 0x101010 : t.bg);
+        c.fill(x + 1, y + 1, w, h, mix(t.bg === -1 ? 0x101010 : t.bg, 0x000000, 0.55)); // soft shadow
+        c.box(x, y, w, h, { border, bg: t.surface, style: "round" });
+        if (title)
+            c.ansi(x + 2, y, " " + (icon ? F(border, icon) + " " : "") + BOLD(F(t.text, title)) + " ", {}, w - 4);
+        return { x, y };
+    };
+    const hits = [];
+    if (o instanceof ChoiceOverlay) {
+        const w = Math.min(c.w - 6, 100), inner = w - 4, d = o.detail;
+        const tone = o.title.startsWith("Run") && d?.kind === "command" && d.danger ? t.warn : d?.kind === "plan" ? t.accent2 : t.accent;
+        const rows = [];
+        if (d?.kind === "diff") {
+            const r = renderDiffRows(d.diff, { width: inner, theme: t, lang: langOf(d.path), mode: "stacked", maxRows: 14 });
+            rows.push(...r.rows);
+            if (r.hidden)
+                rows.push(fit(F(t.faint, ` … ${r.hidden} more lines`), inner, t.surface2));
+        }
+        else if (d?.kind === "command") {
+            rows.push(fit(" " + F(t.accent, "$ ") + BOLD(F(t.text, clipWidth(d.cmd, inner - 5))), inner, t.surface2));
+            if (d.cmd.length > inner - 5)
+                for (const l of wrapAnsi(F(t.dim, d.cmd.slice(inner - 5)), inner - 4, 0).slice(0, 4))
+                    rows.push(fit("   " + l, inner, t.surface2));
+            if (d.danger)
+                rows.push(fit(" " + F(t.warn, "⚠ " + d.danger), inner, t.surface2));
+        }
+        else if (d?.kind === "plan") {
+            for (const l of renderMarkdown(d.md, inner - 2, themeSkin(t)).slice(0, 16))
+                rows.push(fit(" " + l, inner, t.surface));
+        }
+        else
+            for (const l of o.body.slice(0, 12))
+                rows.push(fit(" " + l, inner, t.surface));
+        const h = Math.min(c.h - 4, rows.length + o.options.length + 6);
+        const { x, y } = card(w, h, tone, o.title, d?.kind === "diff" ? "✎" : d?.kind === "command" ? "❯" : d?.kind === "plan" ? "☰" : "?");
+        let yy = y + 1;
+        for (const r of rows.slice(0, h - o.options.length - 5)) {
+            c.ansi(x + 2, yy++, r, { bg: t.surface }, inner);
+        }
+        yy++;
+        c.ansi(x + 2, yy++, BOLD(F(t.text, o.question)), { bg: t.surface }, inner);
+        o.options.forEach((opt, i) => {
+            const on = i === o.sel, bg = on ? t.selection : t.surface;
+            c.ansi(x + 2, yy, fit((on ? F(tone, "▶ ") : "  ") + F(on ? tone : t.faint, `${i + 1}`) + "  " + (on ? BOLD(F(t.text, opt.label)) : F(t.text, opt.label)) + (opt.hint ? "  " + F(t.faint, opt.hint) : ""), inner, bg));
+            hits.push({ x: x + 2, y: yy, w: inner, h: 1, kind: "option", index: i });
+            yy++;
+        });
+        c.ansi(x + 2, y + h - 2, F(t.faint, "↑↓ choose  ·  enter confirm  ·  1-9 quick pick  ·  esc cancel"), { bg: t.surface }, inner);
+        return { hits, box: { x, y, w, h } };
+    }
+    if (o instanceof PickerOverlay) {
+        const list = o.visible(), w = Math.min(c.w - 8, 84), inner = w - 4, maxRows = Math.max(3, Math.min(14, c.h - 10, list.length || 1));
+        o.sel = Math.max(0, Math.min(o.sel, list.length - 1));
+        const top = Math.max(0, Math.min(o.sel - Math.floor(maxRows / 2), list.length - maxRows)), shown = list.slice(top, top + maxRows);
+        const h = shown.length + 6, { x, y } = card(w, h, t.accent, o.title, "⌘");
+        const field = fit(" " + F(t.accent, "›") + " " + (o.filter ? F(t.text, o.filter) : F(t.faint, "type to filter…")) + F(t.accent, "▌"), inner, t.surface2);
+        c.ansi(x + 2, y + 1, split(field.replace(/\s+$/, ""), "", inner, t.surface2), {}, inner);
+        c.ansi(x + 2 + inner - 12, y + 1, fit(F(t.faint, `${list.length}/${o.items.length}`.padStart(11)), 12, t.surface2));
+        shown.forEach((it, i) => {
+            const idx = top + i, on = idx === o.sel, bg = on ? t.selection : t.surface, yy = y + 3 + i;
+            c.ansi(x + 2, yy, split((on ? F(t.accent, "▌ ") : "  ") + (on ? BOLD(F(t.text, clipWidth(it.label, inner - 30))) : F(t.text, clipWidth(it.label, inner - 30))), it.hint ? F(t.faint, clipWidth(it.hint, Math.max(8, inner - 34))) + " " : "", inner, bg));
+            hits.push({ x: x + 2, y: yy, w: inner, h: 1, kind: "item", index: idx });
+        });
+        if (!shown.length)
+            c.ansi(x + 2, y + 3, F(t.faint, "  no matches"), { bg: t.surface }, inner);
+        if (top > 0)
+            c.ansi(x + w - 10, y + 2, F(t.faint, `↑ ${top} more`), { bg: t.surface });
+        if (top + maxRows < list.length)
+            c.ansi(x + w - 12, y + h - 3, F(t.faint, `↓ ${list.length - top - maxRows} more`), { bg: t.surface });
+        c.ansi(x + 2, y + h - 2, F(t.faint, "↑↓ move  ·  enter select  ·  esc cancel  ·  click to choose"), { bg: t.surface }, inner);
+        return { hits, box: { x, y, w, h }, cursor: { x: x + 5 + cellWidth(o.filter), y: y + 1 } };
+    }
+    if (o instanceof InputOverlay) {
+        const w = Math.min(c.w - 8, 72), inner = w - 4, h = 7, { x, y } = card(w, h, t.accent, undefined);
+        c.ansi(x + 2, y + 1, BOLD(F(t.text, o.prompt.length > inner ? o.prompt.slice(0, inner - 1) + "…" : o.prompt)), { bg: t.surface }, inner);
+        const shown = o.secret ? "•".repeat(o.ed.text.length) : o.ed.text.split("\n")[0];
+        c.box(x + 2, y + 2, inner, 3, { border: t.accent, bg: t.surface2, style: "round" });
+        c.ansi(x + 4, y + 3, F(t.text, clipWidth(shown, inner - 4)), { bg: t.surface2 }, inner - 4);
+        c.ansi(x + 2, y + h - 2, F(t.faint, o.hint), { bg: t.surface }, inner);
+        return { hits, box: { x, y, w, h }, cursor: { x: x + 4 + Math.min(cellWidth(shown), inner - 5), y: y + 3 } };
+    }
+    if (o instanceof TextOverlay) {
+        const w = Math.min(c.w - 6, 110), inner = w - 4, visible = Math.min(o.lines.length, c.h - 8), h = visible + 4, { x, y } = card(w, h, t.accent2, o.title[0].toUpperCase() + o.title.slice(1), "?");
+        const maxScroll = Math.max(0, o.lines.length - visible);
+        o.scroll = Math.max(0, Math.min(o.scroll, maxScroll));
+        o.lines.slice(o.scroll, o.scroll + visible).forEach((l, i) => c.ansi(x + 2, y + 1 + i, fit(l, inner, t.surface), {}, inner));
+        c.ansi(x + 2, y + h - 2, F(t.faint, (maxScroll ? "↑↓ scroll  ·  " : "") + "any other key closes"), { bg: t.surface }, inner);
+        return { hits, box: { x, y, w, h } };
+    }
+    void A;
+    void highlightWith;
+    void chip;
+    void frame;
+    return undefined;
+}

package/dist/cli/tui/overlays.d.ts

@@ -0,0 +1,98 @@
+import { Editor } from "./editor.ts";
+import type { Key } from "./keys.ts";
+import { type Option } from "./view.ts";
+export type Drawn = {
+    lines: string[];
+    cursor?: {
+        row: number;
+        col: number;
+    };
+};
+export interface Overlay {
+    render(width: number): Drawn;
+    key(k: Key): void;
+}
+/** What a permission prompt is about, in a form the full-screen UI can draw properly (the inline UI uses `body`). */
+export type ChoiceDetail = {
+    kind: "diff";
+    path: string;
+    diff: string;
+} | {
+    kind: "command";
+    cmd: string;
+    danger?: string;
+} | {
+    kind: "plan";
+    md: string;
+} | {
+    kind: "text";
+    text: string;
+};
+/** Standard text-editing keys, shared by the main input and text overlays. Returns true if the key was consumed. */
+export declare function editKey(ed: Editor, k: Key): boolean;
+/** Numbered choices inside a titled box (permission prompts). Resolves with the chosen index, or undefined on Esc. */
+export declare class ChoiceOverlay implements Overlay {
+    sel: number;
+    title: string;
+    body: string[];
+    question: string;
+    options: Option[];
+    done: (i: number | undefined) => void;
+    detail?: ChoiceDetail;
+    constructor(title: string, body: string[], question: string, options: Option[], done: (i: number | undefined) => void, paint?: (s: string) => string, detail?: ChoiceDetail);
+    paint?: (s: string) => string;
+    render(width: number): Drawn;
+    key(k: Key): void;
+}
+export type PickItem<T> = {
+    label: string;
+    value: T;
+    hint?: string;
+};
+/** Filterable list. Type to filter, ↑/↓ to move, enter to pick, esc to cancel. */
+export declare class PickerOverlay<T> implements Overlay {
+    sel: number;
+    filter: string;
+    title: string;
+    items: PickItem<T>[];
+    done: (v: T | undefined) => void;
+    max: number;
+    constructor(title: string, items: PickItem<T>[], done: (v: T | undefined) => void, initial?: number, max?: number);
+    visible(): PickItem<T>[];
+    /** Called whenever the highlighted item changes (live theme preview). */
+    onMove?: (v: T | undefined) => void;
+    /** Choose the i-th visible item (mouse click). */
+    pick(i: number): void;
+    private moved;
+    render(width: number): Drawn;
+    key(k: Key): void;
+}
+/** One-shot text prompt ("what should it do instead?", API key). Esc cancels. */
+export declare class InputOverlay implements Overlay {
+    ed: Editor;
+    prompt: string;
+    secret: boolean;
+    done: (v: string | undefined) => void;
+    hint: string;
+    constructor(prompt: string, done: (v: string | undefined) => void, o?: {
+        secret?: boolean;
+        initial?: string;
+        hint?: string;
+    });
+    render(width: number): Drawn;
+    key(k: Key): void;
+}
+/** Static text (help) closed by any key. */
+export declare class TextOverlay implements Overlay {
+    lines: string[];
+    done: () => void;
+    scroll: number;
+    title: string;
+    constructor(lines: string[], done: () => void, title?: string);
+    render(): Drawn;
+    key(k?: Key): void;
+}
+export declare const helpOverlay: (cmds: {
+    name: string;
+    help: string;
+}[], done: () => void, width: number) => TextOverlay;