amness 0.0.0-stage → 0.1.2

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

@@ -0,0 +1,56 @@
+export type Theme = {
+    name: string;
+    label: string;
+    dark: boolean;
+    bg: number;
+    surface: number;
+    surface2: number;
+    border: number;
+    borderStrong: number;
+    text: number;
+    dim: number;
+    faint: number;
+    accent: number;
+    accent2: number;
+    onAccent: number;
+    ok: number;
+    warn: number;
+    err: number;
+    info: number;
+    addBg: number;
+    addFg: number;
+    addStrong: number;
+    delBg: number;
+    delFg: number;
+    delStrong: number;
+    selection: number;
+    inlineCodeBg: number;
+    inlineCode: number;
+    link: number;
+    syn: {
+        keyword: number;
+        string: number;
+        number: number;
+        comment: number;
+        func: number;
+        type: number;
+        punct: number;
+        plain: number;
+    };
+    gradient: number[];
+    tool: {
+        read: number;
+        edit: number;
+        shell: number;
+        web: number;
+        memory: number;
+        plan: number;
+        explore: number;
+        generic: number;
+    };
+};
+export declare const THEMES: Record<string, Theme>;
+export declare const themeNames: () => string[];
+export declare const getTheme: (name?: string) => Theme;
+export declare const luminance: (c: number) => number;
+export declare const contrast: (a: number, b: number) => number;

package/dist/cli/tui/themes.js

