cvc-tui 0.1.0

package/dist/components/textInput.js

@@ -0,0 +1,264 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+// CVC power-input composer — Hermes ui-tui parity.
+//
+// Features:
+//  • Multi-line buffer (Alt+Enter / Shift+Enter newline; Enter submit)
+//  • Word-wrap to terminal columns
+//  • Visible inverse-block cursor
+//  • Dim live char/line counter footer
+//  • Up/Down history cycle (when on first/last logical line)
+//  • Ctrl+R reverse-incremental search overlay
+//  • Tab completion: slash commands + file paths
+//  • Ctrl+L clears
+//  • Queued submission indicator `[queued: N]`
+//  • Hidden when promptStore has an active confirm/secret prompt
+//
+// Pure buffer math lives in ../app/inputBuffer.ts; this file is the React
+// glue + key dispatch.
+import { useCallback, useEffect, useState } from 'react';
+import { Box, Text, useInput } from 'ink';
+import { useStore } from '@nanostores/react';
+import { $buffer, $completion, resetCompletion, setBuffer, setBufferRaw, } from '../app/inputStore.js';
+import { emptyBuffer, insert, backspace, del as bufDel, moveLeft, moveRight, moveHome, moveEnd, moveUp, moveDown, onFirstLine, onLastLine, bufferStats, cursorRowCol, } from '../app/inputBuffer.js';
+import { $history, loadHistory, pushHistory, historyPrev, historyNext, resetHistoryBrowse, } from '../app/historyStore.js';
+import { $queue } from '../app/queueStore.js';
+import { $prompt } from '../app/promptStore.js';
+import { $ui } from '../app/uiStore.js';
+import { tokenAtCursor, candidatesFor, applyCandidate, } from '../app/completion.js';
+import { HistorySearch } from './overlays/historySearch.js';
+import { ConfirmPrompt } from './overlays/confirmPrompt.js';
+import { SecretPrompt } from './overlays/secretPrompt.js';
+const PROMPT_COLOR = '#e63946';
+/**
+ * Render the buffer with an inverse-block cursor at `cursor`. Wraps to `cols`
+ * columns. Returns an array of visual lines (already containing ANSI invert
+ * codes for the cursor cell).
+ */
+function renderWrapped(buf, _cols) {
+    const text = buf.text;
+    const cursor = Math.max(0, Math.min(buf.cursor, text.length));
+    // Insert cursor sentinel as inverted character.
+    const ESC = '\x1b';
+    const INV = `${ESC}[7m`;
+    const OFF = `${ESC}[27m`;
+    const ch = cursor < text.length && text[cursor] !== '\n' ? text[cursor] : ' ';
+    const withCursor = text.slice(0, cursor) + INV + ch + OFF + text.slice(cursor + (cursor < text.length && text[cursor] !== '\n' ? 1 : 0));
+    // Wrap each logical line. We can't naively wrapText because of escape codes;
+    // however the codes are zero-width so length-based wrap with the *raw* text
+    // still produces visually correct output if we map back. For simplicity and
+    // since terminal widths in our tests are generous, we wrap on raw text with
+    // injected codes treated as part of the line — the codes themselves don't
+    // consume cells, but wrapText sees them as chars. To stay correct, wrap the
+    // raw line and re-inject the cursor cell.
+    // Simpler: split on '\n' from withCursor and let Ink soft-wrap visually.
+    return withCursor.split('\n');
+}
+/** Slim hint footer: `chars · lines · [queued: N]`. */
+const Hints = ({ chars, lineCount, queued, mode, }) => {
+    const parts = [`${chars} chars`, `${lineCount} line${lineCount === 1 ? '' : 's'}`];
+    if (queued > 0)
+        parts.push(`queued: ${queued}`);
+    if (mode)
+        parts.push(mode);
+    return (_jsx(Box, { children: _jsx(Text, { dimColor: true, children: parts.join(' · ') }) }));
+};
+export const Composer = ({ onSubmit, placeholder, prompt = '❯' }) => {
+    const buf = useStore($buffer);
+    const completion = useStore($completion);
+    const ui = useStore($ui);
+    const queue = useStore($queue);
+    const prompts = useStore($prompt);
+    const history = useStore($history);
+    const [searchOpen, setSearchOpen] = useState(false);
+    // One-time history load.
+    useEffect(() => {
+        if (history.length === 0)
+            loadHistory();
+    }, [history.length]);
+    // If a prompt is active, show the appropriate overlay instead of the composer.
+    // (Composer hides — Hermes parity.)
+    if (prompts) {
+        if (prompts.kind === 'confirm')
+            return _jsx(ConfirmPrompt, {});
+        if (prompts.kind === 'secret')
+            return _jsx(SecretPrompt, {});
+    }
+    if (searchOpen) {
+        return (_jsx(HistorySearch, { onAccept: (entry) => {
+                setBuffer({ text: entry, cursor: entry.length });
+                setSearchOpen(false);
+            }, onCancel: () => setSearchOpen(false) }));
+    }
+    const cols = Math.max(20, ui.cols ?? 80);
+    const submit = useCallback(() => {
+        const text = buf.text;
+        if (!text.trim()) {
+            // Empty submit: just clear.
+            setBuffer(emptyBuffer());
+            return;
+        }
+        pushHistory(text);
+        resetHistoryBrowse();
+        setBuffer(emptyBuffer());
+        if (onSubmit)
+            onSubmit(text);
+    }, [buf.text, onSubmit]);
+    const cycleCompletion = useCallback((dir) => {
+        // Tab pressed: either start a new cycle or rotate the existing one.
+        if (completion.active && completion.candidates.length > 0) {
+            const n = completion.candidates.length;
+            const nextIdx = (completion.index + dir + n) % n;
+            const cand = completion.candidates[nextIdx];
+            const replaced = applyCandidate(buf.text, completion.start, completion.prefix.length, cand);
+            // Use raw setter so we don't reset the cycle.
+            setBufferRaw({ text: replaced.text, cursor: replaced.cursor });
+            $completion.set({
+                ...completion,
+                index: nextIdx,
+                prefix: cand,
+            });
+            return;
+        }
+        const ctx = tokenAtCursor(buf.text, buf.cursor);
+        if (!ctx)
+            return;
+        const cands = candidatesFor(ctx);
+        if (cands.length === 0)
+            return;
+        const first = cands[0];
+        const replaced = applyCandidate(buf.text, ctx.start, ctx.token.length, first);
+        setBufferRaw({ text: replaced.text, cursor: replaced.cursor });
+        $completion.set({
+            active: true,
+            prefix: first,
+            candidates: cands,
+            index: 0,
+            start: ctx.start,
+        });
+    }, [buf.text, buf.cursor, completion]);
+    useInput((input, key) => {
+        // Ctrl+L: clear buffer.
+        if (key.ctrl && input === 'l') {
+            setBuffer(emptyBuffer());
+            return;
+        }
+        // Ctrl+R: open reverse-search overlay.
+        if (key.ctrl && input === 'r') {
+            setSearchOpen(true);
+            return;
+        }
+        // Ctrl+C: clear current input (don't crash; parent handles outer SIGINT).
+        if (key.ctrl && input === 'c') {
+            if (buf.text.length === 0) {
+                process.exit(0);
+            }
+            setBuffer(emptyBuffer());
+            return;
+        }
+        // Tab / Shift+Tab.
+        if (key.tab) {
+            cycleCompletion(key.shift ? -1 : 1);
+            return;
+        }
+        // Enter / newline. Ink reports Alt+Enter via key.meta, Shift+Enter via key.shift.
+        if (key.return) {
+            if (key.meta || key.shift) {
+                setBuffer(insert(buf, '\n'));
+                return;
+            }
+            submit();
+            return;
+        }
+        if (key.backspace || key.delete) {
+            // Ink convention: `key.delete` is forward-delete on some terms; `key.backspace` for backspace.
+            if (key.delete && !key.backspace) {
+                setBuffer(bufDel(buf));
+            }
+            else {
+                setBuffer(backspace(buf));
+            }
+            return;
+        }
+        if (key.leftArrow) {
+            setBuffer(moveLeft(buf));
+            return;
+        }
+        if (key.rightArrow) {
+            setBuffer(moveRight(buf));
+            return;
+        }
+        if (key.upArrow) {
+            // History cycle when on the first logical line.
+            if (onFirstLine(buf)) {
+                const entry = historyPrev(buf.text);
+                if (entry !== null) {
+                    setBuffer({ text: entry, cursor: entry.length });
+                }
+                return;
+            }
+            setBuffer(moveUp(buf));
+            return;
+        }
+        if (key.downArrow) {
+            if (onLastLine(buf)) {
+                const entry = historyNext();
+                if (entry !== null) {
+                    setBuffer({ text: entry, cursor: entry.length });
+                }
+                return;
+            }
+            setBuffer(moveDown(buf));
+            return;
+        }
+        // Home / End — Ink doesn't expose these directly; they often arrive as raw escapes.
+        if (key.ctrl && input === 'a') {
+            setBuffer(moveHome(buf));
+            return;
+        }
+        if (key.ctrl && input === 'e') {
+            setBuffer(moveEnd(buf));
+            return;
+        }
+        if (key.escape) {
+            // Esc: cancel completion, otherwise clear buffer.
+            if (completion.active) {
+                resetCompletion();
+                return;
+            }
+            setBuffer(emptyBuffer());
+            return;
+        }
+        // Printable input.
+        if (input && !key.ctrl && !key.meta) {
+            setBuffer(insert(buf, input));
+            return;
+        }
+    });
+    const stats = bufferStats(buf.text);
+    const wrapped = renderWrapped(buf, cols);
+    const showPlaceholder = buf.text.length === 0 && placeholder;
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { children: [_jsxs(Text, { color: PROMPT_COLOR, children: [prompt, " "] }), showPlaceholder ? (_jsx(Text, { dimColor: true, children: placeholder })) : (_jsx(Box, { flexDirection: "column", children: wrapped.map((line, i) => (_jsx(Text, { children: line || ' ' }, i))) }))] }), _jsx(Hints, { chars: stats.chars, lineCount: stats.lineCount, queued: queue.length, mode: completion.active ? `tab ${completion.index + 1}/${completion.candidates.length}` : undefined })] }));
+};
+export const TextInput = ({ value, onChange, onSubmit, placeholder, prompt }) => {
+    const buf = useStore($buffer);
+    // Sync controlled value into the store on mount / external change.
+    useEffect(() => {
+        if (buf.text !== value) {
+            setBuffer({ text: value, cursor: value.length });
+        }
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [value]);
+    // Push buffer changes back to parent on every text change.
+    useEffect(() => {
+        if (buf.text !== value)
+            onChange(buf.text);
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [buf.text]);
+    return (_jsx(Composer, { placeholder: placeholder, prompt: prompt, onSubmit: (t) => {
+            onChange('');
+            if (onSubmit)
+                onSubmit(t);
+        } }));
+};
+// Re-exports for tests / consumers.
+export { cursorRowCol };

package/dist/components/thinking.js

@@ -0,0 +1,39 @@
+import { jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useState } from 'react';
+import { Box, Text } from 'ink';
+import { TIMING } from '../config/timing.js';
+// unicode-animations exposes a large catalog of frame arrays. We import lazily
+// and gracefully fall back if the shape changes.
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+let UA = null;
+try {
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    UA = await import('unicode-animations').catch(() => null);
+}
+catch {
+    UA = null;
+}
+const FALLBACK_FRAMES = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+function pickFrames() {
+    try {
+        if (UA?.default?.dots)
+            return UA.default.dots;
+        if (Array.isArray(UA?.dots))
+            return UA.dots;
+    }
+    catch {
+        /* ignore */
+    }
+    return FALLBACK_FRAMES;
+}
+export const Thinking = ({ label = 'thinking', color = '#e63946' }) => {
+    const [frame, setFrame] = useState(0);
+    const frames = pickFrames();
+    useEffect(() => {
+        const id = setInterval(() => {
+            setFrame((f) => (f + 1) % frames.length);
+        }, TIMING.SPINNER_FRAME_MS);
+        return () => clearInterval(id);
+    }, [frames.length]);
+    return (_jsxs(Box, { children: [_jsxs(Text, { color: color, children: [frames[frame], " "] }), _jsxs(Text, { color: "gray", children: [label, "\u2026"] })] }));
+};

package/dist/components/transcript.js

@@ -0,0 +1,22 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+import { useStore } from '@nanostores/react';
+import { $messages, $turn } from '../app/turnStore.js';
+import { Markdown, StreamingMarkdown } from './streamingMarkdown.js';
+import { CVC_THEME } from '../types.js';
+const Bubble = ({ msg, streaming }) => {
+    const isUser = msg.role === 'user';
+    const borderColor = isUser ? CVC_THEME.primary : CVC_THEME.dim;
+    const tag = isUser ? 'you' : msg.role === 'assistant' ? 'cvc' : msg.role;
+    const tagColor = isUser ? CVC_THEME.primary : CVC_THEME.accent;
+    return (_jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [_jsx(Text, { bold: true, color: tagColor, children: `▌ ${tag}` }), _jsx(Box, { borderStyle: "round", borderColor: borderColor, paddingX: 1, flexDirection: "column", children: isUser ? (_jsx(Text, { children: msg.content })) : streaming ? (_jsx(StreamingMarkdown, { content: msg.content })) : (_jsx(Markdown, { text: msg.content })) })] }));
+};
+export const Transcript = () => {
+    const messages = useStore($messages);
+    const turn = useStore($turn);
+    if (messages.length === 0) {
+        return (_jsx(Box, { marginY: 1, children: _jsx(Text, { color: CVC_THEME.dim, children: "\u2014 no messages yet \u2014 type below to start \u2014" }) }));
+    }
+    const lastId = messages[messages.length - 1]?.id;
+    return (_jsx(Box, { flexDirection: "column", marginY: 1, children: messages.map((m) => (_jsx(Bubble, { msg: m, streaming: m.role === 'assistant' && m.id === lastId && turn?.status === 'streaming' }, m.id))) }));
+};

