kritya 0.8.2-beta

package/dist/ui/App.js

@@ -0,0 +1,449 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useCallback, useEffect, useRef, useState } from "react";
+import { Box, Static, Text, useApp, useInput, useStdout } from "ink";
+import TextInput from "ink-text-input";
+import fs from "node:fs";
+import fg from "fast-glob";
+import stringWidth from "string-width";
+import { gitDiffStat } from "../git/git.js";
+import { modelDisplaySlug } from "../config/models.js";
+import { SessionStore } from "../session/store.js";
+import { resolveSafe } from "../tools/common.js";
+import { loadIgnorePatterns } from "../tools/ignore.js";
+import { Markdown } from "./Markdown.js";
+import { ModelPicker } from "./ModelPicker.js";
+import { ElicitationPrompt } from "./ElicitationPrompt.js";
+import { PermissionPrompt } from "./PermissionPrompt.js";
+import { SelectList } from "./SelectList.js";
+import { Spinner } from "./Spinner.js";
+import { StatusLine } from "./StatusLine.js";
+import { TranscriptItem } from "./TranscriptItem.js";
+import { tailForViewport, terminalColumns, terminalRows } from "./viewport.js";
+import { BUILTIN_COMMANDS, runCommand } from "../commands/registry.js";
+import { mcpPrompts, mcpResources } from "../mcp/client.js";
+import { useAgent } from "./useAgent.js";
+const MENTION_RE = /(^|\s)@([^\s@]*)$/;
+const MENTION_ALL_RE = /(?:^|\s)@([^\s@]+)/g;
+const MAX_MENTION_CHARS = 8000;
+const IMAGE_RE = /\.(png|jpe?g|gif|webp|bmp)$/i;
+// Erase screen + scrollback, then home the cursor (same sequence Ink itself
+// uses for its own "content taller than the terminal" clear path).
+const CLEAR_TERMINAL = "\x1b[2J\x1b[3J\x1b[H";
+export function App({ agent, workspace, modelRef, providerRef, config, resumedCount, initialTasks, undoStack, uiBridge, resumeSessions, customCommands = [], mcpToolCount = 0, onSwitchClient, onRequestPermissionReady, onRequestElicitationReady, }) {
+    const { exit } = useApp();
+    const { stdout } = useStdout();
+    const [input, setInput] = useState("");
+    const [inputKey, setInputKey] = useState(0);
+    const [steerInput, setSteerInput] = useState("");
+    const [resumeFilter, setResumeFilter] = useState("");
+    const [cmdIndex, setCmdIndex] = useState(0);
+    const [fileIndex, setFileIndex] = useState(0);
+    const [fileList, setFileList] = useState([]);
+    const [verbose, setVerbose] = useState(false);
+    const [elapsed, setElapsed] = useState(0);
+    const [staticKey, setStaticKey] = useState(0);
+    const inputHistory = useRef([]);
+    const histIndex = useRef(-1); // -1 means "current, not browsing history"
+    /**
+     * Ctrl-chord bookkeeping for the text inputs.
+     *
+     * Ink delivers a keypress to every `useInput` hook, and ink-text-input
+     * ignores only Ctrl+C — so Ctrl+K and Ctrl+O run their shortcut *and* get
+     * typed into the box as a bare "k"/"o". Hitting the kill switch left junk on
+     * the prompt line, which the next Enter would have sent as a message.
+     *
+     * The two hooks can fire in either order, so both directions are covered:
+     * `ctrlChord` makes onChange drop the echoed letter when the shortcut ran
+     * first, and re-setting the value from `inputRef` undoes it when the input
+     * ran first. `inputRef` tracks committed state, so it always holds the value
+     * from before this keypress.
+     */
+    const ctrlChord = useRef(null);
+    const inputRef = useRef("");
+    const steerInputRef = useRef("");
+    useEffect(() => {
+        inputRef.current = input;
+    }, [input]);
+    useEffect(() => {
+        steerInputRef.current = steerInput;
+    }, [steerInput]);
+    const noteCtrlChord = (letter) => {
+        ctrlChord.current = letter;
+        setInput(inputRef.current);
+        setSteerInput(steerInputRef.current);
+        setTimeout(() => {
+            ctrlChord.current = null;
+        }, 0);
+    };
+    /** The change a Ctrl chord echoed into the box, rather than a real keystroke. */
+    const isCtrlEcho = (prev, next) => ctrlChord.current !== null && next === prev + ctrlChord.current;
+    // Terminals that reflow their buffer on resize (e.g. VS Code's xterm.js)
+    // rewrap already-printed full-width lines (banner art, box borders) to the
+    // new column count on their own, before Ink's next redraw arrives. Ink then
+    // erases based on a stale line count from before that reflow, so it clears
+    // the wrong number of rows and leaves stale copies of boxes/banners behind
+    // — compounding on every resize. There's no way to reflow in place safely,
+    // so once the column count actually settles on a new value (ignoring
+    // height-only resizes, e.g. VS Code adding a split terminal), wipe the
+    // screen ourselves and remount <Static> so Ink reprints everything fresh
+    // onto a blank canvas. The manual clear is safe here specifically because
+    // the forced remount immediately triggers Ink's own static-flush path,
+    // which resyncs its internal line-count bookkeeping — it's only unsafe to
+    // write raw ANSI without following it with something that resets that
+    // bookkeeping.
+    const lastColumns = useRef(stdout?.columns);
+    useEffect(() => {
+        if (!stdout)
+            return;
+        let timer;
+        const onResize = () => {
+            clearTimeout(timer);
+            timer = setTimeout(() => {
+                if (stdout.columns === lastColumns.current)
+                    return;
+                lastColumns.current = stdout.columns;
+                stdout.write(CLEAR_TERMINAL);
+                setStaticKey((k) => k + 1);
+            }, 150);
+        };
+        stdout.on("resize", onResize);
+        return () => {
+            clearTimeout(timer);
+            stdout.off("resize", onResize);
+        };
+    }, [stdout]);
+    const refreshFileList = useCallback(() => {
+        fg("**/*", {
+            cwd: workspace,
+            dot: false,
+            onlyFiles: true,
+            ignore: ["**/node_modules/**", "**/.git/**", "**/dist/**", ...loadIgnorePatterns(workspace)],
+            suppressErrors: true,
+        })
+            .then((files) => setFileList(files.sort().slice(0, 2000)))
+            .catch(() => { });
+    }, [workspace]);
+    useEffect(refreshFileList, [refreshFileList]);
+    const { items, addItem, phase, setPhase, stream, thinking, activity, setActivity, runningPhase, setRunningPhase, workflow, refreshWorkflow, permission, elicitation, inFlight, model, provider, servedModel, totalUsage, totalCost, tasks, setTasks, ctxPct, setCtxPct, tokenBudget, budgetPct, budgetUsed, budgetStopped, resetBudget, setBudgetLimit, branch, planMode, setPlanMode, dryRunMode, killed, killReason, engageKill, releaseKill, acceptEdits, setAcceptEdits, autoApprovedCount, cycleMode, onAcceptEditsConfirm, abortRef, setModelEverywhere, setProviderEverywhere, costReport, runAgent, runWebSearch, onPermissionDecision, onElicitationDecision, onResumeSelect, requestPermission, requestElicitation, } = useAgent({
+        agent,
+        workspace,
+        modelRef,
+        providerRef,
+        config,
+        uiBridge,
+        resumedCount,
+        initialTasks,
+        resumeSessions,
+        refreshFileList,
+        onSwitchClient,
+    });
+    useEffect(() => {
+        onRequestPermissionReady?.(requestPermission);
+    }, [onRequestPermissionReady, requestPermission]);
+    useEffect(() => {
+        onRequestElicitationReady?.(requestElicitation);
+    }, [onRequestElicitationReady, requestElicitation]);
+    // Tick an elapsed-seconds counter while the agent is working.
+    useEffect(() => {
+        if (phase !== "working") {
+            setElapsed(0);
+            return;
+        }
+        const start = Date.now();
+        const t = setInterval(() => setElapsed(Math.floor((Date.now() - start) / 1000)), 1000);
+        return () => clearInterval(t);
+    }, [phase]);
+    const allCommands = [
+        ...BUILTIN_COMMANDS,
+        ...customCommands.map((c) => ({ name: c.name, description: c.description })),
+        // Servers can contribute slash commands too (MCP prompts).
+        ...mcpPrompts().map((p) => ({ name: p.command, description: p.description })),
+    ];
+    // Command suggestions while typing a slash command (before any arguments).
+    const suggestions = phase === "input" && input.startsWith("/") && !input.includes(" ")
+        ? allCommands.filter((c) => c.name.startsWith(input.trim()))
+        : [];
+    const selectedCmd = suggestions.length ? Math.min(cmdIndex, suggestions.length - 1) : 0;
+    // File suggestions while typing an @mention.
+    const mentionMatch = phase === "input" && !input.startsWith("/") ? MENTION_RE.exec(input) : null;
+    const mentionFragment = mentionMatch ? mentionMatch[2].toLowerCase() : null;
+    const fileSuggestions = mentionFragment !== null
+        ? [...fileList, ...mcpResources().map((r) => r.mention)]
+            .filter((f) => f.toLowerCase().includes(mentionFragment))
+            .slice(0, 8)
+        : [];
+    const selectedFile = fileSuggestions.length ? Math.min(fileIndex, fileSuggestions.length - 1) : 0;
+    const completeMention = (file) => {
+        if (!mentionMatch)
+            return;
+        const head = input.slice(0, mentionMatch.index + mentionMatch[1].length);
+        setInput(`${head}@${file} `);
+        setInputKey((k) => k + 1);
+        setFileIndex(0);
+    };
+    useInput((_input, key) => {
+        // Ctrl+K is the kill switch, and it comes before every other binding and
+        // phase check on purpose: a panic button that only works from the idle
+        // input line is not a panic button. It fires mid-stream, mid-tool, and
+        // while a permission prompt is on screen.
+        if (key.ctrl && _input === "k") {
+            noteCtrlChord(_input);
+            if (killed)
+                return; // already stopped; /kill off is the way back
+            engageKill("Ctrl+K");
+            return;
+        }
+        if (key.escape && phase === "working") {
+            abortRef.current?.abort();
+        }
+        // Ctrl+O toggles showing full tool output.
+        if (key.ctrl && _input === "o") {
+            noteCtrlChord(_input);
+            setVerbose((v) => !v);
+            return;
+        }
+        // Shift+Tab cycles normal → accept-edits → plan → normal. Only from the
+        // plain input state — not mid-permission-prompt, mid-resume-picker, etc.
+        if (key.tab && key.shift && phase === "input") {
+            cycleMode();
+            return;
+        }
+        // First-time accept-edits confirmation: Yes proceeds, anything else cancels.
+        if (phase === "confirmMode") {
+            const c = _input.toLowerCase();
+            if (c === "y" || key.return)
+                onAcceptEditsConfirm(true);
+            else if (c === "n" || key.escape)
+                onAcceptEditsConfirm(false);
+            return;
+        }
+        // History recall with ↑/↓ when no autocomplete popup is open.
+        if (phase === "input" && !suggestions.length && !fileSuggestions.length) {
+            const hist = inputHistory.current;
+            if (key.upArrow && hist.length) {
+                histIndex.current =
+                    histIndex.current === -1 ? hist.length - 1 : Math.max(0, histIndex.current - 1);
+                setInput(hist[histIndex.current]);
+                return;
+            }
+            if (key.downArrow && histIndex.current !== -1) {
+                histIndex.current += 1;
+                if (histIndex.current >= hist.length) {
+                    histIndex.current = -1;
+                    setInput("");
+                }
+                else {
+                    setInput(hist[histIndex.current]);
+                }
+                return;
+            }
+        }
+        if (phase === "resume") {
+            if (key.backspace || key.delete)
+                setResumeFilter((f) => f.slice(0, -1));
+            else if (_input && !key.upArrow && !key.downArrow && !key.return && !key.escape && !key.tab) {
+                setResumeFilter((f) => f + _input);
+            }
+        }
+        if (suggestions.length) {
+            if (key.upArrow)
+                setCmdIndex((i) => (i - 1 + suggestions.length) % suggestions.length);
+            else if (key.downArrow)
+                setCmdIndex((i) => (i + 1) % suggestions.length);
+            else if (key.tab) {
+                setInput(suggestions[selectedCmd].name + " ");
+                setInputKey((k) => k + 1);
+            }
+        }
+        else if (fileSuggestions.length) {
+            if (key.upArrow)
+                setFileIndex((i) => (i - 1 + fileSuggestions.length) % fileSuggestions.length);
+            else if (key.downArrow)
+                setFileIndex((i) => (i + 1) % fileSuggestions.length);
+            else if (key.tab)
+                completeMention(fileSuggestions[selectedFile]);
+        }
+    });
+    const handleSlash = (raw) => {
+        const [cmd, ...rest] = raw.trim().split(/\s+/);
+        const arg = rest.join(" ");
+        const ctx = {
+            arg,
+            raw,
+            agent,
+            workspace,
+            config,
+            undoStack,
+            customCommands,
+            mcpToolCount,
+            planMode,
+            acceptEdits,
+            setAcceptEdits,
+            tokenBudget,
+            budgetPct,
+            budgetUsed,
+            budgetStopped,
+            resetBudget,
+            setBudgetLimit,
+            addItem,
+            setPhase,
+            setActivity,
+            setRunningPhase,
+            refreshWorkflow,
+            setCtxPct,
+            setTasks,
+            setPlanMode,
+            killed,
+            killReason,
+            engageKill,
+            releaseKill,
+            setModelEverywhere,
+            provider,
+            model,
+            setProviderEverywhere,
+            refreshFileList,
+            runAgent,
+            runWebSearch,
+            expandMentions,
+            costReport,
+            gitDiffStat,
+            exit,
+        };
+        void runCommand(cmd, ctx);
+    };
+    const expandMentions = async (text) => {
+        const mentions = [...new Set([...text.matchAll(MENTION_ALL_RE)].map((m) => m[1]))];
+        let extra = "";
+        for (const p of mentions) {
+            if (IMAGE_RE.test(p))
+                continue; // images are attached separately, not inlined as text
+            // An @mcp:… mention names a document a server offers rather than a file
+            // on disk, so it's fetched instead of read — and marked as external,
+            // since a server wrote it.
+            const resource = mcpResources().find((r) => r.mention === p);
+            if (resource) {
+                try {
+                    const body = await resource.read();
+                    const capped = body.length > MAX_MENTION_CHARS
+                        ? body.slice(0, MAX_MENTION_CHARS) + "\n… (truncated)"
+                        : body;
+                    extra +=
+                        `\n\n[Attached MCP resource: ${resource.uri} from server "${resource.server}" — ` +
+                            `external content]\n\`\`\`\n${capped}\n\`\`\``;
+                }
+                catch (err) {
+                    extra += `\n\n[MCP resource ${p} could not be read: ${err instanceof Error ? err.message : String(err)}]`;
+                }
+                continue;
+            }
+            try {
+                const abs = resolveSafe(workspace, p);
+                const content = fs.readFileSync(abs, "utf8");
+                const capped = content.length > MAX_MENTION_CHARS
+                    ? content.slice(0, MAX_MENTION_CHARS) + "\n… (truncated)"
+                    : content;
+                extra += `\n\n[Attached file: ${p}]\n\`\`\`\n${capped}\n\`\`\``;
+            }
+            catch {
+                // Not a real file — leave the @word as-is.
+            }
+        }
+        return text + extra;
+    };
+    // Collect @-mentioned image files as data URIs for vision-capable models.
+    const collectImages = (text) => {
+        const images = [];
+        for (const p of new Set([...text.matchAll(MENTION_ALL_RE)].map((m) => m[1]))) {
+            if (!IMAGE_RE.test(p))
+                continue;
+            try {
+                const abs = resolveSafe(workspace, p);
+                const b64 = fs.readFileSync(abs).toString("base64");
+                const ext = p.split(".").pop().toLowerCase();
+                const mime = ext === "jpg" ? "jpeg" : ext;
+                images.push(`data:image/${mime};base64,${b64}`);
+            }
+            catch {
+                // Not a readable image — skip.
+            }
+        }
+        return images;
+    };
+    const handleSubmit = async (value) => {
+        // Enter while command suggestions are open selects the highlighted command instead of sending.
+        if (suggestions.length && value.trim() !== suggestions[selectedCmd].name) {
+            setInput(suggestions[selectedCmd].name + " ");
+            setInputKey((k) => k + 1);
+            setCmdIndex(0);
+            return;
+        }
+        // Enter while file suggestions are open completes the mention instead of sending.
+        if (fileSuggestions.length && mentionFragment !== fileSuggestions[selectedFile].toLowerCase()) {
+            completeMention(fileSuggestions[selectedFile]);
+            return;
+        }
+        const text = value.trim();
+        setInput("");
+        setCmdIndex(0);
+        setFileIndex(0);
+        histIndex.current = -1;
+        if (!text)
+            return;
+        if (inputHistory.current[inputHistory.current.length - 1] !== text) {
+            inputHistory.current.push(text);
+        }
+        if (text.startsWith("/")) {
+            handleSlash(text);
+            return;
+        }
+        addItem({ kind: "user", text });
+        const images = collectImages(text);
+        if (images.length)
+            addItem({ kind: "info", text: `Attached ${images.length} image(s).` });
+        await runAgent(await expandMentions(text), images);
+    };
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Static, { items: items, children: (item) => _jsx(TranscriptItem, { item: item, verbose: verbose, stdout: stdout }, item.id) }, staticKey), stream ? (_jsx(Box, { marginBottom: 1, children: _jsx(Markdown, { text: tailForViewport(stream, terminalColumns(stdout), terminalRows(stdout)), streaming: true }) })) : null, tasks.length > 0 && (_jsx(Box, { flexDirection: "column", borderStyle: "round", borderColor: "blue", paddingX: 1, width: Math.min(terminalColumns(stdout) - 2, Math.max(...tasks.map((t) => stringWidth(t.text))) + 6), children: tasks.map((t, i) => (_jsxs(Text, { color: t.status === "done" ? "green" : t.status === "in_progress" ? "yellow" : undefined, dimColor: t.status === "pending", children: [t.status === "done" ? "☑" : t.status === "in_progress" ? "◐" : "☐", " ", t.text] }, i))) })), phase === "working" && (_jsxs(Box, { flexDirection: "column", children: [_jsx(Spinner, { label: 
+                        // The workflow prefix rides on every branch, not just "thinking":
+                        // during a phase you want to know which phase a tool call belongs
+                        // to just as much as which phase is being reasoned about.
+                        (runningPhase ? `${workflow?.name ?? ""} · ${runningPhase} phase · ` : "") +
+                            (inFlight.length > 1
+                                ? `${inFlight.length} tools running (Esc to cancel)`
+                                : inFlight.length === 1
+                                    ? `${inFlight[0].status ? `${inFlight[0].summary} — ${inFlight[0].status}` : inFlight[0].summary} (Esc to cancel)`
+                                    : activity
+                                        ? activity
+                                        : thinking
+                                            ? "thinking… (Esc to cancel)"
+                                            : "working… (Esc to cancel)") }), inFlight.length > 1 && (_jsx(Box, { flexDirection: "column", marginLeft: 2, children: inFlight.map((t) => (_jsxs(Text, { dimColor: true, children: ["\u00B7 ", t.status ? `${t.summary} — ${t.status}` : t.summary] }, t.id))) })), _jsxs(Box, { borderStyle: "round", borderColor: "yellow", paddingX: 1, children: [_jsx(Text, { color: "yellow", children: "\u21B3 " }), _jsx(TextInput, { value: steerInput, onChange: (v) => setSteerInput((prev) => (isCtrlEcho(prev, v) ? prev : v)), onSubmit: (value) => {
+                                    const text = value.trim();
+                                    setSteerInput("");
+                                    if (!text)
+                                        return;
+                                    if (text.startsWith("/")) {
+                                        addItem({
+                                            kind: "info",
+                                            text: "Commands are unavailable while the agent is working — press Esc to interrupt first.",
+                                        });
+                                        return;
+                                    }
+                                    addItem({ kind: "user", text: `${text} (queued)` });
+                                    void expandMentions(text).then((t) => agent.queueSteer(t));
+                                }, placeholder: "steer the agent\u2026 (Enter to queue)" })] })] })), phase === "permission" && permission && (_jsx(PermissionPrompt, { toolName: permission.toolName, summary: permission.summary, diff: permission.diff, warning: permission.warning, onDecision: onPermissionDecision })), phase === "elicitation" && elicitation && (_jsx(ElicitationPrompt, { message: elicitation.message, fields: elicitation.fields, onDecision: onElicitationDecision })), phase === "confirmMode" && (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "green", paddingX: 1, children: [_jsx(Text, { bold: true, color: "green", children: "Switch to accept-edits mode?" }), _jsx(Text, { children: "File writes and edits will auto-approve without asking." }), _jsx(Text, { dimColor: true, children: "Destructive shell commands (rm -rf, force-push, etc.) always still ask, in every mode." }), _jsx(Text, { dimColor: true, children: "Shift+Tab again moves to dry-run mode; once more back to normal." }), _jsx(Box, { marginTop: 1, children: _jsxs(Text, { children: [_jsx(Text, { color: "green", children: "Yes (y)" }), " \u00B7 No (n/Esc)"] }) })] })), phase === "model" && (_jsx(ModelPicker, { current: model, customModels: config.customModels ?? [], onSelect: (id) => {
+                    setPhase("input");
+                    setModelEverywhere(id);
+                }, onCancel: () => setPhase("input") })), phase === "resume" && (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "magenta", paddingX: 1, children: [_jsxs(Text, { bold: true, color: "magenta", children: ["Resume a session ", _jsx(Text, { dimColor: true, children: "(type to search \u00B7 Esc for a fresh one)" })] }), resumeFilter ? (_jsxs(Text, { children: [_jsx(Text, { dimColor: true, children: "filter: " }), resumeFilter] })) : null, _jsx(SelectList, { items: (resumeSessions ?? [])
+                            .filter((s) => s.title.toLowerCase().includes(resumeFilter.toLowerCase()) ||
+                            SessionStore.matchesContent(s.file, resumeFilter))
+                            .map((s) => ({
+                            label: s.title,
+                            value: s.file,
+                            hint: `${s.date} · ${s.count} msgs`,
+                        })), onSelect: onResumeSelect, onCancel: () => onResumeSelect("") })] })), phase === "input" && (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { borderStyle: "round", borderColor: "gray", paddingX: 1, children: [_jsx(Text, { color: "green", children: "\u276F " }), _jsx(TextInput, { value: input, onChange: (v) => {
+                                    setInput((prev) => (isCtrlEcho(prev, v) ? prev : v.replace(/\t/g, "")));
+                                    setCmdIndex(0);
+                                    setFileIndex(0);
+                                }, onSubmit: handleSubmit }, inputKey)] }), suggestions.length > 0 && (_jsxs(Box, { flexDirection: "column", paddingLeft: 2, children: [suggestions.map((c, i) => (_jsxs(Text, { color: i === selectedCmd ? "cyan" : undefined, children: [i === selectedCmd ? "❯ " : "  ", _jsx(Text, { bold: i === selectedCmd, children: c.name }), _jsxs(Text, { dimColor: true, children: [" \u2014 ", c.description] })] }, c.name))), _jsx(Text, { dimColor: true, children: "\u2191\u2193 select \u00B7 Tab/Enter select \u00B7 Enter again to run" })] })), fileSuggestions.length > 0 && (_jsxs(Box, { flexDirection: "column", paddingLeft: 2, children: [fileSuggestions.map((f, i) => (_jsxs(Text, { color: i === selectedFile ? "cyan" : undefined, children: [i === selectedFile ? "❯ " : "  ", f] }, f))), _jsx(Text, { dimColor: true, children: "\u2191\u2193 select \u00B7 Tab/Enter attach file" })] }))] })), _jsx(Box, { children: _jsx(StatusLine, { killed: killed, killReason: killReason, dryRunMode: dryRunMode, planMode: planMode, acceptEdits: acceptEdits, autoApprovedCount: autoApprovedCount, model: servedModel && servedModel !== model
+                        ? `${model}-${modelDisplaySlug(servedModel)}`
+                        : model, workflow: workflow, branch: branch, tasks: tasks, ctxPct: ctxPct, budgetPct: budgetPct, budgetStopped: budgetStopped, phase: phase, elapsed: elapsed, totalUsage: totalUsage, totalCost: totalCost, verbose: verbose, workspace: workspace }) })] }));
+}