@@ -0,0 +1,80 @@
+// Semantic colour themes for the full-screen UI. Every colour is 0xRRGGBB (or -1 = the terminal's own colour, for the "terminal" theme).
+import { DEFAULT, mix } from "./ansi.js";
+const T = (t) => ({
+    borderStrong: mix(t.border, t.text, 0.25), selection: mix(t.surface2, t.accent, 0.45), inlineCodeBg: t.surface2, inlineCode: t.accent2, link: t.info,
+    tool: { read: t.info, edit: t.warn, shell: t.accent, web: t.accent2, memory: t.ok, plan: 0xff79c6, explore: 0xff9e64, generic: t.dim }, ...t,
+});
+export const THEMES = {
+    aurora: T({
+        name: "aurora", label: "Aurora (default)", dark: true,
+        bg: 0x0d1017, surface: 0x131824, surface2: 0x1a2133, border: 0x28324a,
+        text: 0xdbe2ef, dim: 0x93a0b8, faint: 0x5f6c86, accent: 0x8b7bff, accent2: 0x35d0e6, onAccent: 0x0d1017,
+        ok: 0x45d9a0, warn: 0xf6b04c, err: 0xff6b7a, info: 0x62aaff,
+        addBg: 0x0f2c21, addFg: 0x7ceab5, addStrong: 0x185a3f, delBg: 0x34161f, delFg: 0xff9aa6, delStrong: 0x6b2433,
+        syn: { keyword: 0xc4a7ff, string: 0xa6e07a, number: 0xffa56b, comment: 0x62708c, func: 0x7db4ff, type: 0xffd479, punct: 0x8fe1f2, plain: 0xdbe2ef },
+        gradient: [0x8b7bff, 0x35b6ff, 0x35e6b0],
+    }),
+    "tokyo-night": T({
+        name: "tokyo-night", label: "Tokyo Night", dark: true,
+        bg: 0x16161e, surface: 0x1a1b26, surface2: 0x24283b, border: 0x3b4261,
+        text: 0xc0caf5, dim: 0x9aa5ce, faint: 0x6b749b, accent: 0x7aa2f7, accent2: 0xbb9af7, onAccent: 0x16161e,
+        ok: 0x9ece6a, warn: 0xe0af68, err: 0xf7768e, info: 0x7dcfff,
+        addBg: 0x1c2f26, addFg: 0x9ece6a, addStrong: 0x2b5a3a, delBg: 0x37202b, delFg: 0xf7768e, delStrong: 0x6a2c3d,
+        syn: { keyword: 0xbb9af7, string: 0x9ece6a, number: 0xff9e64, comment: 0x6b749b, func: 0x7aa2f7, type: 0x2ac3de, punct: 0x89ddff, plain: 0xc0caf5 },
+        gradient: [0x7aa2f7, 0xbb9af7, 0x7dcfff],
+    }),
+    catppuccin: T({
+        name: "catppuccin", label: "Catppuccin Mocha", dark: true,
+        bg: 0x11111b, surface: 0x181825, surface2: 0x313244, border: 0x45475a,
+        text: 0xcdd6f4, dim: 0xa6adc8, faint: 0x6c7086, accent: 0xcba6f7, accent2: 0x89dceb, onAccent: 0x11111b,
+        ok: 0xa6e3a1, warn: 0xf9e2af, err: 0xf38ba8, info: 0x89b4fa,
+        addBg: 0x1d2e25, addFg: 0xa6e3a1, addStrong: 0x2f5a3e, delBg: 0x36212b, delFg: 0xf38ba8, delStrong: 0x6a3040,
+        syn: { keyword: 0xcba6f7, string: 0xa6e3a1, number: 0xfab387, comment: 0x6c7086, func: 0x89b4fa, type: 0xf9e2af, punct: 0x94e2d5, plain: 0xcdd6f4 },
+        gradient: [0xcba6f7, 0x89b4fa, 0x94e2d5],
+    }),
+    gruvbox: T({
+        name: "gruvbox", label: "Gruvbox Dark", dark: true,
+        bg: 0x1d2021, surface: 0x282828, surface2: 0x3c3836, border: 0x504945,
+        text: 0xebdbb2, dim: 0xbdae93, faint: 0x7c6f64, accent: 0xfabd2f, accent2: 0x8ec07c, onAccent: 0x1d2021,
+        ok: 0xb8bb26, warn: 0xfe8019, err: 0xfb4934, info: 0x83a598,
+        addBg: 0x2b3017, addFg: 0xb8bb26, addStrong: 0x4a5a1c, delBg: 0x3c1e1b, delFg: 0xfb7a68, delStrong: 0x6e2b25,
+        syn: { keyword: 0xfb5c4a, string: 0xb8bb26, number: 0xd3869b, comment: 0x928374, func: 0xfabd2f, type: 0x83a598, punct: 0x8ec07c, plain: 0xebdbb2 },
+        gradient: [0xfabd2f, 0xfe8019, 0xfb4934],
+    }),
+    nord: T({
+        name: "nord", label: "Nord", dark: true,
+        bg: 0x242933, surface: 0x2e3440, surface2: 0x3b4252, border: 0x4c566a,
+        text: 0xe5e9f0, dim: 0xa7b1c2, faint: 0x7d889c, accent: 0x88c0d0, accent2: 0xb48ead, onAccent: 0x242933,
+        ok: 0xa3be8c, warn: 0xebcb8b, err: 0xd9707a, info: 0x81a1c1,
+        addBg: 0x27382f, addFg: 0xa3be8c, addStrong: 0x3c5a45, delBg: 0x3d2c33, delFg: 0xe08a93, delStrong: 0x6b3d47,
+        syn: { keyword: 0x81a1c1, string: 0xa3be8c, number: 0xc29bbb, comment: 0x7d889c, func: 0x88c0d0, type: 0xebcb8b, punct: 0x8fbcbb, plain: 0xe5e9f0 },
+        gradient: [0x88c0d0, 0x81a1c1, 0xb48ead],
+    }),
+    daylight: T({
+        name: "daylight", label: "Daylight (light)", dark: false,
+        bg: 0xfbfbfd, surface: 0xf1f3f9, surface2: 0xe6eaf4, border: 0xcdd3e2,
+        text: 0x1f2430, dim: 0x4f5970, faint: 0x78819a, accent: 0x5b4bdb, accent2: 0x0b7d92, onAccent: 0xffffff,
+        ok: 0x1a7f4b, warn: 0x9a5700, err: 0xc4283c, info: 0x1d62c9,
+        addBg: 0xdcf3e5, addFg: 0x14663a, addStrong: 0xb3e3c6, delBg: 0xfde1e5, delFg: 0xa8202f, delStrong: 0xf6b5bd,
+        syn: { keyword: 0x7a3ec7, string: 0x2a7a2a, number: 0xb4530a, comment: 0x6f7993, func: 0x1d5fc4, type: 0x8a6100, punct: 0x096f82, plain: 0x1f2430 },
+        gradient: [0x5b4bdb, 0x1d62c9, 0x0b7d92],
+    }),
+    /** Uses the terminal's own background and palette: no painted surfaces, structure comes from borders only. */
+    terminal: T({
+        name: "terminal", label: "Terminal (transparent)", dark: true,
+        bg: DEFAULT, surface: DEFAULT, surface2: DEFAULT, border: 0x1000000 + 8,
+        text: DEFAULT, dim: 0x1000000 + 7, faint: 0x1000000 + 8, accent: 0x1000000 + 13, accent2: 0x1000000 + 14, onAccent: 0x1000000 + 0,
+        ok: 0x1000000 + 10, warn: 0x1000000 + 11, err: 0x1000000 + 9, info: 0x1000000 + 12,
+        addBg: DEFAULT, addFg: 0x1000000 + 10, addStrong: DEFAULT, delBg: DEFAULT, delFg: 0x1000000 + 9, delStrong: DEFAULT,
+        syn: { keyword: 0x1000000 + 13, string: 0x1000000 + 10, number: 0x1000000 + 11, comment: 0x1000000 + 8, func: 0x1000000 + 12, type: 0x1000000 + 14, punct: 0x1000000 + 6, plain: DEFAULT },
+        gradient: [0x1000000 + 13, 0x1000000 + 12, 0x1000000 + 14],
+        tool: { read: 0x1000000 + 12, edit: 0x1000000 + 11, shell: 0x1000000 + 13, web: 0x1000000 + 14, memory: 0x1000000 + 10, plan: 0x1000000 + 13, explore: 0x1000000 + 9, generic: 0x1000000 + 7 },
+        selection: 0x1000000 + 4,
+    }),
+};
+export const themeNames = () => Object.keys(THEMES);
+export const getTheme = (name) => THEMES[name ?? ""] ?? THEMES.aurora;
+/** WCAG relative luminance / contrast ratio, used by tests to keep every theme readable. */
+const lin = (v) => { v /= 255; return v <= 0.03928 ? v / 12.92 : ((v + 0.055) / 1.055) ** 2.4; };
+export const luminance = (c) => 0.2126 * lin((c >> 16) & 255) + 0.7152 * lin((c >> 8) & 255) + 0.0722 * lin(c & 255);
+export const contrast = (a, b) => { const [x, y] = [luminance(a), luminance(b)].sort((p, q) => q - p); return (x + 0.05) / (y + 0.05); };

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

