bonecode 1.1.0 → 1.2.1

package/dist/src/tui.js

@@ -0,0 +1,1053 @@
+"use strict";
+/**
+ * BoneCode TUI — terminal interface modeled after OpenCode
+ *
+ * Three core behaviours:
+ *   1. Tool activity is displayed as concise status lines
+ *      (← Edit src/foo.ts, → Read package.json, $ npm test) — never raw code dumps.
+ *      Assistant text is shown inline; tool calls and tool outputs are summarized.
+ *
+ *   2. Typing "/" shows an inline command menu above the prompt with
+ *      arrow-key selection and tab/enter to insert.
+ *
+ *   3. Ctrl+C aborts the in-flight LLM stream by aborting the fetch
+ *      AND notifying the server to cancel the agent loop.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startInteractiveTUI = exports.runTUI = void 0;
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+const readline = __importStar(require("readline"));
+const http = __importStar(require("http"));
+// ─── ANSI ─────────────────────────────────────────────────────────────────────
+const ESC = "\x1b";
+const R = `${ESC}[0m`;
+const BOLD = `${ESC}[1m`;
+const DIM = `${ESC}[2m`;
+const CYAN = `${ESC}[96m`;
+const GREEN = `${ESC}[92m`;
+const YELLOW = `${ESC}[93m`;
+const RED = `${ESC}[91m`;
+const GRAY = `${ESC}[90m`;
+const WHITE = `${ESC}[97m`;
+const BLUE = `${ESC}[94m`;
+// Box drawing
+const VERT = "┃";
+const CORN = "╹";
+const SHADE = "▀";
+const BLOCK = "▣";
+const ARROW_R = "→";
+const ARROW_L = "←";
+const DOLLAR = "$";
+const STAR = "✱";
+const PCT = "%";
+const GEAR = "⚙";
+const HASH = "#";
+function cols() { return process.stdout.columns || 80; }
+function out(s) { process.stdout.write(s); }
+function nl(s = "") { process.stdout.write(s + "\n"); }
+function clearLine() { out(`\r${ESC}[2K`); }
+// ─── Logo ─────────────────────────────────────────────────────────────────────
+function printLogo() {
+    nl();
+    nl(`${GRAY}${BOLD}█▀▀▄ █▀▀█ █▀▀█ █▀▀▀ █▀▀▀ █▀▀█ █▀▀▄ █▀▀▀${R}`);
+    nl(`${GRAY}${BOLD}█▀▀▄ █  █ █  █ █▀▀  █    █  █ █  █ █▀▀ ${R}`);
+    nl(`${GRAY}${BOLD}▀▀▀  ▀▀▀▀ ▀  ▀ ▀▀▀▀ ▀▀▀▀ ▀▀▀▀ ▀▀▀  ▀▀▀▀${R}`);
+    nl();
+}
+// ─── Package version ──────────────────────────────────────────────────────────
+const PKG_ROOT = (() => {
+    const fromSrc = path.resolve(__dirname, "..");
+    const fromDist = path.resolve(__dirname, "..", "..");
+    if (fs.existsSync(path.join(fromDist, "package.json")))
+        return fromDist;
+    return fromSrc;
+})();
+function getVersion() {
+    try {
+        return JSON.parse(fs.readFileSync(path.join(PKG_ROOT, "package.json"), "utf-8")).version;
+    }
+    catch {
+        return "0.0.0";
+    }
+}
+const COMMANDS = [
+    { name: "/new", description: "Start a new session" },
+    { name: "/session", description: "Show current session ID" },
+    { name: "/sessions", description: "List recent sessions" },
+    { name: "/model", description: "Switch model", args: "<provider/model>" },
+    { name: "/provider", description: "Switch provider", args: "<id>" },
+    { name: "/providers", description: "List all providers" },
+    { name: "/clear", description: "Clear screen" },
+    { name: "/history", description: "Show last 10 prompts" },
+    { name: "/help", description: "Show this help" },
+    { name: "/exit", description: "Exit BoneCode" },
+];
+// ─── @file autocomplete helpers ───────────────────────────────────────────────
+const IGNORED_DIRS = new Set([
+    "node_modules", ".git", "dist", "build", ".next", "__pycache__",
+    ".venv", "venv", "target", "vendor", ".cache", "coverage",
+]);
+const CODE_EXTS = new Set([
+    ".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".py", ".go", ".rs",
+    ".java", ".kt", ".cs", ".cpp", ".c", ".h", ".rb", ".php", ".swift",
+    ".md", ".mdx", ".json", ".yaml", ".yml", ".toml", ".env", ".sql", ".sh", ".graphql",
+]);
+function listFiles(worktree, prefix) {
+    const results = [];
+    function walk(dir, depth) {
+        if (results.length >= 50 || depth > 4)
+            return;
+        let entries;
+        try {
+            entries = fs.readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const e of entries) {
+            if (results.length >= 50)
+                break;
+            if (IGNORED_DIRS.has(e.name) || e.name.startsWith("."))
+                continue;
+            const rel = path.relative(worktree, path.join(dir, e.name));
+            if (e.isDirectory()) {
+                if (!prefix || rel.startsWith(prefix) || prefix.startsWith(rel)) {
+                    results.push(rel + "/");
+                    walk(path.join(dir, e.name), depth + 1);
+                }
+            }
+            else if (CODE_EXTS.has(path.extname(e.name).toLowerCase())) {
+                if (!prefix || rel.startsWith(prefix))
+                    results.push(rel);
+            }
+        }
+    }
+    walk(worktree, 0);
+    return results.sort();
+}
+function buildCompleter(worktree) {
+    return (line) => {
+        if (line.startsWith("/")) {
+            // Tab-complete commands too (in addition to the inline menu)
+            const matches = COMMANDS.map(c => c.name).filter(c => c.startsWith(line));
+            return [matches, line];
+        }
+        const atIdx = line.lastIndexOf("@");
+        if (atIdx !== -1) {
+            const prefix = line.slice(atIdx + 1);
+            const completions = listFiles(worktree, prefix).map(f => line.slice(0, atIdx + 1) + f);
+            return [completions, line];
+        }
+        return [[], line];
+    };
+}
+// ─── Server health ────────────────────────────────────────────────────────────
+async function waitForServer(port, maxMs = 30000) {
+    const start = Date.now();
+    while (Date.now() - start < maxMs) {
+        try {
+            const ok = await new Promise((resolve) => {
+                const req = http.get(`http://localhost:${port}/health`, (res) => resolve(res.statusCode === 200));
+                req.on("error", () => resolve(false));
+                req.setTimeout(1000, () => { req.destroy(); resolve(false); });
+            });
+            if (ok)
+                return true;
+        }
+        catch { }
+        await new Promise(r => setTimeout(r, 500));
+    }
+    return false;
+}
+// ─── API ──────────────────────────────────────────────────────────────────────
+async function apiGet(url, token) {
+    const r = await fetch(url, { headers: { "Authorization": `Bearer ${token}` } });
+    if (!r.ok)
+        throw new Error(`API ${r.status}`);
+    return r.json();
+}
+async function apiPost(url, body, token) {
+    return fetch(url, {
+        method: "POST",
+        headers: { "Content-Type": "application/json", "Authorization": `Bearer ${token}` },
+        body: JSON.stringify(body),
+    });
+}
+async function apiDelete(url, token) {
+    await fetch(url, { method: "DELETE", headers: { "Authorization": `Bearer ${token}` } });
+}
+async function createSession(port, token, worktree, title) {
+    const r = await apiPost(`http://localhost:${port}/v2/session`, { title, directory: worktree }, token);
+    if (!r.ok)
+        throw new Error(`Failed to create session: ${await r.text()}`);
+    const sess = await r.json();
+    if (!sess.id)
+        throw new Error("No session ID returned");
+    return sess.id;
+}
+function relPath(p, worktree) {
+    if (!p)
+        return "";
+    try {
+        if (path.isAbsolute(p)) {
+            const rel = path.relative(worktree, p);
+            if (!rel.startsWith(".."))
+                return rel.replace(/\\/g, "/");
+        }
+        return p.replace(/\\/g, "/");
+    }
+    catch {
+        return p;
+    }
+}
+function describeTool(toolName, input, worktree) {
+    const n = (toolName || "").toLowerCase();
+    const inp = input || {};
+    // Map BoneCode's tool names AND opencode's names
+    const isWrite = n === "write" || n === "write_file";
+    const isEdit = n === "edit" || n === "edit_file";
+    const isRead = n === "read" || n === "read_file";
+    const isShell = n === "bash" || n === "shell" || n === "run_command";
+    const isGlob = n === "glob";
+    const isGrep = n === "grep" || n === "search_files";
+    const isList = n === "list_directory" || n === "list" || n === "ls";
+    const isWebfetch = n === "webfetch";
+    const isWebsearch = n === "websearch";
+    const isPatch = n === "apply_patch" || n === "patch";
+    const isTodo = n === "todo_write" || n === "todowrite" || n === "todo";
+    const isTask = n === "task" || n === "subagent";
+    if (isWrite) {
+        return { icon: ARROW_L, color: CYAN, title: "Write", detail: relPath(inp.path || inp.filePath, worktree) };
+    }
+    if (isEdit) {
+        return { icon: ARROW_L, color: CYAN, title: "Edit", detail: relPath(inp.path || inp.filePath, worktree) };
+    }
+    if (isPatch) {
+        return { icon: PCT, color: CYAN, title: "Patch", detail: inp.patch ? `${String(inp.patch).split("\n").length} lines` : "" };
+    }
+    if (isRead) {
+        let detail = relPath(inp.path || inp.filePath, worktree);
+        if (inp.start_line || inp.end_line) {
+            detail += ` ${GRAY}[${inp.start_line || 1}-${inp.end_line || ""}]${R}`;
+        }
+        return { icon: ARROW_R, color: GRAY, title: "Read", detail };
+    }
+    if (isShell) {
+        const cmd = String(inp.command || "").trim();
+        const short = cmd.length > 60 ? cmd.slice(0, 57) + "..." : cmd;
+        return { icon: DOLLAR, color: YELLOW, title: short || "Shell" };
+    }
+    if (isGlob) {
+        return { icon: STAR, color: GRAY, title: "Glob", detail: inp.pattern || "" };
+    }
+    if (isGrep) {
+        const pattern = inp.pattern || "";
+        const glob = inp.glob ? ` in ${inp.glob}` : "";
+        return { icon: STAR, color: GRAY, title: "Grep", detail: `"${pattern}"${glob}` };
+    }
+    if (isList) {
+        return { icon: ARROW_R, color: GRAY, title: "List", detail: relPath(inp.path, worktree) };
+    }
+    if (isWebfetch) {
+        return { icon: PCT, color: BLUE, title: "WebFetch", detail: inp.url || "" };
+    }
+    if (isWebsearch) {
+        return { icon: PCT, color: BLUE, title: "WebSearch", detail: inp.query ? `"${inp.query}"` : "" };
+    }
+    if (isTodo) {
+        const todos = Array.isArray(inp.todos) ? inp.todos : [];
+        const done = todos.filter((t) => t.status === "completed").length;
+        return { icon: HASH, color: GRAY, title: "Todos", detail: `${done}/${todos.length} done` };
+    }
+    if (isTask) {
+        return { icon: HASH, color: CYAN, title: "Task", detail: inp.description || "" };
+    }
+    // Fallback
+    return { icon: GEAR, color: GRAY, title: toolName };
+}
+function renderToolStart(d) {
+    const detail = d.detail ? ` ${GRAY}${d.detail}${R}` : "";
+    nl(`   ${d.color}${d.icon}${R} ${WHITE}${d.title}${R}${detail}`);
+}
+function renderToolDone(d, ms) {
+    const detail = d.detail ? ` ${GRAY}${d.detail}${R}` : "";
+    const time = ms !== undefined ? `  ${GRAY}${(ms / 1000).toFixed(1)}s${R}` : "";
+    // Replace the "..." with a checkmark (or just write a new line if not interactive)
+    nl(`   ${GREEN}✓${R} ${GRAY}${d.title}${R}${detail}${time}`);
+}
+function renderToolError(d, err) {
+    const detail = d.detail ? ` ${GRAY}${d.detail}${R}` : "";
+    nl(`   ${RED}✗${R} ${GRAY}${d.title}${R}${detail}  ${RED}${err}${R}`);
+}
+// ─── User message rendering ───────────────────────────────────────────────────
+function renderUserMessage(text) {
+    nl();
+    for (const line of text.split("\n")) {
+        nl(`${GRAY}${VERT}${R}  ${WHITE}${line}${R}`);
+    }
+    nl();
+}
+function renderTurnEnd(model, elapsedMs, interrupted) {
+    const elapsed = (elapsedMs / 1000).toFixed(1);
+    const dur = interrupted ? `${YELLOW}interrupted${R}` : `${GRAY}${elapsed}s${R}`;
+    nl();
+    nl(`   ${CYAN}${BLOCK}${R}  ${WHITE}Build${R}${GRAY} · ${model} · ${R}${dur}`);
+}
+// ─── Help / providers / commands menu ─────────────────────────────────────────
+function printHelp() {
+    nl();
+    nl(`${CYAN}${BOLD}BoneCode${R} ${GRAY}commands${R}`);
+    nl();
+    for (const c of COMMANDS) {
+        const args = c.args ? ` ${GRAY}${c.args}${R}` : "";
+        nl(`  ${CYAN}${c.name.padEnd(12)}${R}${args.padEnd(20)}  ${GRAY}${c.description}${R}`);
+    }
+    nl();
+    nl(`  ${CYAN}Ctrl+C${R}        ${GRAY}Interrupt current request${R}`);
+    nl(`  ${CYAN}Ctrl+D${R}        ${GRAY}Exit BoneCode${R}`);
+    nl(`  ${CYAN}↑ / ↓${R}         ${GRAY}Prompt history${R}`);
+    nl(`  ${CYAN}@<path>${R}       ${GRAY}Attach a file (Tab completes)${R}`);
+    nl();
+}
+async function fetchProviders(port, token) {
+    try {
+        return await apiGet(`http://localhost:${port}/v2/provider`, token);
+    }
+    catch {
+        return [];
+    }
+}
+function printProviders(providers, currentProvider) {
+    const width = cols();
+    nl();
+    nl(`${CYAN}${BOLD}Providers${R}`);
+    nl(`${GRAY}${"─".repeat(Math.min(width, 56))}${R}`);
+    for (const p of providers) {
+        const active = p.id === currentProvider;
+        const dot = active ? `${GREEN}●${R}` : `${GRAY}○${R}`;
+        const free = p.free ? ` ${GREEN}free${R}` : "";
+        const local = p.id === "local" ? ` ${CYAN}local config${R}` : "";
+        nl(`  ${dot} ${active ? CYAN + BOLD : WHITE}${p.id}${R}${free}${local}  ${GRAY}${p.name}${R}`);
+        if (p.freeNote)
+            nl(`       ${GRAY}${p.freeNote}${R}`);
+        if (p.models?.length)
+            nl(`       ${GRAY}${p.models.slice(0, 3).join("  ")}${R}`);
+        if (p.keyEnv)
+            nl(`       ${GRAY}${p.keyEnv}${R}`);
+    }
+    nl(`${GRAY}${"─".repeat(Math.min(width, 56))}${R}`);
+    nl(`  ${GRAY}/provider <id>   /model <id>${R}`);
+    nl();
+}
+/**
+ * Stateful code-fence collapser.
+ *
+ * The LLM streams text token-by-token, including ```python\n...\n``` blocks.
+ * We don't want to dump that raw to the terminal because:
+ *   (a) The code is going to be saved via a tool call anyway, so showing it
+ *       twice (raw stream + saved file path) is redundant.
+ *   (b) It can be 100s of lines long and overwhelms the TUI.
+ *
+ * Strategy: buffer everything between ``` and ```. When the closing fence
+ * arrives, emit a one-line marker like  [code: python, 42 lines]
+ * instead of the buffered content.
+ *
+ * State machine:
+ *   "text"  — pass deltas through verbatim (with partial-fence detection)
+ *   "fence" — buffer everything; emit marker on close fence
+ */
+function makeCodeFenceCollapser() {
+    let mode = "text";
+    let lang = "";
+    let buffered = ""; // bytes accumulated inside a fence
+    let pending = ""; // partial-fence buffer (when we see backticks but don't know yet)
+    const lines = (s) => s.split("\n").length;
+    function flushPending() {
+        const out = pending;
+        pending = "";
+        return out;
+    }
+    return {
+        feed(chunk) {
+            let result = "";
+            let i = 0;
+            const buf = pending + chunk;
+            pending = "";
+            while (i < buf.length) {
+                if (mode === "text") {
+                    // Look for ``` to enter fence mode
+                    const fenceIdx = buf.indexOf("```", i);
+                    if (fenceIdx === -1) {
+                        // No fence in remaining text — emit it all, but hold the last 2 chars
+                        // in case they're part of an upcoming fence.
+                        const safeEnd = Math.max(i, buf.length - 2);
+                        result += buf.slice(i, safeEnd);
+                        pending = buf.slice(safeEnd);
+                        i = buf.length;
+                        break;
+                    }
+                    // Emit text up to the fence
+                    result += buf.slice(i, fenceIdx);
+                    // Read the language (everything until newline)
+                    const nlIdx = buf.indexOf("\n", fenceIdx + 3);
+                    if (nlIdx === -1) {
+                        // Don't have the full opening line yet — buffer
+                        pending = buf.slice(fenceIdx);
+                        i = buf.length;
+                        break;
+                    }
+                    lang = buf.slice(fenceIdx + 3, nlIdx).trim() || "code";
+                    i = nlIdx + 1;
+                    mode = "fence";
+                    buffered = "";
+                    // Print a leading marker (will be amended when we close)
+                    result += `${GRAY}┃ code: ${lang}…${R}`;
+                    continue;
+                }
+                // mode === "fence" — look for closing ```
+                const closeIdx = buf.indexOf("```", i);
+                if (closeIdx === -1) {
+                    buffered += buf.slice(i);
+                    // Hold last 2 chars in case they're part of an upcoming close fence
+                    const safeEnd = Math.max(i, buf.length - 2);
+                    buffered = buffered.slice(0, buffered.length - (buf.length - safeEnd));
+                    pending = buf.slice(safeEnd);
+                    i = buf.length;
+                    break;
+                }
+                // Closing fence found
+                buffered += buf.slice(i, closeIdx);
+                const lineCount = lines(buffered.replace(/\n+$/, ""));
+                // Replace the placeholder we already wrote with the final marker.
+                // Carriage return + clear line + reprint marker.
+                result += `\r${ESC}[2K   ${GRAY}┃ code: ${lang}, ${lineCount} line${lineCount === 1 ? "" : "s"}${R}\n`;
+                i = closeIdx + 3;
+                // Skip optional newline after closing fence
+                if (buf[i] === "\n")
+                    i++;
+                mode = "text";
+                lang = "";
+                buffered = "";
+            }
+            return result;
+        },
+        flush() {
+            const tail = flushPending();
+            if (mode === "fence") {
+                // Stream ended mid-fence — close it with an approximate count
+                const lineCount = lines(buffered.replace(/\n+$/, ""));
+                mode = "text";
+                return tail + `\r${ESC}[2K   ${GRAY}┃ code: ${lang}, ${lineCount}+ lines${R}\n`;
+            }
+            return tail;
+        },
+    };
+}
+async function streamPrompt(opts) {
+    const { port, token, sessionId, model, provider, message, worktree, abortSignal } = opts;
+    const t0 = Date.now();
+    let fullText = "";
+    let tokens = 0;
+    let inAssistantText = false;
+    let tools = new Map();
+    // Code-fence collapser — replaces ```...``` blocks with [code: lang, N lines]
+    // markers across delta boundaries.
+    const fence = makeCodeFenceCollapser();
+    const collapseCodeFences = (chunk) => fence.feed(chunk);
+    // Track which message the deltas belong to so we can detect tool boundaries
+    // The compat adapter emits these event types:
+    //   part.delta       — text chunk
+    //   tool.requested   — tool call started
+    //   message.updated  — message saved
+    //   session.updated  — session state changed
+    //   error            — error event
+    const flushTextLine = () => {
+        if (inAssistantText) {
+            // Make sure assistant text ends with a newline before the next thing
+            if (fullText && !fullText.endsWith("\n"))
+                out("\n");
+            inAssistantText = false;
+        }
+    };
+    try {
+        const r = await fetch(`http://localhost:${port}/v2/session/${sessionId}/prompt`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json", "Authorization": `Bearer ${token}` },
+            body: JSON.stringify({ content: message, modelID: model, providerID: provider }),
+            signal: abortSignal,
+        });
+        if (!r.ok) {
+            return { text: "", tokens: 0, elapsedMs: Date.now() - t0, error: `HTTP ${r.status}: ${await r.text()}`, interrupted: false };
+        }
+        const reader = r.body.getReader();
+        const dec = new TextDecoder();
+        let buf = "";
+        while (true) {
+            const { value, done } = await reader.read();
+            if (done)
+                break;
+            buf += dec.decode(value, { stream: true });
+            const lines = buf.split("\n");
+            buf = lines.pop() || "";
+            for (const raw of lines) {
+                if (!raw.startsWith("data: "))
+                    continue;
+                const json = raw.slice(6).trim();
+                if (!json || json === "[DONE]")
+                    continue;
+                try {
+                    const ev = JSON.parse(json);
+                    // Text delta — assistant is generating prose
+                    if (ev.type === "part.delta" && ev.delta?.type === "text") {
+                        const text = ev.delta.text || "";
+                        if (!text)
+                            continue;
+                        if (!inAssistantText) {
+                            // Start of assistant text — print the indent prefix once
+                            out(`   `);
+                            inAssistantText = true;
+                        }
+                        // Process the delta through the code-fence collapser so streaming
+                        // code blocks appear as "[code: lang]" placeholders instead of
+                        // dumping raw source.
+                        const piece = collapseCodeFences(text);
+                        // Print with leading-newline indenting (so each new line gets the 3-space prefix)
+                        const indented = piece.replace(/\n/g, `\n   `);
+                        out(indented);
+                        fullText += text;
+                        continue;
+                    }
+                    // Tool requested — show concise activity line
+                    if (ev.type === "tool.requested") {
+                        flushTextLine();
+                        const callId = ev.tool_call_id || ev.id || `${ev.tool_name}-${Date.now()}`;
+                        const display = describeTool(ev.tool_name || "tool", ev.tool_input || {}, worktree);
+                        tools.set(callId, { callId, display, startedAt: Date.now() });
+                        renderToolStart(display);
+                        continue;
+                    }
+                    // Tool completed
+                    if (ev.type === "tool.completed" || ev.type === "tool.success") {
+                        flushTextLine();
+                        const callId = ev.tool_call_id || ev.id || "";
+                        const tracked = tools.get(callId);
+                        if (tracked) {
+                            const ms = Date.now() - tracked.startedAt;
+                            renderToolDone(tracked.display, ms);
+                            tools.delete(callId);
+                        }
+                        continue;
+                    }
+                    // Tool failed
+                    if (ev.type === "tool.failed" || ev.type === "tool.error") {
+                        flushTextLine();
+                        const callId = ev.tool_call_id || ev.id || "";
+                        const tracked = tools.get(callId);
+                        const err = ev.error || ev.message || "failed";
+                        if (tracked) {
+                            renderToolError(tracked.display, err);
+                            tools.delete(callId);
+                        }
+                        else {
+                            nl(`   ${RED}✗ ${err}${R}`);
+                        }
+                        continue;
+                    }
+                    // Retry notification
+                    if (ev.type === "session.retry") {
+                        flushTextLine();
+                        nl(`   ${YELLOW}⟳ Retry ${ev.attempt || ""}: ${ev.message || ""}${R}`);
+                        continue;
+                    }
+                    // Server-side error
+                    if (ev.type === "error") {
+                        flushTextLine();
+                        return {
+                            text: fullText,
+                            tokens,
+                            elapsedMs: Date.now() - t0,
+                            error: ev.properties?.message || "error",
+                            interrupted: false,
+                        };
+                    }
+                    // Compaction
+                    if (ev.type === "session.compacted") {
+                        flushTextLine();
+                        nl(`   ${BLUE}⊕ Context compacted${R}`);
+                        continue;
+                    }
+                }
+                catch {
+                    // Ignore malformed events
+                }
+            }
+        }
+        flushTextLine();
+        // Drain any tools that didn't get a completion event
+        for (const tracked of tools.values()) {
+            const ms = Date.now() - tracked.startedAt;
+            renderToolDone(tracked.display, ms);
+        }
+        tools.clear();
+        // Flush any unclosed code fence
+        const tail = fence.flush();
+        if (tail)
+            out(tail);
+        // Fetch the final message to get token totals
+        try {
+            const msgs = await apiGet(`http://localhost:${port}/v2/session/${sessionId}/message`, token);
+            const last = msgs.filter((m) => m.role === "assistant").slice(-1)[0];
+            tokens = (last?.tokens?.input || 0) + (last?.tokens?.output || 0);
+            // If we didn't get any text deltas but the stored message has text, render it now
+            if (!fullText && last?.parts) {
+                for (const p of last.parts) {
+                    if (p.type === "text" && p.text) {
+                        out(`   ${p.text.replace(/\n/g, `\n   `)}\n`);
+                        fullText = p.text;
+                        break;
+                    }
+                }
+            }
+        }
+        catch { }
+        return { text: fullText, tokens, elapsedMs: Date.now() - t0, interrupted: false };
+    }
+    catch (e) {
+        flushTextLine();
+        if (e.name === "AbortError") {
+            return { text: fullText, tokens, elapsedMs: Date.now() - t0, interrupted: true };
+        }
+        return { text: fullText, tokens, elapsedMs: Date.now() - t0, error: e.message, interrupted: false };
+    }
+}
+function filterCommands(query) {
+    if (!query || query === "/")
+        return COMMANDS;
+    const q = query.toLowerCase();
+    return COMMANDS.filter(c => c.name.toLowerCase().startsWith(q));
+}
+function renderCommandMenu(state) {
+    if (!state.visible || state.options.length === 0)
+        return 0;
+    const max = Math.min(state.options.length, 8);
+    for (let i = 0; i < max; i++) {
+        const c = state.options[i];
+        const selected = i === state.selected;
+        const prefix = selected ? `${CYAN}▌${R} ` : `  `;
+        const name = selected ? `${CYAN}${BOLD}${c.name}${R}` : `${WHITE}${c.name}${R}`;
+        const args = c.args ? ` ${GRAY}${c.args}${R}` : "";
+        const desc = `${GRAY}${c.description}${R}`;
+        nl(`${prefix}${name}${args}  ${desc}`);
+    }
+    if (state.options.length > max) {
+        nl(`  ${GRAY}... ${state.options.length - max} more (keep typing)${R}`);
+        return max + 1;
+    }
+    return max;
+}
+function clearMenu(rows) {
+    if (rows <= 0)
+        return;
+    // Move up `rows` lines and clear each one
+    for (let i = 0; i < rows; i++) {
+        out(`${ESC}[1A${ESC}[2K`);
+    }
+}
+// ─── Main TUI loop ────────────────────────────────────────────────────────────
+async function runTUI(opts) {
+    let { model, provider } = opts;
+    const { port, token, worktree } = opts;
+    let sessionId = opts.sessionId || null;
+    const history = [];
+    let abort = null;
+    let streaming = false;
+    // Initial session
+    if (!sessionId) {
+        try {
+            sessionId = await createSession(port, token, worktree, "BoneCode Session");
+        }
+        catch (e) {
+            process.stderr.write(`${RED}Failed to create session: ${e.message}${R}\n`);
+            process.exit(1);
+        }
+    }
+    // Header
+    printLogo();
+    nl(`  ${GRAY}v${getVersion()}  ·  ${model}  ·  ${path.basename(worktree)}${R}`);
+    nl(`  ${GRAY}session ${sessionId.slice(0, 8)}${R}`);
+    nl();
+    nl(`  ${GRAY}Type ${R}${CYAN}/${R}${GRAY} to see commands  ·  Ctrl+C interrupt  ·  Ctrl+D exit${R}`);
+    nl();
+    // ─── Slash command menu state ──────────────────────────────────────────────
+    const menu = {
+        visible: false,
+        options: [],
+        selected: 0,
+        rowsRendered: 0,
+    };
+    // Set up readline AFTER setting up SIGINT so we control it
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+        terminal: true,
+        historySize: 200,
+        completer: buildCompleter(worktree),
+    });
+    const promptStr = () => `${CYAN}${BOLD}>${R} `;
+    // ─── Ctrl+C handling ──────────────────────────────────────────────────────
+    // When streaming: abort the request AND notify server
+    // When idle: clear menu/input or hint to use /exit
+    const onSigint = async () => {
+        if (streaming && abort) {
+            abort.abort();
+            // Also tell the server to cancel the agent loop
+            try {
+                await fetch(`http://localhost:${port}/v2/session/${sessionId}/cancel`, {
+                    method: "POST",
+                    headers: { "Authorization": `Bearer ${token}` },
+                });
+            }
+            catch { /* server may not have the endpoint, abort is enough */ }
+            // Don't reprompt here — the streamPrompt finally block will handle UI
+            return;
+        }
+        // Idle: clear menu if visible, else hint
+        if (menu.visible) {
+            clearMenu(menu.rowsRendered);
+            menu.visible = false;
+            menu.rowsRendered = 0;
+            menu.selected = 0;
+        }
+        out(`\n${GRAY}(Ctrl+D or /exit to quit)${R}\n`);
+        rl.setPrompt(promptStr());
+        rl.prompt();
+    };
+    // Detach readline's default SIGINT (which closes the line buffer)
+    // and route it to our handler.
+    rl.on("SIGINT", onSigint);
+    rl.on("close", () => {
+        if (streaming && abort)
+            abort.abort();
+        nl(`\n${GRAY}Goodbye.${R}`);
+        process.exit(0);
+    });
+    // ─── Live menu update on every keystroke ──────────────────────────────────
+    // We hook into the keypress events of stdin to redraw the menu.
+    // The menu sits ABOVE the prompt line.
+    const stdin = rl.input;
+    const updateMenu = () => {
+        if (streaming)
+            return;
+        const line = rl.line || "";
+        const startsWithSlash = line.startsWith("/");
+        const shouldShow = startsWithSlash && !line.includes(" ");
+        if (!shouldShow) {
+            if (menu.visible) {
+                // Need to clear the menu — but we need to preserve the current input line.
+                // Strategy: save current line content & cursor, clear menu lines above,
+                // then restore the prompt and content.
+                const cursor = rl.cursor || 0;
+                out(`\r${ESC}[2K`); // clear current prompt line
+                clearMenu(menu.rowsRendered); // clear menu lines above
+                menu.visible = false;
+                menu.rowsRendered = 0;
+                menu.selected = 0;
+                // Redraw prompt + line
+                out(promptStr() + line);
+                // Restore cursor position
+                const drawn = line.length;
+                if (cursor < drawn) {
+                    out(`${ESC}[${drawn - cursor}D`);
+                }
+            }
+            return;
+        }
+        // Filter and reset selection if list changed
+        const newOptions = filterCommands(line);
+        if (newOptions.length === 0) {
+            // Clear menu if visible
+            if (menu.visible) {
+                const cursor = rl.cursor || 0;
+                out(`\r${ESC}[2K`);
+                clearMenu(menu.rowsRendered);
+                menu.visible = false;
+                menu.rowsRendered = 0;
+                out(promptStr() + line);
+                if (cursor < line.length)
+                    out(`${ESC}[${line.length - cursor}D`);
+            }
+            return;
+        }
+        // Save current input line
+        const cursor = rl.cursor || 0;
+        out(`\r${ESC}[2K`); // clear prompt line
+        clearMenu(menu.rowsRendered); // clear old menu
+        menu.options = newOptions;
+        menu.selected = Math.min(menu.selected, newOptions.length - 1);
+        if (menu.selected < 0)
+            menu.selected = 0;
+        menu.visible = true;
+        // Render the menu (each item ends in newline)
+        menu.rowsRendered = renderCommandMenu(menu);
+        // Redraw prompt + line
+        out(promptStr() + line);
+        if (cursor < line.length) {
+            out(`${ESC}[${line.length - cursor}D`);
+        }
+    };
+    // Capture special keys for menu navigation
+    const onKeypress = (_chunk, key) => {
+        if (!key)
+            return;
+        if (streaming)
+            return;
+        if (menu.visible && menu.options.length > 0) {
+            // Arrow up/down navigate the menu
+            if (key.name === "up") {
+                menu.selected = (menu.selected - 1 + menu.options.length) % menu.options.length;
+                updateMenu();
+                return;
+            }
+            if (key.name === "down") {
+                menu.selected = (menu.selected + 1) % menu.options.length;
+                updateMenu();
+                return;
+            }
+            // Tab: replace input with the selected command
+            if (key.name === "tab") {
+                const sel = menu.options[menu.selected];
+                if (sel) {
+                    // Replace the line buffer with the command + space
+                    rl.line = sel.name + " ";
+                    rl.cursor = sel.name.length + 1;
+                    updateMenu();
+                    out(`\r${ESC}[2K`);
+                    out(promptStr() + rl.line);
+                }
+                return;
+            }
+        }
+        // Default: trigger menu update on the next tick (after readline updates the buffer)
+        setImmediate(updateMenu);
+    };
+    stdin.on("keypress", onKeypress);
+    rl.setPrompt(promptStr());
+    rl.prompt();
+    // ─── Main input loop ──────────────────────────────────────────────────────
+    for await (const rawLine of rl) {
+        const text = rawLine.trim();
+        // Clear any visible menu before processing
+        if (menu.visible) {
+            menu.visible = false;
+            menu.rowsRendered = 0;
+            menu.selected = 0;
+        }
+        if (!text) {
+            rl.setPrompt(promptStr());
+            rl.prompt();
+            continue;
+        }
+        history.push(text);
+        if (history.length > 200)
+            history.shift();
+        // ── Slash commands ──────────────────────────────────────────────────────
+        if (text.startsWith("/")) {
+            const parts = text.slice(1).trim().split(/\s+/);
+            const cmd = parts[0]?.toLowerCase() || "";
+            const args = parts.slice(1);
+            switch (cmd) {
+                case "help":
+                case "h":
+                    printHelp();
+                    break;
+                case "new":
+                    try {
+                        sessionId = await createSession(port, token, worktree, "New Session");
+                        nl(`${GREEN}✓${R} ${GRAY}session ${sessionId.slice(0, 8)}${R}`);
+                    }
+                    catch (e) {
+                        nl(`${RED}✗ ${e.message}${R}`);
+                    }
+                    break;
+                case "session":
+                    nl(`${GRAY}${sessionId}${R}`);
+                    break;
+                case "sessions": {
+                    try {
+                        const list = await apiGet(`http://localhost:${port}/v2/session?limit=10`, token);
+                        if (!list.length) {
+                            nl(`${GRAY}No sessions${R}`);
+                            break;
+                        }
+                        nl();
+                        for (const s of list) {
+                            const active = s.id === sessionId;
+                            const dot = active ? `${GREEN}●${R}` : `${GRAY}○${R}`;
+                            const t = new Date(s.time?.updated || Date.now()).toLocaleString();
+                            nl(`  ${dot} ${WHITE}${(s.title || "untitled").slice(0, 50).padEnd(50)}${R}  ${GRAY}${t}${R}`);
+                        }
+                        nl();
+                    }
+                    catch (e) {
+                        nl(`${RED}✗ ${e.message}${R}`);
+                    }
+                    break;
+                }
+                case "model":
+                    if (args[0]) {
+                        if (args[0] === "local") {
+                            provider = process.env.DEFAULT_PROVIDER || "openai_compatible";
+                            model = process.env.DEFAULT_MODEL || "local-model";
+                        }
+                        else if (args[0].includes("/")) {
+                            const i = args[0].indexOf("/");
+                            provider = args[0].slice(0, i);
+                            model = args[0].slice(i + 1);
+                        }
+                        else {
+                            model = args[0];
+                        }
+                        nl(`${GREEN}✓${R} ${WHITE}${provider}/${model}${R}`);
+                    }
+                    else {
+                        nl(`${GRAY}${provider}/${model}${R}`);
+                    }
+                    break;
+                case "provider":
+                    if (args[0]) {
+                        if (args[0] === "local") {
+                            provider = process.env.DEFAULT_PROVIDER || "openai_compatible";
+                            model = process.env.DEFAULT_MODEL || "local-model";
+                            nl(`${GREEN}✓${R} ${WHITE}${provider}/${model}${R}`);
+                        }
+                        else {
+                            provider = args[0];
+                            nl(`${GREEN}✓${R} ${WHITE}${provider}${R}  ${GRAY}use /model <id> to set model${R}`);
+                        }
+                    }
+                    else {
+                        nl(`${GRAY}${provider}${R}`);
+                    }
+                    break;
+                case "providers": {
+                    const list = await fetchProviders(port, token);
+                    if (list.length)
+                        printProviders(list, provider);
+                    else
+                        nl(`${YELLOW}Could not fetch providers${R}`);
+                    break;
+                }
+                case "clear":
+                    process.stdout.write(`${ESC}[2J${ESC}[H`);
+                    printLogo();
+                    break;
+                case "history":
+                    if (!history.length)
+                        nl(`${GRAY}No history${R}`);
+                    else
+                        history.slice(-10).forEach((h, i) => nl(`  ${GRAY}${i + 1}.${R} ${h.slice(0, 80)}`));
+                    break;
+                case "exit":
+                case "quit":
+                case "q":
+                    nl(`\n${GRAY}Goodbye.${R}`);
+                    process.exit(0);
+                    break;
+                default:
+                    nl(`${YELLOW}Unknown: /${cmd}${R}  ${GRAY}Type /help for available commands${R}`);
+            }
+            rl.setPrompt(promptStr());
+            rl.prompt();
+            continue;
+        }
+        // ── Prompt to the agent ─────────────────────────────────────────────────
+        if (!sessionId) {
+            try {
+                sessionId = await createSession(port, token, worktree, text.slice(0, 50));
+            }
+            catch (e) {
+                nl(`${RED}✗ ${e.message}${R}`);
+                rl.setPrompt(promptStr());
+                rl.prompt();
+                continue;
+            }
+        }
+        // Resolve @file mentions to absolute paths
+        const resolved = text.replace(/@([\w./\-]+)/g, (match, fp) => {
+            const abs = path.isAbsolute(fp) ? fp : path.resolve(worktree, fp);
+            return fs.existsSync(abs) ? `@${abs}` : match;
+        });
+        renderUserMessage(text);
+        // Show "..." spinner so the user knows something is happening
+        out(`   ${GRAY}thinking...${R}`);
+        rl.pause();
+        streaming = true;
+        abort = new AbortController();
+        const t0 = Date.now();
+        const result = await streamPrompt({
+            port, token, sessionId,
+            model, provider,
+            message: resolved,
+            worktree,
+            abortSignal: abort.signal,
+        });
+        streaming = false;
+        abort = null;
+        // Clear the thinking spinner if no output happened
+        if (!result.text && !result.error) {
+            clearLine();
+        }
+        else {
+            // Make sure the next render starts on a clean line
+            const cur = process.stdout.cursor;
+            if (cur && cur.col !== 0)
+                out("\n");
+        }
+        renderTurnEnd(model, result.elapsedMs, result.interrupted);
+        if (result.error && !result.interrupted) {
+            nl(`   ${RED}✗ ${result.error}${R}`);
+        }
+        nl();
+        rl.resume();
+        rl.setPrompt(promptStr());
+        rl.prompt();
+    }
+    stdin.removeListener("keypress", onKeypress);
+}
+exports.runTUI = runTUI;
+// ─── Entry point ──────────────────────────────────────────────────────────────
+async function startInteractiveTUI(opts) {
+    const ready = await waitForServer(opts.port, 30000);
+    if (!ready) {
+        process.stderr.write(`${RED}BoneCode server not responding on port ${opts.port}${R}\n`);
+        process.stderr.write(`${GRAY}Start with: bonecode serve${R}\n`);
+        process.exit(1);
+    }
+    await runTUI(opts);
+}
+exports.startInteractiveTUI = startInteractiveTUI;
+//# sourceMappingURL=tui.js.map