package/dist/ui/Banner.js

@@ -0,0 +1,71 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from "ink";
+import { terminalColumns } from "./viewport.js";
+// Dot-matrix glyphs (7 rows). "#" is an on pixel, "." is off.
+const GLYPHS = {
+    K: ["#....#", "#...#.", "#..#..", "###...", "#..#..", "#...#.", "#....#"],
+    R: ["#####.", "#....#", "#....#", "#####.", "#..#..", "#...#.", "#....#"],
+    T: ["######", "..##..", "..##..", "..##..", "..##..", "..##..", "..##.."],
+    Y: ["#....#", "#....#", ".#..#.", "..##..", "..##..", "..##..", "..##.."],
+    A: [".####.", "#....#", "#....#", "######", "#....#", "#....#", "#....#"],
+    I: ["####", ".##.", ".##.", ".##.", ".##.", ".##.", "####"],
+    "-": ["....", "....", "....", "####", "....", "....", "...."],
+};
+const ROWS = 7;
+export function bannerLines(text, pixel) {
+    const off = " ".repeat(pixel.length);
+    const lines = [];
+    for (let row = 0; row < ROWS; row++) {
+        lines.push([...text]
+            .map((ch) => (GLYPHS[ch] ?? GLYPHS["-"])[row]
+            .split("")
+            .map((p) => (p === "#" ? pixel : off))
+            .join(""))
+            .join(off));
+    }
+    return lines;
+}
+/** Column (within a bannerLines() row) where each character of `text` starts. */
+function letterOffsets(text, pixelLen) {
+    const offsets = [];
+    let col = 0;
+    [...text].forEach((ch, i) => {
+        if (i > 0)
+            col += pixelLen;
+        offsets.push(col);
+        col += (GLYPHS[ch] ?? GLYPHS["-"])[0].length * pixelLen;
+    });
+    return offsets;
+}
+/** Width (in bannerLines() columns) of one glyph. */
+function letterWidth(ch, pixelLen) {
+    return (GLYPHS[ch] ?? GLYPHS["-"])[0].length * pixelLen;
+}
+// Vertical gradient: cyan at the top fading into NVIDIA green.
+const TOP_RGB = [0x00, 0xd9, 0xff];
+const BOTTOM_RGB = [0x76, 0xb9, 0x00];
+function rowColor(row) {
+    const t = row / (ROWS - 1);
+    const [r, g, b] = TOP_RGB.map((c, i) => Math.round(c + (BOTTOM_RGB[i] - c) * t));
+    return `#${[r, g, b].map((c) => c.toString(16).padStart(2, "0")).join("")}`;
+}
+const BETA_LABEL = "beta";
+export function Banner({ subtitle }) {
+    const columns = terminalColumns(process.stdout);
+    const wide = bannerLines("KRITYA", "░░");
+    const narrow = bannerLines("KRITYA", "░");
+    const pixelLen = wide[0].length <= columns ? 2 : narrow[0].length <= columns ? 1 : 0;
+    const lines = pixelLen === 2 ? wide : pixelLen === 1 ? narrow : null;
+    const center = (text) => " ".repeat(Math.max(0, Math.floor((columns - text.length) / 2))) + text;
+    // Right-align "beta" under the final "A" of KRITYA, one line below the glyph.
+    const betaLine = (() => {
+        if (!lines)
+            return null;
+        const leftPad = Math.max(0, Math.floor((columns - lines[0].length) / 2));
+        const aStart = letterOffsets("KRITYA", pixelLen)[5];
+        const aWidth = letterWidth("A", pixelLen);
+        const indent = leftPad + aStart + Math.max(0, aWidth - BETA_LABEL.length);
+        return " ".repeat(indent) + BETA_LABEL;
+    })();
+    return (_jsxs(Box, { flexDirection: "column", marginTop: 2, marginBottom: 1, children: [lines ? (lines.map((line, i) => (_jsx(Text, { color: rowColor(i), children: center(line) }, i)))) : (_jsx(Text, { bold: true, color: "cyan", children: center("KRITYA") })), betaLine ? _jsx(Text, { dimColor: true, children: betaLine }) : null, _jsx(Box, { marginTop: 2, children: subtitle ? _jsx(Text, { dimColor: true, children: center(subtitle) }) : null }), _jsx(Text, { dimColor: true, children: center("AI can make mistakes. Verify important output.") })] }));
+}

