@nanhara/hara 0.0.2 → 0.48.0

package/dist/tui/App.js

@@ -0,0 +1,200 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+// The hara TUI (ink). Layout, top to bottom:
+//   <Static>   committed transcript — rendered once each, scrolls into native scrollback
+//   current    the in-progress turn's blocks (assistant text / reasoning / tool / diff), live
+//   <Working>  spinner while a turn runs (Esc interrupts)
+//   <InputBox> the pinned, bordered prompt (or a confirm prompt when a tool needs approval)
+//
+// The agent machinery is injected via `onSubmit` (a turn runner) so this view is testable with
+// ink-testing-library against a fake runner — no provider/network needed.
+import { Box, Static, Text, useApp, useInput } from "ink";
+import { useCallback, useEffect, useRef, useState } from "react";
+import { InputBox } from "./InputBox.js";
+import { activity } from "../activity.js";
+import { ctxPctFor } from "../statusbar.js";
+import { accent } from "./theme.js";
+import { renderMarkdown } from "../md.js";
+let _id = 0;
+const nid = () => ++_id;
+const stripAnsi = (s) => s.replace(/\x1b\[[0-9;]*m/g, "");
+function Block({ item, open }) {
+    switch (item.kind) {
+        case "user":
+            return (_jsxs(Box, { marginTop: 1, children: [_jsx(Text, { color: "cyan", children: "\u203A " }), _jsx(Text, { children: item.text })] }));
+        case "assistant":
+            return _jsx(Text, { children: renderMarkdown(item.text) }); // headers/bold/inline-code/bullets + verbatim fences
+        case "reasoning": {
+            // fixed-height window: show the last 5 lines while thinking; ctrl-r toggles the full text.
+            const lines = item.text.replace(/\n+$/, "").split("\n");
+            const long = lines.length > 5;
+            const shown = open || !long ? lines : lines.slice(-5);
+            const hint = long ? (open ? " · ctrl-r collapse" : " · ctrl-r expand") : "";
+            return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { color: accent(), dimColor: true, children: `✻ thinking … ${lines.length} line${lines.length === 1 ? "" : "s"}${hint}` }), shown.map((l, i) => (_jsx(Text, { dimColor: true, children: `│ ${l}` }, i)))] }));
+        }
+        case "tool":
+            return _jsx(Text, { dimColor: true, children: "  " + item.text });
+        case "diff":
+            return _jsx(Text, { children: item.text });
+        case "notice":
+            return _jsx(Text, { dimColor: true, children: item.text });
+    }
+}
+// ASCII rendering of the nanhara "Λi" mark (small peak + big peak + italic i), in the brand violet.
+// hara wordmark — FIGlet "ANSI Shadow". A recognizable banner reads better in a terminal than a
+// pixel-faithful logo. Printed once at the top of the session; scrolls away with the transcript.
+const BANNER = [
+    "██╗  ██╗ █████╗ ██████╗  █████╗",
+    "██║  ██║██╔══██╗██╔══██╗██╔══██╗",
+    "███████║███████║██████╔╝███████║",
+    "██╔══██║██╔══██║██╔══██╗██╔══██║",
+    "██║  ██║██║  ██║██║  ██║██║  ██║",
+    "╚═╝  ╚═╝╚═╝  ╚═╝╚═╝  ╚═╝╚═╝  ╚═╝",
+];
+function HeaderCard({ version, model, cwd, tip, vision, session }) {
+    return (_jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [BANNER.map((row, i) => (_jsx(Text, { color: accent(), children: row }, i))), _jsx(Text, { dimColor: true, children: ` the coding agent that runs like an org   ·   v${version}` }), _jsx(Text, { dimColor: true, children: ` ${model}  ·  ${cwd}` }), session ? _jsx(Text, { dimColor: true, children: ` session ${session}` }) : null, vision ? (_jsxs(Text, { children: [_jsx(Text, { color: accent(), children: " 👁 " }), _jsx(Text, { dimColor: true, children: vision })] })) : null, tip ? _jsx(Text, { dimColor: true, children: ` ${tip}` }) : null] }));
+}
+function Working() {
+    const [n, setN] = useState(0);
+    useEffect(() => {
+        const id = setInterval(() => setN((x) => x + 1), 100);
+        return () => clearInterval(id);
+    }, []);
+    const frames = "⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏";
+    return (_jsxs(Box, { marginTop: 1, children: [_jsx(Text, { color: "yellow", children: frames[n % frames.length] }), _jsx(Text, { dimColor: true, children: ` working ${Math.floor(n / 10)}s · esc to interrupt` })] }));
+}
+export function App({ initialStatus, model, cwd, header, onSubmit, cycleApproval, onClipboardImage }) {
+    const { exit } = useApp();
+    const [history, setHistory] = useState([]);
+    const [current, setCurrent] = useState([]);
+    const [working, setWorking] = useState(false);
+    const [status, setStatus] = useState({ ...initialStatus, agents: 0 });
+    const [prompt, setPrompt] = useState(null);
+    const [promptSel, setPromptSel] = useState(0);
+    const [reasoningOpen, setReasoningOpen] = useState(false);
+    const ctrlRef = useRef(null);
+    const queueRef = useRef([]); // type-ahead: FIFO of messages entered while working
+    const [pool, setPool] = useState([]); // type-ahead pool: queued message lines, shown above the input
+    const drainingRef = useRef(false); // idempotency guard so the drain effect can't double-send one item
+    const currentRef = useRef([]);
+    currentRef.current = current;
+    const statusRef = useRef(status);
+    statusRef.current = status;
+    useEffect(() => {
+        const fn = () => setStatus((s) => ({ ...s, agents: activity.running }));
+        activity.onChange(fn);
+        return () => activity.onChange(null);
+    }, []);
+    const pushCurrent = useCallback((kind, text, merge = false) => {
+        setCurrent((cur) => {
+            const last = cur[cur.length - 1];
+            if (merge && last && last.kind === kind)
+                return [...cur.slice(0, -1), { ...last, text: last.text + text }];
+            return [...cur, { id: nid(), kind, text }];
+        });
+    }, []);
+    const handleSubmit = useCallback(async (line, images) => {
+        const t = line.trim();
+        if ((!t && !images?.length) || prompt)
+            return; // nothing to send, or a choice is pending
+        if (working) {
+            // type-ahead: hold the message in the pool; all pooled messages are sent together when the turn ends
+            queueRef.current.push({ line, images });
+            setPool(queueRef.current.map((q) => q.line.trim() || "🖼 (image)"));
+            return;
+        }
+        setHistory((h) => [...h, { id: nid(), kind: "user", text: t }]); // t already carries any [Image #N] tokens
+        const ctrl = new AbortController();
+        ctrlRef.current = ctrl;
+        setWorking(true);
+        const sink = {
+            assistantDelta: (d) => pushCurrent("assistant", d, true),
+            reasoningDelta: (d) => pushCurrent("reasoning", d, true),
+            tool: (name, preview) => pushCurrent("tool", `↳ ${name}${preview ? " " + preview : ""}`),
+            diff: (text) => pushCurrent("diff", text),
+            notice: (text) => pushCurrent("notice", text),
+            usage: (input, output) => setStatus((s) => ({ ...s, input: s.input + input, output: s.output + output, ctxPct: ctxPctFor(model, input) })),
+            session: (name) => setStatus((s) => ({ ...s, sessionName: name })),
+        };
+        const openPrompt = (title, options) => new Promise((resolve) => {
+            setPromptSel(0);
+            setPrompt({ title, options: options, resolve: resolve });
+        });
+        const confirmFn = (q) => openPrompt(q, [
+            { label: "Yes", value: true, key: "y" },
+            { label: "Yes, and don't ask again this session", value: "always", key: "a" },
+            { label: "No  (esc)", value: false, key: "n" },
+        ]);
+        const selectFn = (title, options) => openPrompt(title, options);
+        const setApprovalFn = (m) => setStatus((s) => ({ ...s, approval: m }));
+        try {
+            await onSubmit(t, { sink, confirm: confirmFn, select: selectFn, setApproval: setApprovalFn, signal: ctrl.signal, exit, approval: statusRef.current.approval }, images);
+        }
+        catch (e) {
+            pushCurrent("notice", `error: ${e instanceof Error ? e.message : String(e)}`);
+        }
+        const committed = currentRef.current.map((it) => it.kind === "reasoning"
+            ? { ...it, kind: "notice", text: `✻ thought · ${it.text.split("\n").filter((l) => l.trim()).length} lines` }
+            : it);
+        setHistory((h) => [...h, ...committed]);
+        setCurrent([]);
+        setWorking(false);
+        ctrlRef.current = null;
+    }, [working, prompt, onSubmit, pushCurrent, model, exit]);
+    // Drain the type-ahead pool: when the turn finishes (working → false) and nothing awaits a choice, COALESCE
+    // every pooled message into ONE turn and send it — additions/clarifications go to the agent together, in order.
+    useEffect(() => {
+        if (working || prompt || drainingRef.current || !queueRef.current.length)
+            return;
+        drainingRef.current = true;
+        const batch = queueRef.current;
+        queueRef.current = [];
+        setPool([]);
+        const line = batch.map((b) => b.line).join("\n\n");
+        const images = batch.flatMap((b) => b.images ?? []);
+        void Promise.resolve(handleSubmit(line, images.length ? images : undefined)).finally(() => {
+            drainingRef.current = false;
+        });
+    }, [working, prompt, handleSubmit]);
+    useInput((input, key) => {
+        if (prompt) {
+            const opts = prompt.options;
+            if (key.upArrow)
+                setPromptSel((s) => (s - 1 + opts.length) % opts.length);
+            else if (key.downArrow)
+                setPromptSel((s) => (s + 1) % opts.length);
+            else if (key.return) {
+                prompt.resolve(opts[Math.min(promptSel, opts.length - 1)].value);
+                setPrompt(null);
+            }
+            else if (key.escape) {
+                prompt.resolve(opts[opts.length - 1].value); // last option = cancel/no
+                setPrompt(null);
+            }
+            else if (/^[1-9]$/.test(input) && Number(input) <= opts.length) {
+                prompt.resolve(opts[Number(input) - 1].value); // type a number to pick directly
+                setPrompt(null);
+            }
+            else if (input) {
+                const hit = opts.find((o) => o.key && o.key === input.toLowerCase());
+                if (hit) {
+                    prompt.resolve(hit.value);
+                    setPrompt(null);
+                }
+            }
+            return;
+        }
+        if (key.ctrl && input === "r")
+            return setReasoningOpen((x) => !x);
+        if (key.escape && working) {
+            // Esc = stop everything: abort the turn AND drop any type-ahead (a stopped turn shouldn't fire queued msgs)
+            if (queueRef.current.length) {
+                queueRef.current = [];
+                setPool([]);
+            }
+            ctrlRef.current?.abort();
+        }
+        else if (key.tab && key.shift && cycleApproval)
+            setStatus((s) => ({ ...s, approval: cycleApproval(s.approval) }));
+    });
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Static, { items: header ? [{ id: -1, kind: "notice", text: "" }, ...history] : history, children: (item) => (item.id === -1 ? _jsx(HeaderCard, { ...header }, "hdr") : _jsx(Block, { item: item }, item.id)) }), current.map((item) => (_jsx(Block, { item: item, open: reasoningOpen }, item.id))), working && !prompt && _jsx(Working, {}), prompt && (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Text, { color: "yellow", children: `  ${stripAnsi(prompt.title)}` }), prompt.options.map((o, i) => (_jsx(Text, { color: i === promptSel ? "cyan" : undefined, bold: i === promptSel, children: (i === promptSel ? " ❯ " : "   ") + `${i + 1}. ` + o.label }, i))), _jsx(Text, { dimColor: true, children: `   ↑↓ or 1–${prompt.options.length} to choose · Enter · Esc cancels` })] })), pool.length > 0 && !prompt && (_jsx(Box, { flexDirection: "column", children: pool.map((l, i) => (_jsx(Text, { color: accent(), children: `  › ${l.length > 72 ? l.slice(0, 72) + "…" : l}` }, i))) })), _jsx(InputBox, { status: status, cwd: cwd, isActive: !prompt, working: working, queued: pool.length, onSubmit: handleSubmit, onClipboardImage: onClipboardImage })] }));
+}