package/dist/config/timing.js

@@ -0,0 +1,14 @@
+// Centralised timing constants for the CVC TUI.
+// Keep all magic numbers controlling UI cadence in this file.
+export const TIMING = {
+    /** Spinner frame interval (ms) */
+    SPINNER_FRAME_MS: 80,
+    /** Throttle for streaming markdown re-renders (ms) */
+    STREAM_THROTTLE_MS: 16,
+    /** Debounce on text-input change handlers (ms) */
+    INPUT_DEBOUNCE_MS: 0,
+    /** Gateway connect retry backoff (ms) */
+    GATEWAY_RECONNECT_MS: 1500,
+    /** Heartbeat ping interval (ms) */
+    HEARTBEAT_MS: 15000,
+};

package/dist/entry.js

@@ -0,0 +1,43 @@
+#!/usr/bin/env node
+import { jsx as _jsx } from "react/jsx-runtime";
+// CVC TUI entrypoint. Verifies a TTY, connects to the Python JSON-RPC
+// gateway via subprocess stdio, then mounts <App/>.
+import { render } from 'ink';
+import { App } from './app.js';
+import { GatewayClient } from './gateway/client.js';
+import { renderBannerPlain } from './banner.js';
+const VERSION = '0.0.1';
+async function main() {
+    if (!process.stdout.isTTY) {
+        process.stdout.write(renderBannerPlain({ version: VERSION, model: process.env.CVC_MODEL ?? 'unknown' }) + '\n');
+        process.stdout.write('cvc-tui requires a TTY to run interactively.\n');
+        process.exit(0);
+    }
+    const gateway = new GatewayClient();
+    let model = process.env.CVC_MODEL ?? 'claude-sonnet-4-6';
+    try {
+        const session = await gateway.connect();
+        model = session.model || model;
+    }
+    catch (err) {
+        process.stderr.write(`gateway connect failed: ${err.message}\n`);
+        process.exit(1);
+    }
+    const { waitUntilExit } = render(_jsx(App, { version: VERSION, model: model, gateway: gateway }));
+    // Clean Ctrl-C exit even if Ink loses focus.
+    const onSignal = () => {
+        void gateway.close().finally(() => process.exit(0));
+    };
+    process.on('SIGINT', onSignal);
+    process.on('SIGTERM', onSignal);
+    try {
+        await waitUntilExit();
+    }
+    finally {
+        await gateway.close().catch(() => { });
+    }
+}
+main().catch((err) => {
+    process.stderr.write(`fatal: ${err.stack ?? err}\n`);
+    process.exit(1);
+});