@@ -0,0 +1,39 @@
+import type { Message } from "../../src/index.ts";
+import { type RGB } from "./theme.ts";
+export type ContextMap = {
+    parts: {
+        key: "system" | "you" | "assistant" | "tools" | "defs";
+        label: string;
+        tokens: number;
+        color: RGB;
+    }[];
+    total: number;
+    biggest?: {
+        name: string;
+        tokens: number;
+    };
+};
+/**
+ * Attribute the conversation's size to who produced it. Sizes are character-based estimates; when the API told us the real prompt size
+ * (`promptTokens`) the estimates are scaled so the total matches it.
+ */
+export declare function contextMap(messages: Message[], promptTokens?: number, toolDefChars?: number): ContextMap;
+export type ReportInput = {
+    model: string;
+    messages: Message[];
+    usage: {
+        prompt: number;
+        completion: number;
+        calls: number;
+        cached?: number;
+        reasoning?: number;
+    };
+    series: number[];
+    lastPrompt: number;
+    turnTokens: number;
+    turnBudget: number;
+    width: number; /** size of the tool definitions sent with every request */
+    toolDefChars?: number;
+};
+/** The /tokens panel. */
+export declare function tokenReport(r: ReportInput): string[];

package/dist/cli/tui/tokens.js

@@ -0,0 +1,71 @@
+import { contextWindow, estimateCost, fmtCost, fmtTokens, priceOf } from "./pricing.js";
+import { bold, dimmed, fg, gauge, gaugeColor, palette, sparkline, stackedBar } from "./theme.js";
+const approx = (chars) => Math.ceil(chars / 3.6);
+/**
+ * Attribute the conversation's size to who produced it. Sizes are character-based estimates; when the API told us the real prompt size
+ * (`promptTokens`) the estimates are scaled so the total matches it.
+ */
+export function contextMap(messages, promptTokens = 0, toolDefChars = 0) {
+    const chars = { system: 0, you: 0, assistant: 0, tools: 0 };
+    const names = new Map();
+    let biggest;
+    for (const m of messages) {
+        const calls = (m.tool_calls ?? []).reduce((n, c) => n + c.function.arguments.length + c.function.name.length, 0);
+        if (m.role === "system")
+            chars.system += m.content?.length ?? 0;
+        else if (m.role === "user")
+            chars.you += m.content?.length ?? 0;
+        else if (m.role === "assistant") {
+            chars.assistant += (m.content?.length ?? 0) + calls;
+            for (const c of m.tool_calls ?? [])
+                names.set(c.id, c.function.name);
+        }
+        else {
+            const n = m.content?.length ?? 0;
+            chars.tools += n;
+            if (!biggest || n > biggest.chars)
+                biggest = { name: names.get(m.tool_call_id ?? "") ?? "tool", chars: n };
+        }
+    }
+    const est = { system: approx(chars.system), you: approx(chars.you), assistant: approx(chars.assistant), tools: approx(chars.tools), defs: approx(toolDefChars) };
+    const sum = est.system + est.you + est.assistant + est.tools + est.defs, k = promptTokens && sum ? promptTokens / sum : 1;
+    const parts = [
+        { key: "tools", label: "tool output", tokens: Math.round(est.tools * k), color: palette.read },
+        { key: "assistant", label: "assistant", tokens: Math.round(est.assistant * k), color: palette.edit },
+        { key: "you", label: "you", tokens: Math.round(est.you * k), color: palette.memory },
+        { key: "system", label: "system", tokens: Math.round(est.system * k), color: palette.shell },
+        { key: "defs", label: "tool defs", tokens: Math.round(est.defs * k), color: palette.web }, // the JSON schemas of every tool ride along on each request
+    ];
+    return { parts, total: parts.reduce((n, p) => n + p.tokens, 0), biggest: biggest ? { name: biggest.name, tokens: Math.round(approx(biggest.chars) * k) } : undefined };
+}
+/** The /tokens panel. */
+export function tokenReport(r) {
+    const win = contextWindow(r.model), used = r.lastPrompt || contextMap(r.messages, 0, r.toolDefChars).total, pct = Math.min(100, Math.round((used / win) * 100));
+    const map = contextMap(r.messages, r.lastPrompt, r.toolDefChars), barW = Math.max(16, Math.min(48, r.width - 12));
+    const sb = stackedBar(map.parts.map((p) => ({ label: p.label, value: p.tokens, color: p.color })), barW);
+    const cached = r.usage.cached ?? 0, reasoning = r.usage.reasoning ?? 0;
+    const cost = estimateCost(r.model, r.usage.prompt, r.usage.completion, cached), p = priceOf(r.model);
+    const perReq = r.usage.calls ? Math.round(r.usage.prompt / r.usage.calls) : 0;
+    const lines = [
+        "", `  ${bold("Tokens")}`,
+        `  ${dimmed("context window")}  ${gauge(pct, 20)} ${fg(gaugeColor(pct), pct + "%")}  ${dimmed(`${fmtTokens(used)} of ${fmtTokens(win)}`)}`,
+        `  ${dimmed("what fills it ")}  ${sb.bar}`, `                  ${sb.legend.join("   ")}`,
+    ];
+    if (map.biggest && map.biggest.tokens > 800)
+        lines.push(`  ${dimmed("biggest item   ")}  ${fg(palette.warn, "◆")} one ${map.biggest.name} result is ~${fmtTokens(map.biggest.tokens)} tokens`);
+    if (r.series.length)
+        lines.push(`  ${dimmed("prompt size/req")}  ${sparkline(r.series, 32)}  ${dimmed(`${r.series.length} requests, latest ${fmtTokens(r.series.at(-1))}`)}`);
+    if (cached)
+        lines.push(`  ${dimmed("prompt cache   ")}  ${fg(palette.ok, Math.round((cached / Math.max(1, r.usage.prompt)) * 100) + "%")} of input served from cache ${dimmed(`(${fmtTokens(cached)} tokens at ~10% price)`)}`);
+    if (reasoning)
+        lines.push(`  ${dimmed("reasoning      ")}  ${fmtTokens(reasoning)} hidden reasoning tokens ${dimmed(`(${Math.round((reasoning / Math.max(1, r.usage.completion)) * 100)}% of output)`)}`);
+    lines.push(`  ${dimmed("this chat      ")}  ${fmtTokens(r.usage.prompt)} in · ${fmtTokens(r.usage.completion)} out · ${r.usage.calls} request${r.usage.calls === 1 ? "" : "s"}${perReq ? dimmed(` (avg ${fmtTokens(perReq)} in)`) : ""}`, `  ${dimmed("est. cost      ")}  ${cost === null ? dimmed("unknown for this model") : bold(fmtCost(cost))}${p ? dimmed(`  at $${p[1]}/$${p[2]} per M tokens${cached ? ", cached input at 10%" : ""}`) : ""}`);
+    if (r.turnBudget && r.turnTokens) {
+        const b = Math.min(100, Math.round((r.turnTokens / r.turnBudget) * 100));
+        lines.push(`  ${dimmed("turn budget    ")}  ${gauge(b, 20)} ${fmtTokens(r.turnTokens)} of ${fmtTokens(r.turnBudget)}`);
+    }
+    const advice = pct >= 85 ? `${fg(palette.err, "!")} nearly full: run /compact now, or /clear to start fresh` : pct >= 60 ? `${fg(palette.warn, "↯")} getting full: /compact will summarise and free most of it` : map.parts[0].key === "tools" && map.parts[0].tokens > used * 0.5 ? `${fg(palette.read, "i")} mostly tool output: ask for narrower reads (line ranges, grep) to keep it lean` : "";
+    if (advice)
+        lines.push("", `  ${advice}`);
+    return lines;
+}

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