package/dist/tui/InputBox.js

@@ -0,0 +1,208 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+// The framed input box (ink): a top border carrying the session name in the right corner, the
+// prompt line in the middle, and a bottom border carrying the approval modes + token usage +
+// concurrency. Composed from <Text> rows (no ink border fork needed) so the title sits exactly
+// where we want it. Pure-ish: pass `width` to make rendering deterministic in tests.
+import { Box, Text, useInput, useStdout } from "ink";
+import { useMemo, useState } from "react";
+import { fileCandidates } from "../context/mentions.js";
+import { imagePathFromPaste } from "../images.js";
+export const MODES = ["suggest", "auto-edit", "full-auto", "plan"];
+export const nextMode = (m) => MODES[(MODES.indexOf(m) + 1) % MODES.length];
+const tok = (n) => (n >= 1000 ? `${(n / 1000).toFixed(1)}k` : `${n}`);
+function TopBorder({ name, width }) {
+    const labelLen = name.length + 2; // "⏺ " + name
+    const left = Math.max(2, width - labelLen - 3);
+    return (_jsxs(Box, { children: [_jsxs(Text, { dimColor: true, children: ["─".repeat(left), " "] }), _jsx(Text, { color: "cyan", children: "\u23FA" }), _jsxs(Text, { bold: true, children: [" ", name] }), _jsx(Text, { dimColor: true, children: " \u2500" })] }));
+}
+// Bottom border carries token usage + concurrency at the right corner (modes moved to ModeBar below).
+function BottomBorder({ s, width }) {
+    const usage = `↑${tok(s.input)} ↓${tok(s.output)}${s.ctxPct > 0 ? ` · ctx ${s.ctxPct}%` : ""}`;
+    const label = s.agents > 0 ? `${usage} · ⛁${s.agents}` : `${usage} · ⛁ idle`;
+    const left = Math.max(2, width - label.length - 3);
+    return (_jsx(Box, { children: _jsx(Text, { dimColor: true, children: `${"─".repeat(left)} ${label} ─` }) }));
+}
+const MODE_DESC = {
+    suggest: "confirms edits & commands",
+    "auto-edit": "auto-applies edits · asks before commands",
+    "full-auto": "runs everything — no prompts  ⚠",
+    plan: "investigate read-only, then propose a plan to approve",
+};
+// Prominent approval-mode selector below the box: all three listed, the active one highlighted (red
+// for the dangerous full-auto) with a one-line description and the shift+tab hint.
+function ModeBar({ approval }) {
+    const warn = approval === "full-auto";
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { children: MODES.map((m, i) => (_jsxs(Text, { children: [i > 0 ? "   " : "  ", m === approval ? _jsx(Text, { color: warn ? "red" : m === "plan" ? "cyan" : "green", bold: true, children: `◆ ${m}` }) : _jsx(Text, { dimColor: true, children: m })] }, m))) }), _jsx(Text, { dimColor: true, children: `    ${MODE_DESC[approval]} · shift+tab ⇄` })] }));
+}
+/** The active `@mention` token immediately left of the cursor (for the file popup), or null. */
+function activeMention(value, cursor) {
+    const m = /(?:^|\s)@([^\s@]*)$/.exec(value.slice(0, cursor));
+    return m ? { query: m[1], start: cursor - m[1].length } : null;
+}
+// Dropdown of fuzzy @path matches, shown above the input as you type `@…` (codex / Claude-Code style).
+function MentionPopup({ items, selected, query }) {
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { dimColor: true, children: `  @${query}  ·  ${items.length} match${items.length === 1 ? "" : "es"} — ↑↓ select · Tab/Enter insert · Esc dismiss` }), items.map((it, i) => (_jsxs(Text, { children: [i === selected ? _jsx(Text, { color: "cyan", children: "  ▸ " }) : _jsx(Text, { children: "    " }), _jsx(Text, { color: it.endsWith("/") ? "blue" : undefined, dimColor: i !== selected, bold: i === selected, children: it })] }, it)))] }));
+}
+const TOKEN_RE = /\[Image #\d+\]/g;
+/** Render the prompt line: plain text + the cursor, with any `[Image #N]` attachment tokens highlighted
+ *  (codex / Claude-Code style — the image lives inline in the text, visibly distinct from what you typed). */
+function InputLine({ value, cursor }) {
+    const parts = [];
+    let last = 0;
+    let m;
+    TOKEN_RE.lastIndex = 0;
+    while ((m = TOKEN_RE.exec(value))) {
+        if (m.index > last)
+            parts.push({ text: value.slice(last, m.index), token: false });
+        parts.push({ text: m[0], token: true });
+        last = m.index + m[0].length;
+    }
+    if (last < value.length)
+        parts.push({ text: value.slice(last), token: false });
+    const seg = (token, text, k) => token ? (_jsx(Text, { backgroundColor: "magenta", color: "white", children: text }, k)) : (_jsx(Text, { children: text }, k));
+    const nodes = [];
+    let pos = 0;
+    let ki = 0;
+    for (const p of parts) {
+        const start = pos;
+        const end = pos + p.text.length;
+        if (cursor >= start && cursor < end) {
+            const rel = cursor - start;
+            if (rel > 0)
+                nodes.push(seg(p.token, p.text.slice(0, rel), `s${ki++}`));
+            nodes.push(_jsx(Text, { inverse: true, children: p.text[rel] }, `c${ki++}`));
+            if (rel + 1 < p.text.length)
+                nodes.push(seg(p.token, p.text.slice(rel + 1), `e${ki++}`));
+        }
+        else {
+            nodes.push(seg(p.token, p.text, `p${ki++}`));
+        }
+        pos = end;
+    }
+    if (cursor >= value.length)
+        nodes.push(_jsx(Text, { inverse: true, children: " " }, "end"));
+    return _jsx(Text, { children: nodes });
+}
+/** Top border (session) + prompt line + bottom border (usage) + ModeBar, with an @path popup. */
+export function InputBox({ status, cwd, width, onSubmit, onClipboardImage, isActive = true, working = false, queued = 0, placeholder = "Type a task · /help · @file · Ctrl+V paste image · shift+tab mode · Esc interrupts", }) {
+    const { stdout } = useStdout();
+    const w = width ?? stdout?.columns ?? 80;
+    const [value, setValue] = useState("");
+    const [cursor, setCursor] = useState(0);
+    const [sel, setSel] = useState(0);
+    const [dismissed, setDismissed] = useState(false);
+    const [images, setImages] = useState([]);
+    const set = (v, c) => {
+        setValue(v);
+        setCursor(c);
+        setSel(0);
+        setDismissed(false);
+    };
+    // Attach an image: drop a highlighted `[Image #N]` token inline at the cursor and track the file
+    // (codex / Claude-Code style). Backspace over the token removes both.
+    const addImage = (img) => {
+        const tok = `[Image #${images.length + 1}]`;
+        const before = value.slice(0, cursor);
+        const ins = (before && !/\s$/.test(before) ? " " : "") + tok + " ";
+        setValue(before + ins + value.slice(cursor));
+        setCursor((before + ins).length);
+        setImages((xs) => [...xs, img]);
+        setSel(0);
+        setDismissed(false);
+    };
+    const submit = (text) => {
+        if (!text.trim() && images.length === 0)
+            return; // nothing to send
+        onSubmit?.(text, images.length ? images : undefined);
+        set("", 0);
+        setImages([]);
+    };
+    const mention = activeMention(value, cursor);
+    const candidates = useMemo(() => (isActive && mention && !dismissed ? fileCandidates(cwd, mention.query, 8) : []), [cwd, isActive, dismissed, mention?.query, mention?.start]);
+    const popupOpen = candidates.length > 0;
+    const selIdx = popupOpen ? Math.min(sel, candidates.length - 1) : 0;
+    const complete = (cand) => {
+        if (!mention)
+            return;
+        const before = value.slice(0, mention.start); // includes the leading '@'
+        const after = value.slice(cursor);
+        const insert = cand.endsWith("/") ? cand : cand + " "; // dirs keep drilling; files end the mention
+        setValue(before + insert + after);
+        setCursor((before + insert).length);
+        setSel(0);
+        setDismissed(false);
+    };
+    useInput((input, key) => {
+        if (popupOpen && (key.upArrow || key.downArrow)) {
+            const n = candidates.length;
+            setSel((s) => (key.downArrow ? (s + 1) % n : (s - 1 + n) % n));
+            return;
+        }
+        if (popupOpen && (key.tab || key.return)) {
+            complete(candidates[selIdx]);
+            return;
+        }
+        if (key.escape) {
+            if (popupOpen)
+                setDismissed(true);
+            return;
+        }
+        if (key.return) {
+            submit(value);
+            return;
+        }
+        if (key.leftArrow)
+            return setCursor((c) => Math.max(0, c - 1));
+        if (key.rightArrow)
+            return setCursor((c) => Math.min(value.length, c + 1));
+        if (key.ctrl && input === "a")
+            return setCursor(0);
+        if (key.ctrl && input === "e")
+            return setCursor(value.length);
+        if (key.ctrl && input === "u")
+            return set(value.slice(cursor), 0);
+        if (key.ctrl && input === "v") {
+            // paste a screenshot / image from the OS clipboard
+            const img = onClipboardImage?.();
+            if (img)
+                addImage(img);
+            return;
+        }
+        if (key.backspace || key.delete) {
+            if (cursor > 0) {
+                const head = value.slice(0, cursor);
+                const tm = /\[Image #(\d+)\]\s?$/.exec(head); // backspacing over an attachment token removes it whole
+                if (tm) {
+                    const n = Number(tm[1]);
+                    const kept = head.slice(0, tm.index) + value.slice(cursor);
+                    const renumbered = kept.replace(/\[Image #(\d+)\]/g, (m2, d) => (Number(d) > n ? `[Image #${Number(d) - 1}]` : m2));
+                    setImages((xs) => xs.filter((_, i) => i !== n - 1));
+                    setValue(renumbered);
+                    setCursor(tm.index);
+                    setSel(0);
+                    setDismissed(false);
+                    return;
+                }
+                set(value.slice(0, cursor - 1) + value.slice(cursor), cursor - 1);
+            }
+            return;
+        }
+        if (input && !key.ctrl && !key.meta) {
+            const nl = input.search(/[\r\n]/); // a chunk carrying a newline (paste / fed input) submits
+            if (nl >= 0) {
+                submit(value.slice(0, cursor) + input.slice(0, nl) + value.slice(cursor));
+                return;
+            }
+            // a dragged-in / pasted image file path attaches instead of inserting literal text
+            if (input.length > 3) {
+                const img = imagePathFromPaste(input, cwd);
+                if (img) {
+                    addImage(img);
+                    return;
+                }
+            }
+            set(value.slice(0, cursor) + input + value.slice(cursor), cursor + input.length);
+        }
+    }, { isActive });
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(TopBorder, { name: status.sessionName || "session", width: w }), _jsxs(Box, { children: [_jsx(Text, { color: "cyan", children: "› " }), value.length === 0 ? (_jsxs(Text, { children: [_jsx(Text, { inverse: true, children: " " }), _jsx(Text, { dimColor: true, children: placeholder })] })) : (_jsx(InputLine, { value: value, cursor: cursor }))] }), _jsx(BottomBorder, { s: status, width: w }), working ? _jsx(Text, { dimColor: true, children: `  ⌨ working — Enter queues your message${queued ? ` · ${queued} queued` : ""} · Esc interrupts` }) : null, popupOpen ? _jsx(MentionPopup, { items: candidates, selected: selIdx, query: mention.query }) : null, _jsx(ModeBar, { approval: status.approval })] }));
+}

