@breviqcode/cli 0.1.0

package/dist/tui/App.js

@@ -0,0 +1,894 @@
+import { jsxs as _jsxs, Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
+import { randomBytes } from "node:crypto";
+import { Box, render, Static, Text, useApp, useInput } from "ink";
+import Spinner from "ink-spinner";
+import { useEffect, useRef, useState } from "react";
+import { Loop, SecretStore, UserConfig } from "@breviqcode/core";
+import { buildRuntime, configPath } from "../runtime.js";
+import { extractResumeId } from "../flags.js";
+import { buildProviderNamed } from "../provider.js";
+import { PROVIDER_PRESETS } from "../provider-presets.js";
+import { runOnboarding } from "../onboarding.js";
+import { systemMessage } from "../system-prompt.js";
+import { loadCustomCommands, expandCommand } from "../custom-commands.js";
+import { formatTodoChecklist, formatToolCallLabel, formatToolResultDetail, TOOLS_WITH_OWN_UI } from "./format-tool-call.js";
+/** The slash-command palette's source of truth — shown as a filterable,
+ * arrow-navigable menu the moment the input starts with "/", matching
+ * Claude Code's own behavior (type "/" to see everything, keep typing to
+ * filter, ↑/↓ to navigate, Enter to run, Tab to complete). */
+const SLASH_COMMANDS = [
+    { name: "model", args: "<name>", description: "Switch the model for this session" },
+    { name: "provider", description: "Switch provider (OpenAI, Anthropic, Gemini, Groq, local, ...)" },
+    { name: "resume", args: "<id>", description: "Resume a previous session (no id opens a picker)" },
+    { name: "mcp", description: "List configured MCP servers and their tools" },
+    { name: "plan", description: "Switch to plan mode (read-only until you approve a plan)" },
+    { name: "build", description: "Switch to build mode (all tools available)" },
+    { name: "clear", description: "Clear conversation context (history on disk is kept)" },
+    { name: "help", description: "Show commands and tips" },
+    { name: "exit", description: "Quit BreviqCode" },
+];
+const CONFIRM_OPTIONS = [
+    { label: "Yes", approve: true, remember: false },
+    { label: "Yes, allow always this session", approve: true, remember: true },
+    { label: "No", approve: false, remember: false },
+];
+let nextEntryId = 1;
+/**
+ * The interactive, stay-open TUI — this project's equivalent of the Go
+ * version's Bubble Tea interface, built with Ink/React instead (matching
+ * Claude Code's own real stack, per the research behind this whole
+ * rewrite). Unlike the one-shot `breviq chat` command (send one message,
+ * stream the reply, exit), this keeps one process alive across many turns,
+ * reusing the exact same runtime wiring via `buildRuntime` — the same
+ * tools, gate, session store, symbol index, and LSP manager, just kept
+ * alive instead of torn down after one message.
+ *
+ * Tool calls render as a two-line "⏺ Label(args)" / "  ⎿ detail" block —
+ * matching Claude Code's/OpenCode's own tool-call presentation — rather
+ * than a flat status line, and the input sits in a bordered box (colored
+ * by agent mode) rather than a plain text prompt, since a bare `[build] >`
+ * line was reported live as looking nothing like either tool's actual UI.
+ *
+ * The permission-confirmation `Prompter` and the `question` tool's `Asker`
+ * are implemented as plain closures over this component's own `useState`
+ * setters — no external pub/sub bridge needed, since `buildRuntime` (and
+ * everything it constructs) is only ever built *inside* this component's
+ * effect, after Ink already owns the render tree. Gate/tools calling
+ * `prompt()`/`ask()` from deep inside a tool-call chain just resolves to
+ * "set some state and return a Promise the state-driven UI resolves later"
+ * — normal React state updates are safe to call from any async context,
+ * not just event handlers.
+ */
+export function App({ continueSession, initialAgentMode, resumeSessionId, }) {
+    const { exit } = useApp();
+    const [uiMode, setUiMode] = useState("loading");
+    const [transcript, setTranscript] = useState([]);
+    const [streamingText, setStreamingText] = useState("");
+    const [inputBuffer, setInputBuffer] = useState("");
+    const [pendingConfirm, setPendingConfirm] = useState();
+    const [pendingQuestion, setPendingQuestion] = useState();
+    const [model, setModel] = useState("");
+    const [agentModeDisplay, setAgentModeDisplay] = useState(initialAgentMode);
+    const runtimeRef = useRef(undefined);
+    const conversationRef = useRef([]);
+    const activeToolRef = useRef(undefined);
+    const [activeToolLabel, setActiveToolLabel] = useState(undefined);
+    // One shared selection index for whichever arrow-navigable list is
+    // currently visible (slash palette, confirm options, question options,
+    // model picker) — only one of those can ever be on screen at a time.
+    const [selectedIndex, setSelectedIndex] = useState(0);
+    // Model ids fetched from the provider's live listing endpoint for the
+    // /model picker; inputBuffer doubles as its filter text while open.
+    const [modelChoices, setModelChoices] = useState([]);
+    // The preset being switched to via /provider, while its base-URL/key
+    // questions are still being answered in the TUI.
+    const [providerDraft, setProviderDraft] = useState();
+    // Past sessions fetched for the /resume picker (id, creation time, and a
+    // preview of the first user message); inputBuffer doubles as its filter
+    // text, same convention as the /model picker.
+    const [sessionChoices, setSessionChoices] = useState([]);
+    // Project-level commands loaded from .breviqcode/commands/*.md, merged
+    // into the slash palette alongside the built-in SLASH_COMMANDS.
+    const [customCommands, setCustomCommands] = useState([]);
+    // The visible slash palette entries for the current input, or [] when
+    // the palette shouldn't show (input doesn't start with "/", or args are
+    // already being typed after a completed command name).
+    const paletteMatches = (() => {
+        if (uiMode !== "input" || !inputBuffer.startsWith("/"))
+            return [];
+        const afterSlash = inputBuffer.slice(1);
+        if (afterSlash.includes(" "))
+            return []; // command chosen, user is typing args now
+        const allCommands = [
+            ...SLASH_COMMANDS,
+            ...customCommands.map((c) => ({ name: c.name, args: c.argsHint, description: c.description })),
+        ];
+        return allCommands.filter((c) => c.name.startsWith(afterSlash.toLowerCase()));
+    })();
+    function pushTranscript(kind, text) {
+        setTranscript((prev) => [...prev, { id: nextEntryId++, kind, text }]);
+    }
+    function pushToolResult(label, detail, isError) {
+        setTranscript((prev) => [
+            ...prev,
+            { id: nextEntryId++, kind: "tool", text: "", toolLabel: label, toolDetail: detail, toolError: isError },
+        ]);
+    }
+    // Shared by the initial startup effect and resumeSession() below — both
+    // need a fresh Prompter/Asker closing over the same setState setters.
+    function makePrompter() {
+        return (toolName, argsJson, dangerous) => new Promise((resolve) => {
+            setPendingConfirm({ toolName, argsJson, dangerous, resolve });
+            setSelectedIndex(0);
+            setUiMode("confirm");
+        });
+    }
+    function makeAsker() {
+        return (question, options) => new Promise((resolve) => {
+            setPendingQuestion({ question, options, resolve });
+            setSelectedIndex(0);
+            setUiMode("question");
+        });
+    }
+    useEffect(() => {
+        let cancelled = false;
+        void (async () => {
+            const prompt = makePrompter();
+            const ask = makeAsker();
+            let runtime;
+            try {
+                runtime = await buildRuntime({
+                    prompt,
+                    ask,
+                    initialMode: initialAgentMode,
+                    continueSession,
+                    newSessionId: randomBytes(8).toString("hex"),
+                    resumeSessionId,
+                    onSubAgentStatus: (text) => pushTranscript("status", text),
+                });
+            }
+            catch (err) {
+                // A bad --resume <id> is the one way buildRuntime can fail here —
+                // degrade to a fresh session instead of leaving the TUI stuck on
+                // the startup spinner forever.
+                if (!resumeSessionId)
+                    throw err;
+                pushTranscript("status", `couldn't resume session "${resumeSessionId}": ${err instanceof Error ? err.message : String(err)} — starting a fresh session instead`);
+                runtime = await buildRuntime({
+                    prompt,
+                    ask,
+                    initialMode: initialAgentMode,
+                    continueSession,
+                    newSessionId: randomBytes(8).toString("hex"),
+                    onSubAgentStatus: (text) => pushTranscript("status", text),
+                });
+            }
+            if (cancelled) {
+                await runtime.close();
+                return;
+            }
+            runtimeRef.current = runtime;
+            setModel(runtime.model);
+            setCustomCommands(loadCustomCommands(runtime.projectRoot));
+            conversationRef.current = [
+                systemMessage(runtime.projectRoot, initialAgentMode, runtime.projectInstructions),
+                ...runtime.history,
+            ];
+            for (const m of runtime.history) {
+                if (m.role === "user")
+                    pushTranscript("user", m.content);
+                else if (m.role === "assistant" && m.content)
+                    pushTranscript("assistant", m.content);
+            }
+            setUiMode("input");
+        })();
+        return () => {
+            cancelled = true;
+            void runtimeRef.current?.close();
+        };
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, []);
+    async function submit(text) {
+        const trimmed = text.trim();
+        if (!trimmed)
+            return;
+        if (trimmed.startsWith("/")) {
+            handleSlashCommand(trimmed);
+            return;
+        }
+        await sendToModel(trimmed);
+    }
+    /** Pushes one user turn and runs it through the model — shared by plain
+     * typed input and an expanded custom slash-command's prompt, so both go
+     * through identical tool-call rendering/history-persistence logic rather
+     * than duplicating it. */
+    async function sendToModel(trimmed) {
+        const runtime = runtimeRef.current;
+        if (!runtime)
+            return;
+        const preSubmit = await runtime.hooks.runUserPromptSubmit(trimmed);
+        if (preSubmit.block) {
+            pushTranscript("status", `prompt blocked by hook: ${preSubmit.reason ?? "denied"}`);
+            return;
+        }
+        pushTranscript("user", trimmed);
+        conversationRef.current.push({ role: "user", content: trimmed });
+        runtime.store.appendMessage(runtime.sessionId, "user", trimmed);
+        setUiMode("busy");
+        setStreamingText("");
+        activeToolRef.current = undefined;
+        setActiveToolLabel(undefined);
+        const loop = new Loop({
+            provider: runtime.provider,
+            tools: runtime.registry,
+            gate: runtime.gate,
+            hooks: runtime.hooks,
+            onTextDelta: (delta) => setStreamingText((prev) => prev + delta),
+            // Only non-tool status lines (currently just the tool_use_failed
+            // retry notice) come through here — tool call/result presentation
+            // is handled by onToolCall/onToolResult below instead of parsing
+            // this raw `[tool] name {json}`-style text.
+            onStatusLine: (line) => {
+                if (!line.startsWith("[tool]"))
+                    pushTranscript("status", line);
+            },
+            onToolCall: (name, argsJson) => {
+                if (name === "todowrite") {
+                    pushTranscript("status", formatTodoChecklist(argsJson));
+                    return;
+                }
+                if (TOOLS_WITH_OWN_UI.has(name))
+                    return; // question/exit_plan_mode show their own prompt UI
+                const label = formatToolCallLabel(name, argsJson);
+                activeToolRef.current = { name, label };
+                setActiveToolLabel(label);
+            },
+            onToolResult: (name, result, isError) => {
+                if (name === "todowrite" || TOOLS_WITH_OWN_UI.has(name))
+                    return;
+                const label = activeToolRef.current?.name === name ? activeToolRef.current.label : `${name}()`;
+                pushToolResult(label, formatToolResultDetail(name, result, isError), isError);
+                activeToolRef.current = undefined;
+                setActiveToolLabel(undefined);
+            },
+            onMessage: (m) => {
+                conversationRef.current.push(m);
+                runtime.store.appendMessage(runtime.sessionId, m.role, m.content, m.toolCalls ?? [], m.toolCallId ?? "");
+                if (m.role === "assistant" && m.content) {
+                    pushTranscript("assistant", m.content);
+                    setStreamingText("");
+                }
+            },
+        });
+        try {
+            await loop.run(model, conversationRef.current);
+        }
+        catch (err) {
+            pushTranscript("status", `error: ${err instanceof Error ? err.message : String(err)}`);
+        }
+        setUiMode("input");
+    }
+    function pushSystemNote(content) {
+        conversationRef.current.push({ role: "system", content });
+        const runtime = runtimeRef.current;
+        if (runtime)
+            runtime.store.appendMessage(runtime.sessionId, "system", content);
+    }
+    /** Completes a /resume: tears down the current runtime entirely and
+     * rebuilds it pointed at a different session id — a bigger operation
+     * than /provider's swap-in-place, since the session store, history, and
+     * conversation context all change together, not just the provider. */
+    async function resumeSession(sessionId) {
+        const current = runtimeRef.current;
+        if (current && sessionId === current.sessionId) {
+            pushTranscript("status", "already in that session");
+            return;
+        }
+        setUiMode("loading");
+        try {
+            // Build the new runtime before tearing down the old one — if this
+            // throws (e.g. the session was deleted between listing it and
+            // selecting it), the current session stays fully usable instead of
+            // being left half-closed.
+            const runtime = await buildRuntime({
+                prompt: makePrompter(),
+                ask: makeAsker(),
+                initialMode: agentModeDisplay,
+                continueSession: false,
+                newSessionId: randomBytes(8).toString("hex"),
+                resumeSessionId: sessionId,
+                onSubAgentStatus: (text) => pushTranscript("status", text),
+            });
+            void current?.close();
+            runtimeRef.current = runtime;
+            setModel(runtime.model);
+            conversationRef.current = [
+                systemMessage(runtime.projectRoot, agentModeDisplay, runtime.projectInstructions),
+                ...runtime.history,
+            ];
+            pushTranscript("status", `resumed session ${runtime.sessionId}`);
+            for (const m of runtime.history) {
+                if (m.role === "user")
+                    pushTranscript("user", m.content);
+                else if (m.role === "assistant" && m.content)
+                    pushTranscript("assistant", m.content);
+            }
+        }
+        catch (err) {
+            pushTranscript("status", `couldn't resume session: ${err instanceof Error ? err.message : String(err)}`);
+        }
+        setUiMode("input");
+    }
+    /** Completes a /provider switch: builds the new provider instance, swaps
+     * it into the live runtime (sub-agents follow via TaskTool's getters),
+     * and persists the choice exactly the way onboarding does (config.json +
+     * per-preset keychain slot) so it survives restarts. */
+    function switchProvider(preset, baseUrl, apiKey, extras) {
+        const runtime = runtimeRef.current;
+        if (!runtime)
+            return;
+        try {
+            const provider = buildProviderNamed({
+                provider: preset.adapter,
+                baseUrl,
+                apiKey,
+                maxContext: runtime.maxContext,
+                azureResourceName: extras?.azureResourceName,
+                azureDeploymentName: extras?.azureDeploymentName,
+                azureApiVersion: extras?.azureApiVersion,
+                awsRegion: extras?.awsRegion,
+            });
+            runtime.setProviderAndModel(provider, preset.defaultModel);
+            setModel(preset.defaultModel);
+            new UserConfig(configPath()).save({
+                preset: preset.id,
+                provider: preset.adapter,
+                baseUrl: baseUrl || undefined,
+                model: preset.defaultModel,
+                azureResourceName: extras?.azureResourceName,
+                azureDeploymentName: extras?.azureDeploymentName,
+                azureApiVersion: extras?.azureApiVersion,
+                awsRegion: extras?.awsRegion,
+            });
+            if (apiKey)
+                new SecretStore().setApiKey(preset.id, apiKey);
+            pushTranscript("status", `provider: ${preset.label} · model: ${preset.defaultModel} — /model to pick another`);
+        }
+        catch (err) {
+            pushTranscript("status", `provider switch failed: ${err instanceof Error ? err.message : String(err)}`);
+        }
+        setProviderDraft(undefined);
+        setInputBuffer("");
+        setSelectedIndex(0);
+        setUiMode("input");
+    }
+    /** Runs when a preset is picked in the /provider list — decides whether
+     * it can switch immediately (key already stored / saved config has the
+     * extra fields) or needs more answers first (base URL, key). */
+    function choosePreset(preset) {
+        const secrets = new SecretStore();
+        const storedKey = secrets.getApiKey(preset.id);
+        if (preset.flow === "azure" || preset.flow === "bedrock" || preset.flow === "workers-ai") {
+            // These need fields beyond one key (resource/deployment, AWS creds
+            // trio, account id). If a complete saved setup for this exact preset
+            // already exists, switch straight to it; otherwise point at the
+            // wizard rather than reproducing its whole multi-field flow here.
+            const saved = new UserConfig(configPath()).load();
+            const savedMatches = saved?.preset === preset.id || (saved?.provider === preset.adapter && preset.adapter !== "openai");
+            const complete = preset.flow === "azure"
+                ? Boolean(saved?.azureResourceName && saved.azureDeploymentName && saved.azureApiVersion && storedKey)
+                : preset.flow === "bedrock"
+                    ? Boolean(saved?.awsRegion && storedKey)
+                    : Boolean(saved?.baseUrl && storedKey);
+            if (savedMatches && complete && saved) {
+                switchProvider(preset, saved.baseUrl ?? "", storedKey ?? "", {
+                    azureResourceName: saved.azureResourceName,
+                    azureDeploymentName: saved.azureDeploymentName,
+                    azureApiVersion: saved.azureApiVersion,
+                    awsRegion: saved.awsRegion,
+                });
+            }
+            else {
+                pushTranscript("status", `${preset.label} needs extra setup fields — run \`breviq config\` once to set it up, then /provider switches to it instantly`);
+                setSelectedIndex(0);
+                setUiMode("input");
+            }
+            return;
+        }
+        if (preset.flow === "ask-base-url") {
+            setProviderDraft({ preset });
+            setInputBuffer("");
+            setUiMode("provider-url");
+            return;
+        }
+        // fixed-base-url / none: only a key is needed — reuse a stored one, or
+        // ask for it right here in the TUI.
+        const baseUrl = preset.fixedBaseUrl ?? "";
+        if (storedKey) {
+            switchProvider(preset, baseUrl, storedKey);
+        }
+        else {
+            setProviderDraft({ preset, baseUrl });
+            setInputBuffer("");
+            setUiMode("provider-key");
+        }
+    }
+    function handleSlashCommand(cmd) {
+        const [name, ...rest] = cmd.slice(1).split(/\s+/);
+        const arg = rest.join(" ");
+        const runtime = runtimeRef.current;
+        switch (name) {
+            case "help":
+                pushTranscript("status", "commands: /model <name>  /provider  /resume [id]  /mcp  /plan  /build  /clear  /help  /exit (or Ctrl+C)\ntip: end a line with \\ then Enter to insert a newline instead of submitting");
+                break;
+            case "resume": {
+                if (arg) {
+                    void resumeSession(arg);
+                    break;
+                }
+                if (!runtime)
+                    break;
+                const sessions = runtime.store.listSessions().filter((s) => s.id !== runtime.sessionId);
+                if (sessions.length === 0) {
+                    pushTranscript("status", "no other sessions to resume");
+                    break;
+                }
+                const choices = sessions.map((s) => ({
+                    id: s.id,
+                    createdAt: s.createdAt,
+                    preview: runtime.store.firstUserMessage(s.id) ?? "(no messages yet)",
+                }));
+                setSessionChoices(choices);
+                setSelectedIndex(0);
+                setInputBuffer("");
+                setUiMode("resume-picker");
+                break;
+            }
+            case "mcp":
+                setUiMode("mcp-list");
+                break;
+            case "provider":
+                setSelectedIndex(0);
+                setUiMode("provider-picker");
+                break;
+            case "exit":
+            case "quit":
+                exit();
+                break;
+            case "clear":
+                // Resets the model-facing conversation only — the *visible*
+                // transcript is intentionally left alone. `<Static>` tracks "how
+                // many items have I already printed" as a cursor that only ever
+                // advances, the same way real terminal scrollback can't be
+                // un-printed; resetting `transcript` to `[]` here previously broke
+                // that invariant (confirmed via an isolated test): Static then
+                // treated the next pushed item as one it had "already printed" at
+                // that same array index and silently skipped rendering it, along
+                // with everything appended afterward. Never shrink/replace the
+                // array Static is fed — only ever append to it.
+                if (runtime)
+                    conversationRef.current = [systemMessage(runtime.projectRoot, agentModeDisplay, runtime.projectInstructions)];
+                pushTranscript("status", "context cleared (new messages start fresh; session history on disk is untouched)");
+                break;
+            case "model":
+                if (arg) {
+                    setModel(arg);
+                    runtime?.setModel(arg);
+                    pushTranscript("status", `model set to ${arg}`);
+                    break;
+                }
+                // No arg: open the model picker, fetching live from the provider's
+                // listing endpoint (OpenAI-compatible /models, Anthropic
+                // /v1/models, Gemini /v1beta/models). Providers without a listing
+                // endpoint (Bedrock) fall back to showing the current model and a
+                // type-a-name hint.
+                if (runtime?.provider.listModels) {
+                    setUiMode("busy");
+                    void runtime.provider
+                        .listModels()
+                        .then((models) => {
+                        if (models.length === 0) {
+                            pushTranscript("status", `provider returned no models; current model: ${model}`);
+                            setUiMode("input");
+                            return;
+                        }
+                        setModelChoices(models);
+                        setSelectedIndex(Math.max(0, models.indexOf(model)));
+                        setInputBuffer("");
+                        setUiMode("model-picker");
+                    })
+                        .catch((err) => {
+                        pushTranscript("status", `couldn't list models (${err instanceof Error ? err.message : String(err)}); current model: ${model} — use /model <name> to set one directly`);
+                        setUiMode("input");
+                    });
+                }
+                else {
+                    pushTranscript("status", `current model: ${model} (this provider has no listing endpoint — use /model <name>)`);
+                }
+                break;
+            case "plan":
+                runtime?.gate.setMode("plan");
+                setAgentModeDisplay("plan");
+                pushSystemNote("Mode switched to PLAN: only read-only tools work now. Call exit_plan_mode once ready to make changes.");
+                pushTranscript("status", "mode: plan");
+                break;
+            case "build":
+                runtime?.gate.setMode("build");
+                setAgentModeDisplay("build");
+                pushSystemNote("Mode switched to BUILD: all tools are available now.");
+                pushTranscript("status", "mode: build");
+                break;
+            default: {
+                const custom = customCommands.find((c) => c.name === name);
+                if (custom) {
+                    void sendToModel(expandCommand(custom, arg));
+                    break;
+                }
+                pushTranscript("status", `unknown command: /${name} (try /help)`);
+            }
+        }
+    }
+    useInput((input, key) => {
+        if (key.ctrl && input === "c") {
+            exit();
+            return;
+        }
+        if (uiMode === "confirm" && pendingConfirm) {
+            // Arrow-selectable option list (Yes / Yes-always / No), matching
+            // Claude Code's own permission prompt — with y/a/n still accepted
+            // as shortcut keys for people used to the old style.
+            if (key.upArrow) {
+                setSelectedIndex((prev) => (prev - 1 + CONFIRM_OPTIONS.length) % CONFIRM_OPTIONS.length);
+                return;
+            }
+            if (key.downArrow) {
+                setSelectedIndex((prev) => (prev + 1) % CONFIRM_OPTIONS.length);
+                return;
+            }
+            const resolveConfirm = (option) => {
+                pendingConfirm.resolve({ approve: option.approve, remember: option.remember });
+                setPendingConfirm(undefined);
+                setSelectedIndex(0);
+                setUiMode("busy");
+            };
+            if (key.return) {
+                resolveConfirm(CONFIRM_OPTIONS[selectedIndex] ?? CONFIRM_OPTIONS[0]);
+                return;
+            }
+            const lower = input.toLowerCase();
+            if (lower === "y")
+                resolveConfirm({ approve: true, remember: false });
+            else if (lower === "a")
+                resolveConfirm({ approve: true, remember: true });
+            else if (lower === "n")
+                resolveConfirm({ approve: false, remember: false });
+            return;
+        }
+        if (uiMode === "question" && pendingQuestion) {
+            const options = pendingQuestion.options ?? [];
+            // With options: ↑/↓ selects among them; typing anything switches to
+            // a free-text answer (options are suggestions, not a closed set —
+            // same contract the readline-based Asker in prompt.ts has).
+            if (options.length > 0 && inputBuffer === "") {
+                if (key.upArrow) {
+                    setSelectedIndex((prev) => (prev - 1 + options.length) % options.length);
+                    return;
+                }
+                if (key.downArrow) {
+                    setSelectedIndex((prev) => (prev + 1) % options.length);
+                    return;
+                }
+            }
+            if (key.return) {
+                const answer = inputBuffer !== "" ? inputBuffer : (options[selectedIndex] ?? "");
+                pendingQuestion.resolve(answer);
+                setPendingQuestion(undefined);
+                setInputBuffer("");
+                setSelectedIndex(0);
+                setUiMode("busy");
+                return;
+            }
+            if (key.backspace || key.delete) {
+                setInputBuffer((prev) => prev.slice(0, -1));
+                return;
+            }
+            if (input)
+                setInputBuffer((prev) => prev + input);
+            return;
+        }
+        if (uiMode === "provider-picker") {
+            // inputBuffer doubles as filter text, same convention the /model
+            // picker uses — found missing live (typing a provider name did
+            // nothing and Enter silently picked whatever arrow position was
+            // last active, defaulting to the first entry), so this matches that
+            // already-proven pattern instead of inventing a new one.
+            const filtered = PROVIDER_PRESETS.filter((p) => p.label.toLowerCase().includes(inputBuffer.toLowerCase()));
+            if (key.escape) {
+                setInputBuffer("");
+                setSelectedIndex(0);
+                setUiMode("input");
+                return;
+            }
+            if (key.upArrow && filtered.length > 0) {
+                setSelectedIndex((prev) => (prev - 1 + filtered.length) % filtered.length);
+                return;
+            }
+            if (key.downArrow && filtered.length > 0) {
+                setSelectedIndex((prev) => (prev + 1) % filtered.length);
+                return;
+            }
+            if (key.return) {
+                const preset = filtered[Math.min(selectedIndex, Math.max(0, filtered.length - 1))];
+                setInputBuffer("");
+                setSelectedIndex(0);
+                if (preset)
+                    choosePreset(preset);
+                return;
+            }
+            if (key.backspace || key.delete) {
+                setInputBuffer((prev) => prev.slice(0, -1));
+                setSelectedIndex(0);
+                return;
+            }
+            if (input) {
+                setInputBuffer((prev) => prev + input);
+                setSelectedIndex(0);
+            }
+            return;
+        }
+        if (uiMode === "provider-url" && providerDraft) {
+            if (key.escape) {
+                setProviderDraft(undefined);
+                setInputBuffer("");
+                setUiMode("input");
+                return;
+            }
+            if (key.return) {
+                const baseUrl = inputBuffer.trim() || providerDraft.preset.askDefaultBaseUrl || "";
+                setProviderDraft({ ...providerDraft, baseUrl });
+                setInputBuffer("");
+                setUiMode("provider-key");
+                return;
+            }
+            if (key.backspace || key.delete) {
+                setInputBuffer((prev) => prev.slice(0, -1));
+                return;
+            }
+            if (input)
+                setInputBuffer((prev) => prev + input);
+            return;
+        }
+        if (uiMode === "provider-key" && providerDraft) {
+            if (key.escape) {
+                setProviderDraft(undefined);
+                setInputBuffer("");
+                setUiMode("input");
+                return;
+            }
+            if (key.return) {
+                switchProvider(providerDraft.preset, providerDraft.baseUrl ?? "", inputBuffer.trim());
+                return;
+            }
+            if (key.backspace || key.delete) {
+                setInputBuffer((prev) => prev.slice(0, -1));
+                return;
+            }
+            if (input)
+                setInputBuffer((prev) => prev + input);
+            return;
+        }
+        if (uiMode === "model-picker") {
+            // inputBuffer doubles as the filter text; selection wraps within the
+            // filtered list, same interaction shape as the slash palette.
+            const filtered = modelChoices.filter((m) => m.toLowerCase().includes(inputBuffer.toLowerCase()));
+            if (key.escape) {
+                setModelChoices([]);
+                setInputBuffer("");
+                setSelectedIndex(0);
+                setUiMode("input");
+                return;
+            }
+            if (key.upArrow && filtered.length > 0) {
+                setSelectedIndex((prev) => (prev - 1 + filtered.length) % filtered.length);
+                return;
+            }
+            if (key.downArrow && filtered.length > 0) {
+                setSelectedIndex((prev) => (prev + 1) % filtered.length);
+                return;
+            }
+            if (key.return) {
+                const chosen = filtered[Math.min(selectedIndex, Math.max(0, filtered.length - 1))];
+                if (chosen) {
+                    setModel(chosen);
+                    runtimeRef.current?.setModel(chosen);
+                    pushTranscript("status", `model set to ${chosen}`);
+                }
+                setModelChoices([]);
+                setInputBuffer("");
+                setSelectedIndex(0);
+                setUiMode("input");
+                return;
+            }
+            if (key.backspace || key.delete) {
+                setInputBuffer((prev) => prev.slice(0, -1));
+                setSelectedIndex(0);
+                return;
+            }
+            if (input) {
+                setInputBuffer((prev) => prev + input);
+                setSelectedIndex(0);
+            }
+            return;
+        }
+        if (uiMode === "resume-picker") {
+            // Same filter-by-typing convention as /model and /provider: filter
+            // both the preview text and the raw id, since a user resuming a
+            // session with no messages yet has nothing but the id to match on.
+            const filtered = sessionChoices.filter((s) => s.preview.toLowerCase().includes(inputBuffer.toLowerCase()) || s.id.includes(inputBuffer));
+            if (key.escape) {
+                setSessionChoices([]);
+                setInputBuffer("");
+                setSelectedIndex(0);
+                setUiMode("input");
+                return;
+            }
+            if (key.upArrow && filtered.length > 0) {
+                setSelectedIndex((prev) => (prev - 1 + filtered.length) % filtered.length);
+                return;
+            }
+            if (key.downArrow && filtered.length > 0) {
+                setSelectedIndex((prev) => (prev + 1) % filtered.length);
+                return;
+            }
+            if (key.return) {
+                const chosen = filtered[Math.min(selectedIndex, Math.max(0, filtered.length - 1))];
+                setSessionChoices([]);
+                setInputBuffer("");
+                setSelectedIndex(0);
+                if (chosen)
+                    void resumeSession(chosen.id);
+                return;
+            }
+            if (key.backspace || key.delete) {
+                setInputBuffer((prev) => prev.slice(0, -1));
+                setSelectedIndex(0);
+                return;
+            }
+            if (input) {
+                setInputBuffer((prev) => prev + input);
+                setSelectedIndex(0);
+            }
+            return;
+        }
+        if (uiMode === "mcp-list") {
+            if (key.escape || key.return)
+                setUiMode("input");
+            return;
+        }
+        if (uiMode !== "input")
+            return;
+        // Slash palette navigation, when visible.
+        if (paletteMatches.length > 0) {
+            if (key.upArrow) {
+                setSelectedIndex((prev) => (prev - 1 + paletteMatches.length) % paletteMatches.length);
+                return;
+            }
+            if (key.downArrow) {
+                setSelectedIndex((prev) => (prev + 1) % paletteMatches.length);
+                return;
+            }
+            if (key.tab) {
+                const chosen = paletteMatches[Math.min(selectedIndex, paletteMatches.length - 1)];
+                if (chosen)
+                    setInputBuffer(`/${chosen.name} `);
+                setSelectedIndex(0);
+                return;
+            }
+            if (key.escape) {
+                setInputBuffer("");
+                setSelectedIndex(0);
+                return;
+            }
+            if (key.return) {
+                const chosen = paletteMatches[Math.min(selectedIndex, paletteMatches.length - 1)];
+                setInputBuffer("");
+                setSelectedIndex(0);
+                if (chosen)
+                    void submit(`/${chosen.name}`);
+                return;
+            }
+        }
+        if (key.return) {
+            if (inputBuffer.endsWith("\\")) {
+                setInputBuffer((prev) => prev.slice(0, -1) + "\n");
+                return;
+            }
+            const toSubmit = inputBuffer;
+            setInputBuffer("");
+            void submit(toSubmit);
+            return;
+        }
+        if (key.backspace || key.delete) {
+            setInputBuffer((prev) => {
+                const next = prev.slice(0, -1);
+                return next;
+            });
+            setSelectedIndex(0);
+            return;
+        }
+        if (input) {
+            setInputBuffer((prev) => prev + input);
+            setSelectedIndex(0);
+        }
+    });
+    const modeColor = agentModeDisplay === "plan" ? "yellow" : "cyan";
+    const footerBorderColor = uiMode === "confirm" || uiMode === "question" ? "yellow" : modeColor;
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Static, { items: transcript, children: (entry) => (_jsx(Box, { flexDirection: "column", marginBottom: 1, children: entry.kind === "tool" ? (_jsxs(_Fragment, { children: [_jsxs(Text, { color: entry.toolError ? "red" : "blue", children: [entry.toolError ? "✗" : "⏺", " ", entry.toolLabel] }), _jsxs(Text, { dimColor: true, children: ["  ⎿  ", entry.toolDetail] })] })) : (_jsxs(Text, { color: entry.kind === "user" ? "cyan" : entry.kind === "assistant" ? undefined : undefined, dimColor: entry.kind === "status", bold: entry.kind === "user", children: [entry.kind === "user" ? "> " : "", entry.text] })) }, entry.id)) }), activeToolLabel && (_jsxs(Text, { color: "blue", children: [_jsx(Spinner, { type: "dots" }), " ", activeToolLabel] })), streamingText.length > 0 && _jsx(Text, { children: streamingText }), _jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsxs(Box, { borderStyle: "round", borderColor: footerBorderColor, paddingX: 1, children: [uiMode === "loading" && (_jsxs(Text, { dimColor: true, children: [_jsx(Spinner, { type: "dots" }), " starting..."] })), uiMode === "confirm" && pendingConfirm && (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { bold: true, color: pendingConfirm.dangerous ? "red" : undefined, children: [pendingConfirm.dangerous ? "⚠ DANGEROUS — " : "", formatToolCallLabel(pendingConfirm.toolName, pendingConfirm.argsJson)] }), _jsx(Text, { dimColor: true, children: "Do you want to allow this?" }), CONFIRM_OPTIONS.map((option, i) => (_jsxs(Text, { color: i === selectedIndex ? "cyan" : undefined, dimColor: i !== selectedIndex, children: [i === selectedIndex ? "❯ " : "  ", option.label] }, option.label)))] })), uiMode === "question" && pendingQuestion && (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { bold: true, children: pendingQuestion.question }), (pendingQuestion.options ?? []).map((option, i) => (_jsxs(Text, { color: inputBuffer === "" && i === selectedIndex ? "cyan" : undefined, dimColor: inputBuffer !== "" || i !== selectedIndex, children: [inputBuffer === "" && i === selectedIndex ? "❯ " : "  ", option] }, option))), _jsxs(Box, { children: [_jsx(Text, { dimColor: true, children: "or type: " }), _jsx(Text, { children: inputBuffer })] })] })), uiMode === "busy" && !activeToolLabel && (_jsxs(Text, { dimColor: true, children: [_jsx(Spinner, { type: "dots" }), " thinking..."] })), uiMode === "provider-picker" &&
+                                (() => {
+                                    const filtered = PROVIDER_PRESETS.filter((p) => p.label.toLowerCase().includes(inputBuffer.toLowerCase()));
+                                    const sel = Math.min(selectedIndex, Math.max(0, filtered.length - 1));
+                                    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { children: [_jsx(Text, { bold: true, children: "Select a provider " }), _jsx(Text, { dimColor: true, children: "(type to filter, \u2191/\u2193, Enter, Esc to cancel)" })] }), inputBuffer !== "" && (_jsxs(Box, { children: [_jsx(Text, { dimColor: true, children: "filter: " }), _jsx(Text, { children: inputBuffer })] })), filtered.map((preset, i) => (_jsxs(Text, { color: i === sel ? "cyan" : undefined, dimColor: i !== sel, children: [i === sel ? "❯ " : "  ", preset.label] }, preset.id))), filtered.length === 0 && _jsxs(Text, { dimColor: true, children: ["no providers match \"", inputBuffer, "\""] })] }));
+                                })(), uiMode === "provider-url" && providerDraft && (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { bold: true, children: ["Base URL for ", providerDraft.preset.label] }), _jsxs(Text, { dimColor: true, children: ["blank = ", providerDraft.preset.askDefaultBaseUrl, " (Esc to cancel)"] }), _jsxs(Box, { children: [_jsx(Text, { color: modeColor, children: "> " }), _jsx(Text, { children: inputBuffer })] })] })), uiMode === "provider-key" && providerDraft && (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { bold: true, children: [providerDraft.preset.label, " API key"] }), _jsxs(Text, { dimColor: true, children: [providerDraft.preset.flow === "ask-base-url" ? "blank = keyless local server " : "", "(stored in the OS keychain, Esc to cancel)"] }), _jsxs(Box, { children: [_jsx(Text, { color: modeColor, children: "> " }), _jsx(Text, { children: inputBuffer })] })] })), uiMode === "model-picker" &&
+                                (() => {
+                                    const filtered = modelChoices.filter((m) => m.toLowerCase().includes(inputBuffer.toLowerCase()));
+                                    const sel = Math.min(selectedIndex, Math.max(0, filtered.length - 1));
+                                    // Windowed view: keep the selection visible without rendering
+                                    // a provider's full catalog (Groq alone lists ~50 models).
+                                    const WINDOW = 8;
+                                    const start = Math.max(0, Math.min(sel - Math.floor(WINDOW / 2), filtered.length - WINDOW));
+                                    const visible = filtered.slice(start, start + WINDOW);
+                                    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { children: [_jsx(Text, { bold: true, children: "Select a model " }), _jsxs(Text, { dimColor: true, children: ["(type to filter, \u2191/\u2193, Enter, Esc to cancel) \u2014 ", filtered.length, " of ", modelChoices.length] })] }), inputBuffer !== "" && (_jsxs(Box, { children: [_jsx(Text, { dimColor: true, children: "filter: " }), _jsx(Text, { children: inputBuffer })] })), visible.map((m, i) => {
+                                                const actualIndex = start + i;
+                                                const isSelected = actualIndex === sel;
+                                                return (_jsxs(Text, { color: isSelected ? "cyan" : undefined, dimColor: !isSelected, children: [isSelected ? "❯ " : "  ", m, m === model ? "  (current)" : ""] }, m));
+                                            }), filtered.length === 0 && _jsxs(Text, { dimColor: true, children: ["no models match \"", inputBuffer, "\""] })] }));
+                                })(), uiMode === "resume-picker" &&
+                                (() => {
+                                    const filtered = sessionChoices.filter((s) => s.preview.toLowerCase().includes(inputBuffer.toLowerCase()) || s.id.includes(inputBuffer));
+                                    const sel = Math.min(selectedIndex, Math.max(0, filtered.length - 1));
+                                    const WINDOW = 8;
+                                    const start = Math.max(0, Math.min(sel - Math.floor(WINDOW / 2), filtered.length - WINDOW));
+                                    const visible = filtered.slice(start, start + WINDOW);
+                                    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { children: [_jsx(Text, { bold: true, children: "Resume a session " }), _jsxs(Text, { dimColor: true, children: ["(type to filter, \u2191/\u2193, Enter, Esc to cancel) \u2014 ", filtered.length, " of ", sessionChoices.length] })] }), inputBuffer !== "" && (_jsxs(Box, { children: [_jsx(Text, { dimColor: true, children: "filter: " }), _jsx(Text, { children: inputBuffer })] })), visible.map((s, i) => {
+                                                const actualIndex = start + i;
+                                                const isSelected = actualIndex === sel;
+                                                const preview = s.preview.replace(/\s+/g, " ").slice(0, 60);
+                                                return (_jsxs(Text, { color: isSelected ? "cyan" : undefined, dimColor: !isSelected, children: [isSelected ? "❯ " : "  ", s.createdAt.toLocaleString(), " \u2014 ", preview, s.preview.length > 60 ? "…" : ""] }, s.id));
+                                            }), filtered.length === 0 && _jsxs(Text, { dimColor: true, children: ["no sessions match \"", inputBuffer, "\""] })] }));
+                                })(), uiMode === "mcp-list" &&
+                                (() => {
+                                    const servers = runtimeRef.current?.mcpManager.listServers() ?? [];
+                                    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { children: [_jsx(Text, { bold: true, children: "MCP servers " }), _jsx(Text, { dimColor: true, children: "(Enter/Esc to close)" })] }), servers.length === 0 && (_jsx(Text, { dimColor: true, children: "no MCP servers configured \u2014 add .breviqcode/mcp.json to configure some" })), servers.map((s) => (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { color: s.connected ? "green" : "red", children: [s.connected ? "✓" : "✗", " ", s.name, s.connected ? ` (${s.toolNames.length} tool${s.toolNames.length === 1 ? "" : "s"})` : ""] }), s.connected &&
+                                                        s.toolNames.map((name) => (_jsxs(Text, { dimColor: true, children: ["    ", name] }, name))), !s.connected && _jsxs(Text, { dimColor: true, children: ["    ", s.error] })] }, s.name)))] }));
+                                })(), uiMode === "input" && (_jsxs(Box, { children: [_jsx(Text, { color: modeColor, children: "> " }), inputBuffer ? _jsx(Text, { children: inputBuffer }) : _jsx(Text, { dimColor: true, children: "type a message, or / for commands\u2026" })] }))] }), paletteMatches.length > 0 && (_jsx(Box, { flexDirection: "column", paddingLeft: 2, children: paletteMatches.map((cmd, i) => (_jsxs(Box, { children: [_jsxs(Text, { color: i === selectedIndex ? "cyan" : undefined, dimColor: i !== selectedIndex, children: [i === selectedIndex ? "❯ " : "  ", "/", cmd.name, cmd.args ? ` ${cmd.args}` : ""] }), _jsxs(Text, { dimColor: true, children: ["  ", cmd.description] })] }, cmd.name))) })), _jsxs(Text, { dimColor: true, children: [agentModeDisplay, " mode \u00B7 ", model || "…", runtimeRef.current ? ` · ${runtimeRef.current.projectRoot}` : ""] })] })] }));
+}
+/**
+ * Entry point for the interactive TUI. If neither real env vars nor a
+ * saved config exist yet, runs the first-run onboarding wizard *before*
+ * Ink ever renders — `resolveConfig()` (called later, inside
+ * `buildRuntime`) would otherwise try to run that same readline-based
+ * wizard while Ink already owns stdin in raw mode, which is exactly the
+ * kind of two-consumers-fighting-over-stdin problem this project's
+ * `createInteractiveIO` fix (see CLAUDE.md) exists to avoid — simplest fix
+ * here is just not letting the two ever overlap in the first place.
+ */
+export async function runTui(args) {
+    // Ink needs raw-mode TTY input for keystroke-by-keystroke handling
+    // (useInput); a real terminal launch always has this, but a non-TTY
+    // stdin (piped input, CI, a script) does not, and Ink's own resulting
+    // error is a raw stack trace, not a helpful message. Fail with a clear
+    // pointer to the scriptable one-shot command instead.
+    if (!process.stdin.isTTY) {
+        throw new Error('the interactive TUI needs a real terminal (stdin is not a TTY here) — use `breviq chat "prompt"` for scripted/piped/CI use instead');
+    }
+    const { resumeSessionId, rest } = extractResumeId(args);
+    const continueSession = rest.includes("--continue");
+    const plan = rest.includes("--plan");
+    const hasEnvConfig = Boolean(process.env.BREVIQ_PROVIDER || process.env.BREVIQ_API_KEY || process.env.BREVIQ_BASE_URL || process.env.BREVIQ_MODEL);
+    if (!hasEnvConfig && !new UserConfig(configPath()).exists()) {
+        await runOnboarding(configPath());
+    }
+    const instance = render(_jsx(App, { continueSession: continueSession, initialAgentMode: plan ? "plan" : "build", resumeSessionId: resumeSessionId }));
+    await instance.waitUntilExit();
+}
+//# sourceMappingURL=App.js.map