@@ -0,0 +1,60 @@
+export declare const toolLabel: (name: string) => string;
+/** Short, human description of a tool call's arguments. */
+export declare function argSummary(name: string, raw: string): string;
+export declare const toolCall: (name: string, raw: string) => string;
+export declare const toolHeader: (name: string, raw: string, ok?: boolean | null, agent?: string) => string;
+export declare const isFailure: (result: string) => boolean;
+/** Result lines shown under a tool header (the "⎿" block). */
+export declare function toolResult(name: string, raw: string, result: string, width: number): string[];
+/** Unified diff with line numbers and +/- colouring, like an editor's change view. */
+export declare function renderDiff(diff: string, width: number, maxLines?: number): string[];
+export declare const editSummary: (e: {
+    created: boolean;
+    added: number;
+    removed: number;
+}) => string;
+export declare function userMessage(text: string, width: number, note?: string): string[];
+/** One assistant block: first block of a message gets the "●" marker; later blocks are separated by a blank line. */
+export declare function assistantBlock(md: string, width: number, first: boolean): string[];
+export declare function todoList(todos: {
+    content: string;
+    status: string;
+}[], width: number): string[];
+export type Option = {
+    label: string;
+    hint?: string;
+};
+/** Numbered, arrow-selectable option list used by approval prompts and pickers. */
+export declare function optionList(opts: Option[], sel: number): string[];
+export declare function framed(title: string, body: string[], width: number, paint?: (s: string) => string): string[];
+export type FooterInfo = {
+    mode: string;
+    model: string;
+    provider?: string;
+    ctxPct: number | null;
+    cost: string;
+    branch?: string;
+    hint?: string; /** no left-hand hints at all (a prompt owns the screen) */
+    quiet?: boolean; /** transient message, shown in place of the hint without hiding the mode */
+    notice?: string;
+    running?: boolean;
+    queued?: number;
+};
+export declare function footer(f: FooterInfo, width: number): string;
+export declare const COMMAND_HELP_WIDTH = 14;
+export declare function helpLines(cmds: {
+    name: string;
+    help: string;
+}[], width: number): string[];
+export declare function welcome(o: {
+    version: string;
+    model: string;
+    provider?: string;
+    cwd: string;
+    branch?: string;
+    notes: number;
+    verify?: string;
+    mode: string;
+    resumed?: string;
+    tip?: string;
+}, width: number): string[];