package/dist/tui/run.js

@@ -0,0 +1,10 @@
+// Mounts the hara TUI (ink) and resolves when the user exits. Thin shell — all agent wiring
+// (provider, session history, slash commands, turn execution) is passed in via AppProps.onSubmit
+// from index.ts, which owns that state.
+import { render } from "ink";
+import { createElement } from "react";
+import { App } from "./App.js";
+export async function runTui(props) {
+    const instance = render(createElement(App, props));
+    await instance.waitUntilExit();
+}

package/dist/tui/theme.js

@@ -0,0 +1,11 @@
+let current = "dark";
+export function setTheme(name) {
+    current = name === "light" ? "light" : "dark";
+}
+export function themeName() {
+    return current;
+}
+/** Brand accent (warm vermilion · 朱印). */
+export function accent() {
+    return current === "light" ? "#C0392B" : "#FF6B5C";
+}

package/dist/ui.js

@@ -0,0 +1,17 @@
+import { stdout } from "node:process";
+const useColor = stdout.isTTY && process.env.NO_COLOR === undefined;
+const wrap = (code) => (s) => (useColor ? `\x1b[${code}m${s}\x1b[0m` : s);
+export const c = {
+    dim: wrap("2"),
+    bold: wrap("1"),
+    cyan: wrap("36"),
+    green: wrap("32"),
+    yellow: wrap("33"),
+    red: wrap("31"),
+};
+export function out(s) {
+    stdout.write(s);
+}
+export function statusLine(model, inTok, outTok) {
+    return c.dim(`  ${model} · ↑${inTok} ↓${outTok} tok`);
+}