package/dist/ui/ElicitationPrompt.js

@@ -0,0 +1,46 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { useState } from "react";
+import { Box, Text, useInput } from "ink";
+import TextInput from "ink-text-input";
+import { SelectList } from "./SelectList.js";
+/**
+ * One field at a time, same reasoning as McpTrustPrompt's one-server-at-a-time
+ * flow: a multi-field form rendered all at once in a terminal is hard to
+ * navigate and easy to fat-finger past a field the user meant to change.
+ */
+export function ElicitationPrompt({ message, fields, onDecision, }) {
+    const [index, setIndex] = useState(0);
+    const [content, setContent] = useState({});
+    const [textValue, setTextValue] = useState("");
+    const finish = (finalContent) => onDecision({ action: "accept", content: finalContent });
+    const answer = (value) => {
+        const field = fields[index];
+        const next = { ...content, [field.name]: value };
+        if (index + 1 < fields.length) {
+            setContent(next);
+            setTextValue("");
+            setIndex(index + 1);
+        }
+        else {
+            finish(next);
+        }
+    };
+    const field = fields[index];
+    // SelectList handles its own Escape-to-cancel; the free-text field below has
+    // no such built-in, so it needs its own listener.
+    useInput((_input, key) => {
+        if (field?.kind === "string" && key.escape)
+            onDecision({ action: "cancel" });
+    });
+    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "cyan", paddingX: 1, children: [_jsxs(Text, { bold: true, color: "cyan", children: ["Server request", fields.length > 1 ? ` (${index + 1} of ${fields.length})` : ""] }), _jsx(Text, { children: message }), field ? (_jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsx(Text, { dimColor: true, children: field.label }), field.kind === "boolean" ? (_jsx(SelectList, { items: [
+                            { label: "Yes", value: "yes" },
+                            { label: "No", value: "no" },
+                        ], onSelect: (v) => answer(v === "yes"), onCancel: () => onDecision({ action: "cancel" }) }, field.name)) : field.kind === "enum" ? (_jsx(SelectList, { items: field.options.map((o) => ({ label: o, value: o })), onSelect: (v) => answer(v), onCancel: () => onDecision({ action: "cancel" }) }, field.name)) : (_jsxs(Box, { children: [_jsx(Text, { color: "cyan", children: "> " }), _jsx(TextInput, { value: textValue, onChange: setTextValue, onSubmit: (v) => {
+                                    const trimmed = v.trim();
+                                    if (trimmed)
+                                        answer(trimmed);
+                                } })] }))] })) : (_jsx(Box, { marginTop: 1, children: _jsx(SelectList, { items: [
+                        { label: "Accept (no fields to fill)", value: "accept" },
+                        { label: "Decline", value: "decline" },
+                    ], onSelect: (v) => (v === "accept" ? finish({}) : onDecision({ action: "decline" })), onCancel: () => onDecision({ action: "cancel" }) }) }))] }));
+}