package/dist/cli/tui/view.js

@@ -0,0 +1,178 @@
+// Pure rendering helpers for the chat UI: every function returns terminal lines and never touches the terminal.
+import { bold, cyan, dim, gray, green, red, yellow } from "../ui.js";
+import { renderMarkdown } from "./markdown.js";
+import { brandOf, fg, gauge, gaugeColor, logo, toolColor } from "./theme.js";
+import { cellWidth, clipAnsi, clipWidth, strip, wrapAnsi } from "./text.js";
+const ONE = (s, n) => { const l = s.replace(/\s+/g, " ").trim(); return cellWidth(l) > n ? clipWidth(l, n - 1) + "…" : l; };
+const NAMES = { read_file: "Read", list_files: "List", grep: "Search", write_file: "Write", edit_file: "Update", apply_patch: "Patch", sh: "Bash", memory_save: "Memory", memory_search: "Memory",
+    memory_forget: "Memory", web_search: "WebSearch", fetch_url: "Fetch", task: "Explore", todo_write: "Todos", exit_plan_mode: "Plan", create_tool: "CreateTool", finish: "Finish" };
+export const toolLabel = (name) => NAMES[name] ?? name;
+/** Short, human description of a tool call's arguments. */
+export function argSummary(name, raw) {
+    let a;
+    try {
+        a = JSON.parse(raw);
+    }
+    catch {
+        return ONE(raw, 70);
+    }
+    switch (name) {
+        case "sh": return ONE(a.cmd ?? "", 90);
+        case "read_file": return a.path + (a.start ? `:${a.start}${a.end ? "-" + a.end : ""}` : "");
+        case "grep": return `"${ONE(a.pattern ?? "", 40)}"${a.path ? " in " + a.path : ""}`;
+        case "list_files": return a.path ?? ".";
+        case "task": return ONE(a.description ?? "", 70);
+        case "apply_patch": {
+            const n = (String(a.patch ?? "").match(/^(?:\*\*\* (?:Update|Add|Delete) File:|\+\+\+ )/gm) ?? []).length;
+            return `${n || "?"} file${n === 1 ? "" : "s"}`;
+        }
+        case "web_search": return ONE(a.query ?? "", 70);
+        case "fetch_url": return ONE(a.url ?? "", 80);
+        case "memory_save": return a.name ?? "";
+        case "todo_write": return `${a.todos?.length ?? 0} items`;
+        case "exit_plan_mode": return "";
+    }
+    const named = a.path ?? a.name ?? a.query ?? a.description;
+    if (typeof named === "string")
+        return ONE(named, 80);
+    const entries = Object.entries(a ?? {}); // unknown tool (e.g. from MCP): show its arguments compactly
+    if (entries.length === 1)
+        return ONE(typeof entries[0][1] === "string" ? entries[0][1] : JSON.stringify(entries[0][1]), 80);
+    return ONE(entries.map(([k, v]) => `${k}=${typeof v === "string" ? v : JSON.stringify(v)}`).join(", "), 80);
+}
+export const toolCall = (name, raw) => `${bold(toolLabel(name))}${dim("(")}${argSummary(name, raw)}${dim(")")}`;
+export const toolHeader = (name, raw, ok = null, agent) => `${agent && agent !== "lead" ? dim("  │ ") : ""}${ok === false ? red("●") : fg(toolColor(name), "●")} ${toolCall(name, raw)}`; // colour says what kind of work it was; red says it failed
+export const isFailure = (result) => /^(ERROR|DENIED|REJECTED)/.test(result) || /^exit=(?!0\b)/.test(result);
+const more = (n, hint = true) => dim(`… +${n} more line${n > 1 ? "s" : ""}${hint ? " (ctrl+o to view all)" : ""}`);
+const hang = (lines, first = "  ⎿  ", rest = "     ") => lines.map((l, i) => dim(i ? rest : first) + l);
+/** Result lines shown under a tool header (the "⎿" block). */
+export function toolResult(name, raw, result, width) {
+    const body = result.split("\n"), w = width - 5;
+    const lines = result.trim() ? body : [];
+    if (isFailure(result)) {
+        const shown = body.filter(Boolean).slice(0, 6).map((l) => red(ONE(l, w)));
+        return hang([...shown, ...(body.filter(Boolean).length > 6 ? [more(body.filter(Boolean).length - 6)] : [])]);
+    }
+    switch (name) {
+        case "read_file": return hang([dim(`Read ${lines.length} line${lines.length === 1 ? "" : "s"}`)]);
+        case "list_files": return hang([dim(`${lines.filter(Boolean).length} file${lines.length === 1 ? "" : "s"}`)]);
+        case "grep": {
+            if (/^no matches/.test(result))
+                return hang([dim("No matches")]);
+            const hits = lines.filter(Boolean), files = new Set(hits.map((l) => l.split(":")[0]));
+            return hang([dim(`${hits.length} match${hits.length === 1 ? "" : "es"} in ${files.size} file${files.size === 1 ? "" : "s"}`)]);
+        }
+        case "sh": {
+            const out = body.slice(1).filter((l, i, a) => l.trim() || i < a.length - 1), shown = out.slice(0, 8).map((l) => gray(ONE(l, w)));
+            return hang(out.length ? [...shown, ...(out.length > 8 ? [more(out.length - 8)] : [])] : [dim("(no output)")]);
+        }
+        case "write_file":
+        case "edit_file": return []; // the diff block is rendered from the edit event
+        case "memory_save":
+        case "memory_forget": return hang([dim(ONE(result, w))]);
+        case "web_search": return hang([dim(`${(result.match(/^\d+\./gm) ?? []).length} results`)]);
+        case "fetch_url": return hang([dim(`${result.length.toLocaleString()} characters`)]);
+        case "task": {
+            const t = result.split("\n").filter(Boolean);
+            return hang([...t.slice(0, 8).map((l) => ONE(l, w)), ...(t.length > 8 ? [more(t.length - 8)] : [])]);
+        }
+        case "todo_write":
+        case "exit_plan_mode": return [];
+    }
+    const t = lines.filter(Boolean);
+    return t.length ? hang([ONE(t[0], w), ...(t.length > 1 ? [more(t.length - 1)] : [])]) : [];
+}
+/** Unified diff with line numbers and +/- colouring, like an editor's change view. */
+export function renderDiff(diff, width, maxLines = 24) {
+    const out = [];
+    let a = 0, b = 0;
+    const body = diff.split("\n").filter((l) => !/^(---|\+\+\+)/.test(l));
+    const numW = String(Math.max(a, ...body.map((l) => { const m = l.match(/^@@ -(\d+),?\d* \+(\d+)/); return m ? Math.max(+m[1], +m[2]) + 400 : 0; })) || 1).length;
+    for (const l of body) {
+        const h = l.match(/^@@ -(\d+),?\d* \+(\d+)/);
+        if (h) {
+            a = +h[1];
+            b = +h[2];
+            if (out.length)
+                out.push(dim("      ⋮"));
+            continue;
+        }
+        if (!l)
+            continue;
+        const t = l[0], text = l.slice(1), room = Math.max(10, width - numW - 8);
+        const shown = cellWidth(text) > room ? clipWidth(text, room - 1) + "…" : text;
+        if (t === "+")
+            out.push(green(`${String(b).padStart(numW)} + ${shown}`)), b++;
+        else if (t === "-")
+            out.push(red(`${String(a).padStart(numW)} - ${shown}`)), a++;
+        else
+            out.push(gray(`${String(b).padStart(numW)}   ${shown}`)), a++, b++;
+    }
+    const clipped = out.length > maxLines ? [...out.slice(0, maxLines), more(out.length - maxLines)] : out;
+    return clipped.map((l) => "     " + l);
+}
+export const editSummary = (e) => e.created ? `Created with ${e.added} line${e.added === 1 ? "" : "s"}` : `Added ${e.added} line${e.added === 1 ? "" : "s"}, removed ${e.removed} line${e.removed === 1 ? "" : "s"}`;
+export function userMessage(text, width, note = "") {
+    const rows = text.split("\n").flatMap((l, i) => wrapAnsi(l, width - 2, 0).map((r, j) => (i === 0 && j === 0 ? bold(cyan("❯ ")) : "  ") + bold(r)));
+    return ["", ...rows, ...(note ? ["  " + dim(note)] : [])];
+}
+/** One assistant block: first block of a message gets the "●" marker; later blocks are separated by a blank line. */
+export function assistantBlock(md, width, first) {
+    const rows = renderMarkdown(md, width - 2);
+    if (!rows.length)
+        return [];
+    return [...(first ? [] : [""]), ...rows.map((r, i) => (first && i === 0 ? "● " : "  ") + r)].map((r, i) => (first && i === 0 ? r.replace("●", bold("●")) : r));
+}
+export function todoList(todos, width) {
+    if (!todos.length)
+        return [];
+    const done = todos.filter((t) => t.status === "done").length;
+    return [dim(`  ☰ Todos ${done}/${todos.length}`), ...todos.slice(0, 10).map((t) => "    " + (t.status === "done" ? green("☒ ") + dim(strike(ONE(t.content, width - 8))) : t.status === "in_progress" ? yellow("▶ ") + bold(ONE(t.content, width - 8)) : "☐ " + ONE(t.content, width - 8))),
+        ...(todos.length > 10 ? [dim(`    … +${todos.length - 10} more`)] : [])];
+}
+const strike = (s) => `\x1b[9m${s}\x1b[29m`;
+/** Numbered, arrow-selectable option list used by approval prompts and pickers. */
+export function optionList(opts, sel) {
+    return opts.map((o, i) => `${i === sel ? cyan("❯") : " "} ${i === sel ? bold(cyan(`${i + 1}.`)) : dim(`${i + 1}.`)} ${i === sel ? bold(o.label) : o.label}${o.hint ? "  " + dim(o.hint) : ""}`);
+}
+export function framed(title, body, width, paint = cyan) {
+    const inner = width - 4, rows = body.flatMap((l) => wrapAnsi(l, inner));
+    const top = paint("╭─ ") + bold(title) + paint(" " + "─".repeat(Math.max(0, width - 5 - cellWidth(strip(title)))) + "╮");
+    return [top, ...rows.map((r) => paint("│ ") + r + " ".repeat(Math.max(0, inner - cellWidth(r))) + paint(" │")), paint("╰" + "─".repeat(width - 2) + "╯")];
+}
+const MODE_LABEL = { default: "", acceptEdits: "⏵⏵ accept edits on", plan: "⏸ plan mode (read-only)", yolo: "⚠ yolo: no permission prompts" };
+export function footer(f, width) {
+    const m = MODE_LABEL[f.mode] ?? f.mode;
+    const left = [m ? (f.mode === "yolo" ? red(m) : f.mode === "plan" ? yellow(m) : green(m)) : "", f.notice ? yellow(f.notice) : f.hint ? dim(f.hint) : ""].filter(Boolean).join(dim("  ·  ")) || (f.quiet ? "" : dim("? for shortcuts"));
+    const brand = brandOf(f.model, f.provider), ctx = f.ctxPct !== null ? `${gauge(f.ctxPct, 8)} ${fg(gaugeColor(f.ctxPct), f.ctxPct + "%")}` : "";
+    const right = [f.queued ? yellow(`${f.queued} queued`) : "", f.branch ? dim("⎇ " + f.branch) : "", `${fg(brand.color, brand.icon)} ${dim(f.model)}`, ctx, f.cost ? dim(f.cost) : ""].filter(Boolean).join(dim(" · "));
+    const avail = width - cellWidth(right) - 4; // the right-hand info (queue, model, context) wins over the hints on the left
+    if (avail < 8)
+        return " " + clipAnsi(left, width - 2);
+    const L = cellWidth(left) > avail ? clipAnsi(left, avail) : left;
+    return " " + L + " ".repeat(Math.max(2, width - cellWidth(L) - cellWidth(right) - 2)) + right;
+}
+export const COMMAND_HELP_WIDTH = 14;
+export function helpLines(cmds, width) {
+    const keys = [["Enter", "send · queue while working"], ["\\ + Enter / Alt+Enter / Ctrl+J", "new line"], ["Esc", "interrupt · close popup · Esc Esc rewind"],
+        ["Ctrl+C", "interrupt · clear input · exit (twice)"], ["Shift+Tab", "cycle permissions: ask → accept edits → plan"], ["↑ ↓", "history · menu"], ["Tab", "accept suggestion"],
+        ["@path", "mention a file"], ["!cmd", "run a command now (for example !ls)"], ["#note", "remember a note"], ["Ctrl+P", "command palette"], ["Alt+M", "switch model"], ["Ctrl+O", "full transcript"], ["Ctrl+L", "redraw"], ["drag / dbl / triple click", "select and copy (Shift+drag: terminal selection)"], ["/copy", "copy the last reply (code · all)"]];
+    return [bold("Keys"), ...keys.map(([k, d]) => `  ${cyan(k.padEnd(31))} ${dim(d)}`), "", bold("Commands"),
+        ...cmds.map((c) => `  ${cyan(("/" + c.name).padEnd(COMMAND_HELP_WIDTH))} ${dim(c.help)}`)].flatMap((l) => wrapAnsi(l, width - 2, 33));
+}
+export function welcome(o, width) {
+    const home = process.env.HOME ?? "";
+    let cwd = home && o.cwd.startsWith(home) ? "~" + o.cwd.slice(home.length) : o.cwd;
+    const room = Math.min(width, 66) - 4 - 9 - (o.branch ? o.branch.length + 4 : 0); // keep "project  path  ⎇ branch" on one line
+    if (cellWidth(cwd) > room)
+        cwd = "…" + cwd.slice(cwd.length - Math.max(8, room - 1));
+    const b = brandOf(o.model, o.provider);
+    const body = [
+        ...logo(o.version), "",
+        `${dim("model")}    ${fg(b.color, b.icon)} ${bold(o.model)}`, `${dim("project")}  ${cwd}${o.branch ? dim("  ⎇ " + o.branch) : ""}`,
+        ...(o.verify ? [`${dim("verify")}   ${o.verify}`] : []), ...(o.notes ? [`${dim("memory")}   ${o.notes} note${o.notes === 1 ? "" : "s"} loaded`] : []),
+        ...(o.resumed ? [`${dim("resumed")}  ${o.resumed}`] : []),
+    ];
+    return [...framed("welcome", body, Math.min(width, 66)), ...wrapAnsi(dim("  /help for commands · @file to mention · shift+tab changes permissions"), width, 2),
+        ...(o.tip ? wrapAnsi(`  ${yellow("tip")} ${dim(o.tip)}`, width, 6) : []), ""];
+}