package/dist/undo.js

@@ -0,0 +1,40 @@
+// In-session undo stack for file changes. Each edit tool records the prior state of the files it
+// touched; `/undo` pops the last group and restores it. Process-scoped (one REPL session).
+import { writeFile, unlink, mkdir } from "node:fs/promises";
+import { dirname } from "node:path";
+const stack = [];
+const MAX = 50;
+/** Record a group of file changes (one tool call = one undo step). */
+export function recordEdit(group) {
+    if (!group.length)
+        return;
+    stack.push(group);
+    if (stack.length > MAX)
+        stack.shift();
+}
+export function undoDepth() {
+    return stack.length;
+}
+/** Restore the most recent edit group. Returns the files reverted, or an error. */
+export async function undoLast() {
+    const group = stack.pop();
+    if (!group)
+        return { error: "nothing to undo" };
+    const files = [];
+    for (const s of group) {
+        try {
+            if (s.before === null) {
+                await unlink(s.absPath).catch(() => { }); // was newly created → remove
+            }
+            else {
+                await mkdir(dirname(s.absPath), { recursive: true });
+                await writeFile(s.absPath, s.before, "utf8");
+            }
+            files.push(s.path);
+        }
+        catch {
+            /* skip a file we can't restore */
+        }
+    }
+    return { files };
+}