package/dist/cli/ui.d.ts

@@ -0,0 +1,34 @@
+export declare const bold: (s: string) => string, dim: (s: string) => string, red: (s: string) => string, green: (s: string) => string, yellow: (s: string) => string, blue: (s: string) => string, magenta: (s: string) => string, cyan: (s: string) => string, gray: (s: string) => string;
+export declare const strip: (s: string) => string;
+export declare const width: () => number;
+/** Word-wrap one line (ANSI-aware) to `w` visible columns; continuation lines are indented 2 spaces. */
+export declare function wrap(line: string, w: number): string[];
+export declare function box(input: string[], paint?: (s: string) => string, title?: string): string;
+/** Thrown when the user presses Esc inside a text prompt; screens let it bubble up to the menu. */
+export declare class Cancel extends Error {
+    constructor();
+}
+export type Item<T> = {
+    label: string;
+    value: T;
+    hint?: string;
+};
+/**
+ * Arrow-key menu. ↑/↓ or j/k move, 1-9 jump, enter selects, esc goes back, "/" filters long lists, "?" toggles help.
+ * Long lists scroll inside the terminal height. Returns undefined on back.
+ */
+export declare function select<T>(title: string, items: Item<T>[], initial?: number): Promise<T | undefined>;
+/**
+ * Text prompt. Esc cancels (throws Cancel), up/down recall `history`, and pasted multi-line text arrives as ONE answer
+ * instead of leaking into later prompts. With `multiline`, newlines in a paste are kept; otherwise they become spaces.
+ */
+export declare function ask(prompt: string, def?: string, o?: {
+    secret?: boolean;
+    multiline?: boolean;
+    history?: string[];
+}): Promise<string>;
+export declare const confirm: (q: string, def?: boolean) => Promise<boolean>;
+export declare const pause: () => Promise<void>;
+export declare const clearScreen: () => void;
+export declare function log(line?: string): void;
+export declare function spin(text: string | (() => string)): () => void;