package/dist/vision.js

@@ -0,0 +1,130 @@
+// Built-in capability map for the major model families. First matching rule wins, so each family's
+// vision pattern is listed BEFORE its text catch-all. Anything that matches nothing → "unknown"
+// (we ask the user once and remember). Easy to extend — add a rule near the right family.
+const MODEL_VISION_MAP = [
+    // OpenAI
+    { rx: /gpt-4o|gpt-4\.1|gpt-4-turbo|chatgpt-4o|gpt-5|(?:^|[-_/])o[134](?:[-_/]|$)/i, cap: "vision" },
+    { rx: /gpt-4(\b|-0|-1)|gpt-3\.5|davinci|babbage|text-(?:embedding|davinci)/i, cap: "text" },
+    // Qwen — Alibaba Coding Plan: qwen3.x-plus see images (verified qwen3.7-plus); max/coder are text-only.
+    { rx: /qwen.*vl|qwen.*omni|qvq/i, cap: "vision" },
+    { rx: /qwen-?3[.\d]*-plus/i, cap: "vision" }, // qwen3.5-plus / qwen3.6-plus / qwen3.7-plus
+    { rx: /qwen.*(?:coder|plus|max|turbo|long|math)|qwq|qwen[\d.]*-?\d+b\b|qwen-?\d/i, cap: "text" },
+    // GLM / Zhipu — 4v/4.5v see images; glm-5, glm-4.7, glm-4-flash are text-only.
+    { rx: /glm-?\d(?:\.\d+)?v|cogvlm|glm.*vision/i, cap: "vision" },
+    { rx: /glm-?\d(?:\.\d+)?(?:-(?:air|flash|plus|long|x|0520))?\b|glm-z|chatglm/i, cap: "text" },
+    // DeepSeek (VL first, then the text families)
+    { rx: /deepseek.*vl/i, cap: "vision" },
+    { rx: /deepseek/i, cap: "text" },
+    // Google
+    { rx: /gemini|gemma-3/i, cap: "vision" },
+    { rx: /gemma/i, cap: "text" },
+    // Mistral (Pixtral/small-3 see; the rest text)
+    { rx: /pixtral|mistral-small-3|mistral.*vision/i, cap: "vision" },
+    { rx: /mistral|mixtral|codestral|ministral/i, cap: "text" },
+    // Meta Llama (3.2-11B/90B + 4 see; the rest text)
+    { rx: /llama-?3\.2-(?:11|90)b|llama.*vision|llama-?4/i, cap: "vision" },
+    { rx: /llama|codellama/i, cap: "text" },
+    // Moonshot / Kimi — kimi-k2.5 sees images (Coding Plan); older Kimi text.
+    { rx: /kimi-?k?2\.5|kimi.*vl|moonshot.*(?:vl|vision)/i, cap: "vision" },
+    { rx: /kimi|moonshot/i, cap: "text" },
+    // xAI Grok
+    { rx: /grok.*vision|grok-[\d.]*v\b|grok-4/i, cap: "vision" },
+    { rx: /grok/i, cap: "text" },
+    // MiniMax — VL models see images; the M-series chat (e.g. MiniMax-M2.5) is text-only.
+    { rx: /minimax.*(?:vl|vision)|abab.*vl/i, cap: "vision" },
+    { rx: /minimax|abab/i, cap: "text" },
+    // Other well-known vision families
+    { rx: /(?:^|[-_/])vl(?:[-_/]|$)|internvl|llava|minicpm-?v|yi-vl|step-1[vo]|doubao.*(?:vl|vision)|ernie.*vl/i, cap: "vision" },
+];
+/**
+ * Resolve a model's vision capability: explicit per-model override → Anthropic (all modern Claude see
+ * images) → built-in family map → "unknown" (caller asks the user). Pure + table-driven so it's testable.
+ */
+export function classifyVision(provider, model, overrides = {}) {
+    const o = overrides[model];
+    if (o === "yes")
+        return "vision";
+    if (o === "no")
+        return "text";
+    if (provider === "anthropic")
+        return "vision";
+    const m = model || "";
+    for (const r of MODEL_VISION_MAP)
+        if (r.rx.test(m))
+            return r.cap;
+    return "unknown";
+}
+export const DESCRIBE_SYSTEM = [
+    "You are the eyes of a coding assistant that cannot see images. Transcribe and describe the attached",
+    "image(s) completely and precisely so the assistant can act on them without seeing them.",
+    "Rules:",
+    "1. Transcribe ALL visible text and code VERBATIM, preserving line breaks and indentation — put code,",
+    "   terminal output, and logs in fenced code blocks.",
+    "2. For UI / screenshots: describe the layout, components, labels, states, and notable colors.",
+    "3. For diagrams / charts: describe the structure — nodes, edges, axes, and data.",
+    "4. Quote any error or warning messages exactly.",
+    "5. Be thorough and factual; do not speculate beyond what is visible.",
+].join("\n");
+// Screenshot variant — tuned for driving the desktop (RPA) rather than transcription. A text-only main
+// model can't see, so it needs *actionable* output: where things are, so it can issue clicks.
+export const SCREENSHOT_SYSTEM = [
+    "You are the eyes of an assistant operating this computer; it cannot see the screen and acts only on your",
+    "words. Describe the screenshot so it can ACT. Prioritise, in order:",
+    "1. INTERACTIVE elements — buttons, links, text fields, checkboxes, menus, tabs, icons — each with its",
+    "   visible label and an approximate location: a region (e.g. top-right) AND a rough pixel x,y if you can.",
+    "2. The currently focused/active element or selection, and any open dialog/modal/popup.",
+    "3. Errors, warnings, and key visible text/headings — quote them exactly.",
+    "4. One line on what app/screen this appears to be.",
+    "Positions guide clicks, so always estimate them. Be concise and factual; never invent elements.",
+].join("\n");
+// Grounding — ask a vision model WHERE a UI element is (for accurate RPA clicking), as resolution-independent
+// fractions so it works regardless of Retina/DPI scaling.
+export const LOCATE_SYSTEM = [
+    "You are given a screenshot. The user names ONE UI element (button, field, icon, menu item, link).",
+    "Return ONLY its CENTER as JSON: {\"x\": <0-1000>, \"y\": <0-1000>}, where x is the position as per-mille of",
+    "the image WIDTH (0=left, 1000=right) and y as per-mille of the HEIGHT (0=top, 1000=bottom).",
+    "If the element is not visible, return {\"x\": -1, \"y\": -1}. Output ONLY the JSON, nothing else.",
+].join("\n");
+/** Parse a grounding reply → {x,y} as 0..1 fractions (accepts per-mille / percent / fraction), or null. */
+export function parseLocate(text) {
+    const m = text.match(/"x"\s*:\s*(-?\d+(?:\.\d+)?)[\s,}]+.*?"y"\s*:\s*(-?\d+(?:\.\d+)?)/s) || text.match(/(-?\d+(?:\.\d+)?)\s*[,\s]\s*(-?\d+(?:\.\d+)?)/);
+    if (!m)
+        return null;
+    let x = Number(m[1]);
+    let y = Number(m[2]);
+    if (x < 0 || y < 0 || Number.isNaN(x) || Number.isNaN(y))
+        return null; // not found / unparseable
+    const norm = (v) => (v > 100 ? v / 1000 : v > 1.5 ? v / 100 : v); // per-mille | percent | fraction → 0..1
+    x = Math.min(1, Math.max(0, norm(x)));
+    y = Math.min(1, Math.max(0, norm(y)));
+    return { x, y };
+}
+/** Send a screenshot to a (grounding-capable) vision model and get the target's center as 0..1 fractions. */
+export async function locateImage(provider, image, target, opts = {}) {
+    const r = await provider.turn({
+        system: LOCATE_SYSTEM,
+        history: [{ role: "user", content: `Locate this element: ${target}`, images: [image] }],
+        tools: [],
+        onText: () => { },
+        signal: opts.signal,
+    });
+    if (r.stop === "error")
+        return null;
+    return parseLocate(r.text);
+}
+const PROMPT = "Describe the attached image(s) per your instructions.";
+/** Send images to the vision provider and return its textual description. Throws on a provider error.
+ *  `system` overrides the default prompt (e.g. SCREENSHOT_SYSTEM); `hint` focuses it on a specific goal. */
+export async function describeImages(provider, images, opts = {}) {
+    const content = opts.hint ? `${PROMPT}\nFocus especially on: ${opts.hint}` : PROMPT;
+    const r = await provider.turn({
+        system: opts.system ?? DESCRIBE_SYSTEM,
+        history: [{ role: "user", content, images }],
+        tools: [],
+        onText: () => { },
+        signal: opts.signal,
+    });
+    if (r.stop === "error")
+        throw new Error(r.errorMsg || "vision provider error");
+    return r.text.trim();
+}