cvc-tui 0.4.4 → 0.4.7

package/dist/app/useSessionLifecycle.js

@@ -0,0 +1,175 @@
+// @ts-nocheck
+// SPDX-License-Identifier: MIT
+// Ported from CVC Agent (https://github.com/NousResearch/cvc)
+// Original Copyright (c) 2025 Nous Research. CVC adaptations (c) 2026 Jai Kumar Meena.
+import { writeFileSync } from 'node:fs';
+import { evictInkCaches } from '../vendor/cvc-ink/index.js';
+import { useCallback } from 'react';
+import { buildSetupRequiredSections, SETUP_REQUIRED_TITLE } from '../content/setup.js';
+import { introMsg, toTranscriptMessages } from '../domain/messages.js';
+import { ZERO } from '../domain/usage.js';
+import { asRpcResult } from '../lib/rpc.js';
+import { patchOverlayState } from './overlayStore.js';
+import { turnController } from './turnController.js';
+import { patchTurnState } from './turnStore.js';
+import { getUiState, patchUiState } from './uiStore.js';
+const usageFrom = (info) => (info?.usage ? { ...ZERO, ...info.usage } : ZERO);
+export const writeActiveSessionFile = (sessionId, file = process.env.CVC_TUI_ACTIVE_SESSION_FILE) => {
+    if (!file || !sessionId) {
+        return;
+    }
+    try {
+        writeFileSync(file, JSON.stringify({ session_id: sessionId }), { mode: 0o600 });
+    }
+    catch {
+        // Best-effort shell epilogue hint only; never break live session changes.
+    }
+};
+const trimTail = (items) => {
+    const q = [...items];
+    while (q.at(-1)?.role === 'assistant' || q.at(-1)?.role === 'tool') {
+        q.pop();
+    }
+    if (q.at(-1)?.role === 'user') {
+        q.pop();
+    }
+    return q;
+};
+export function useSessionLifecycle(opts) {
+    const { colsRef, composerActions, gw, panel, rpc, scrollRef, setHistoryItems, setLastUserMsg, setSessionStartedAt, setStickyPrompt, setVoiceProcessing, setVoiceRecording, sys } = opts;
+    const closeSession = useCallback((targetSid) => targetSid ? rpc('session.close', { session_id: targetSid }) : Promise.resolve(null), [rpc]);
+    const resetSession = useCallback(() => {
+        turnController.fullReset();
+        setVoiceRecording(false);
+        setVoiceProcessing(false);
+        patchUiState({ bgTasks: new Set(), info: null, sid: null, usage: ZERO });
+        setHistoryItems([]);
+        setLastUserMsg('');
+        setStickyPrompt('');
+        composerActions.setPasteSnips([]);
+        // Half-prune: new session has new keys, but keep a warm pool in case
+        // the user resumes back to the prior session.
+        evictInkCaches('half');
+    }, [composerActions, setHistoryItems, setLastUserMsg, setStickyPrompt, setVoiceProcessing, setVoiceRecording]);
+    const resetVisibleHistory = useCallback((info = null) => {
+        turnController.idle();
+        turnController.clearReasoning();
+        turnController.turnTools = [];
+        turnController.persistedToolLabels.clear();
+        setHistoryItems(info ? [introMsg(info)] : []);
+        setStickyPrompt('');
+        setLastUserMsg('');
+        composerActions.setPasteSnips([]);
+        patchTurnState({ activity: [] });
+        patchUiState({ info, usage: usageFrom(info) });
+    }, [composerActions, setHistoryItems, setLastUserMsg, setStickyPrompt]);
+    const newSession = useCallback(async (msg, title) => {
+        const setup = await rpc('setup.status', {});
+        if (setup?.provider_configured === false) {
+            panel(SETUP_REQUIRED_TITLE, buildSetupRequiredSections());
+            patchUiState({ status: 'setup required' });
+            return;
+        }
+        await closeSession(getUiState().sid);
+        const r = await rpc('session.create', { cols: colsRef.current });
+        if (!r) {
+            return patchUiState({ status: 'ready' });
+        }
+        const info = r.info ?? null;
+        const requestedTitle = title?.trim() ?? '';
+        resetSession();
+        setSessionStartedAt(Date.now());
+        writeActiveSessionFile(r.session_id);
+        patchUiState({
+            info,
+            sid: r.session_id,
+            status: info?.version ? 'ready' : 'starting agent…',
+            usage: usageFrom(info)
+        });
+        if (info) {
+            setHistoryItems([introMsg(info)]);
+        }
+        if (info?.credential_warning) {
+            sys(`warning: ${info.credential_warning}`);
+        }
+        if (info?.config_warning) {
+            sys(`warning: ${info.config_warning}`);
+        }
+        if (msg) {
+            sys(msg);
+        }
+        if (requestedTitle) {
+            rpc('session.title', {
+                session_id: r.session_id,
+                title: requestedTitle
+            })
+                .then(result => {
+                if (!result || getUiState().sid !== r.session_id) {
+                    return;
+                }
+                const nextTitle = (result.title ?? requestedTitle).trim();
+                const suffix = result.pending ? ' (queued while session initializes)' : '';
+                sys(`session title set: ${nextTitle}${suffix}`);
+            })
+                .catch((err) => {
+                if (getUiState().sid !== r.session_id) {
+                    return;
+                }
+                const message = err instanceof Error ? err.message : String(err);
+                sys(`warning: failed to set session title: ${message}`);
+            });
+        }
+    }, [closeSession, colsRef, panel, resetSession, rpc, setHistoryItems, setSessionStartedAt, sys]);
+    const resumeById = useCallback((id) => {
+        patchOverlayState({ picker: false });
+        patchUiState({ status: 'resuming…' });
+        rpc('setup.status', {}).then(setup => {
+            if (setup?.provider_configured === false) {
+                panel(SETUP_REQUIRED_TITLE, buildSetupRequiredSections());
+                patchUiState({ status: 'setup required' });
+                return;
+            }
+            closeSession(getUiState().sid === id ? null : getUiState().sid).then(() => gw
+                .request('session.resume', { cols: colsRef.current, session_id: id })
+                .then(raw => {
+                const r = asRpcResult(raw);
+                if (!r) {
+                    sys('error: invalid response: session.resume');
+                    return patchUiState({ status: 'ready' });
+                }
+                resetSession();
+                setSessionStartedAt(Date.now());
+                const resumed = toTranscriptMessages(r.messages);
+                setHistoryItems(r.info ? [introMsg(r.info), ...resumed] : resumed);
+                writeActiveSessionFile(r.resumed ?? r.session_id);
+                patchUiState({
+                    info: r.info ?? null,
+                    sid: r.session_id,
+                    status: 'ready',
+                    usage: usageFrom(r.info ?? null)
+                });
+                setTimeout(() => scrollRef.current?.scrollToBottom(), 0);
+            })
+                .catch((e) => {
+                sys(`error: ${e.message}`);
+                patchUiState({ status: 'ready' });
+            }));
+        });
+    }, [closeSession, colsRef, gw, panel, resetSession, rpc, scrollRef, setHistoryItems, setSessionStartedAt, sys]);
+    const guardBusySessionSwitch = useCallback((what = 'switch sessions') => {
+        if (!getUiState().busy) {
+            return false;
+        }
+        sys(`interrupt the current turn before trying to ${what}`);
+        return true;
+    }, [sys]);
+    return {
+        closeSession,
+        guardBusySessionSwitch,
+        newSession,
+        resetSession,
+        resetVisibleHistory,
+        resumeById,
+        trimLastExchange: trimTail
+    };
+}

package/dist/app/useSubmission.js

@@ -0,0 +1,287 @@
+// @ts-nocheck
+// SPDX-License-Identifier: MIT
+// Ported from CVC Agent (https://github.com/NousResearch/cvc)
+// Original Copyright (c) 2025 Nous Research. CVC adaptations (c) 2026 Jai Kumar Meena.
+import { useCallback, useEffect, useRef } from 'react';
+import { TYPING_IDLE_MS } from '../config/timing.js';
+import { attachedImageNotice } from '../domain/messages.js';
+import { looksLikeSlashCommand } from '../domain/slash.js';
+import { asRpcResult } from '../lib/rpc.js';
+import { hasInterpolation, INTERPOLATION_RE } from '../protocol/interpolation.js';
+import { PASTE_SNIPPET_RE } from '../protocol/paste.js';
+import { turnController } from './turnController.js';
+import { getUiState, patchUiState } from './uiStore.js';
+const DOUBLE_ENTER_MS = 450;
+const SESSION_BUSY_RE = /session busy|waiting for model response/i;
+const isSessionBusyError = (e) => e instanceof Error && SESSION_BUSY_RE.test(e.message);
+const expandSnips = (snips) => {
+    const byLabel = new Map();
+    for (const { label, text } of snips) {
+        const hit = byLabel.get(label);
+        hit ? hit.push(text) : byLabel.set(label, [text]);
+    }
+    return (value) => value.replace(PASTE_SNIPPET_RE, tok => byLabel.get(tok)?.shift() ?? tok);
+};
+const spliceMatches = (text, matches, results) => matches.reduceRight((acc, m, i) => acc.slice(0, m.index) + results[i] + acc.slice(m.index + m[0].length), text);
+export function useSubmission(opts) {
+    const { appendMessage, composerActions, composerRefs, composerState, gw, maybeGoodVibes, setLastUserMsg, slashRef, submitRef, sys } = opts;
+    const lastEmptyAt = useRef(0);
+    const typingIdleTimer = useRef(null);
+    useEffect(() => {
+        if (typingIdleTimer.current) {
+            clearTimeout(typingIdleTimer.current);
+            typingIdleTimer.current = null;
+        }
+        if (!composerState.input && !composerState.inputBuf.length) {
+            turnController.relaxStreaming();
+            return;
+        }
+        if (getUiState().busy) {
+            turnController.boostStreamingForTyping();
+        }
+        typingIdleTimer.current = setTimeout(() => {
+            typingIdleTimer.current = null;
+            turnController.relaxStreaming();
+        }, TYPING_IDLE_MS);
+        return () => {
+            if (typingIdleTimer.current) {
+                clearTimeout(typingIdleTimer.current);
+                typingIdleTimer.current = null;
+            }
+        };
+    }, [composerState.input, composerState.inputBuf]);
+    const send = useCallback((text, showUserMessage = true) => {
+        const expand = expandSnips(composerState.pasteSnips);
+        const startSubmit = (displayText, submitText, showUserMessage = true) => {
+            const sid = getUiState().sid;
+            if (!sid) {
+                return sys('session not ready yet');
+            }
+            turnController.clearStatusTimer();
+            maybeGoodVibes(submitText);
+            setLastUserMsg(text);
+            if (showUserMessage) {
+                appendMessage({ role: 'user', text: displayText });
+            }
+            patchUiState({ busy: true, status: 'running…' });
+            turnController.bufRef = '';
+            turnController.interrupted = false;
+            gw.request('prompt.submit', { session_id: sid, text: submitText }).catch((e) => {
+                if (isSessionBusyError(e)) {
+                    composerActions.enqueue(submitText);
+                    patchUiState({ busy: true, status: 'queued for next turn' });
+                    return sys(`queued: "${submitText.slice(0, 50)}${submitText.length > 50 ? '…' : ''}"`);
+                }
+                sys(`error: ${e.message}`);
+                patchUiState({ busy: false, status: 'ready' });
+            });
+        };
+        const sid = getUiState().sid;
+        if (!sid) {
+            return sys('session not ready yet');
+        }
+        // Always ask the backend whether this looks like a file drop.
+        // The backend's _detect_file_drop handles paths with spaces, quotes,
+        // Windows drive letters, and escaped characters correctly.
+        gw.request('input.detect_drop', { session_id: sid, text })
+            .then(r => {
+            if (!r?.matched) {
+                return startSubmit(text, expand(text), showUserMessage);
+            }
+            if (r.is_image) {
+                turnController.pushActivity(attachedImageNotice(r));
+            }
+            else {
+                turnController.pushActivity(`detected file: ${r.name}`);
+            }
+            startSubmit(r.text || text, expand(r.text || text), showUserMessage);
+        })
+            .catch(() => startSubmit(text, expand(text), showUserMessage));
+    }, [appendMessage, composerActions, composerState.pasteSnips, gw, maybeGoodVibes, setLastUserMsg, sys]);
+    const shellExec = useCallback((cmd) => {
+        appendMessage({ role: 'user', text: `!${cmd}` });
+        patchUiState({ busy: true, status: 'running…' });
+        gw.request('shell.exec', { command: cmd })
+            .then(raw => {
+            const r = asRpcResult(raw);
+            if (!r) {
+                return sys('error: invalid response: shell.exec');
+            }
+            const out = [r.stdout, r.stderr].filter(Boolean).join('\n').trim();
+            if (out) {
+                sys(out);
+            }
+            if (r.code !== 0 || !out) {
+                sys(`exit ${r.code}`);
+            }
+        })
+            .catch((e) => sys(`error: ${e.message}`))
+            .finally(() => patchUiState({ busy: false, status: 'ready' }));
+    }, [appendMessage, gw, sys]);
+    const interpolate = useCallback((text, then) => {
+        patchUiState({ status: 'interpolating…' });
+        const matches = [...text.matchAll(new RegExp(INTERPOLATION_RE.source, 'g'))];
+        Promise.all(matches.map(m => gw
+            .request('shell.exec', { command: m[1] })
+            .then(raw => {
+            const r = asRpcResult(raw);
+            return [r?.stdout, r?.stderr].filter(Boolean).join('\n').trim();
+        })
+            .catch(() => '(error)'))).then(results => then(spliceMatches(text, matches, results)));
+    }, [gw]);
+    const sendQueued = useCallback((text) => {
+        if (text.startsWith('!')) {
+            return shellExec(text.slice(1).trim());
+        }
+        if (hasInterpolation(text)) {
+            patchUiState({ busy: true });
+            return interpolate(text, send);
+        }
+        send(text);
+    }, [interpolate, send, shellExec]);
+    // Honors `display.busy_input_mode` from config.yaml (CLI parity):
+    //   - 'queue'     (legacy): append to queueRef; drains on busy → false
+    //   - 'steer'     : inject into the current turn via session.steer; falls
+    //                   back to queue when steer is rejected (no agent / no
+    //                   tool window).
+    //   - 'interrupt' (default): cancel the in-flight turn, then send the
+    //                   new text as a fresh prompt so it actually moves.
+    //
+    // `opts.fallbackToFront` controls whether a steer fallback re-inserts
+    // at the front of the queue (used by the queue-edit path to preserve
+    // a picked item's position); the mainline submit path always appends.
+    const handleBusyInput = useCallback((full, opts = {}) => {
+        const live = getUiState();
+        const mode = live.busyInputMode;
+        const fallback = (note) => {
+            if (opts.fallbackToFront) {
+                composerRefs.queueRef.current.unshift(full);
+                composerActions.syncQueue();
+            }
+            else {
+                composerActions.enqueue(full);
+            }
+            sys(note);
+        };
+        if (mode === 'queue') {
+            return composerActions.enqueue(full);
+        }
+        if (mode === 'steer' && live.sid) {
+            gw.request('session.steer', { session_id: live.sid, text: full })
+                .then(raw => {
+                const r = asRpcResult(raw);
+                if (r?.status !== 'queued') {
+                    fallback('steer rejected — message queued for next turn');
+                }
+            })
+                .catch(() => fallback('steer failed — message queued for next turn'));
+            return;
+        }
+        // 'interrupt' (default): tear down the current turn, then send.
+        // `interruptTurn` fires `session.interrupt` without awaiting; if
+        // the gateway is still mid-response when `prompt.submit` lands,
+        // `send()`'s catch path re-queues with a "queued: ..." sys note
+        // (`isSessionBusyError`) — so a lost race degrades to queue
+        // semantics, not a dropped message.
+        if (live.sid) {
+            turnController.interruptTurn({ appendMessage, gw, sid: live.sid, sys });
+        }
+        if (hasInterpolation(full)) {
+            patchUiState({ busy: true });
+            return interpolate(full, send);
+        }
+        send(full);
+    }, [appendMessage, composerActions, composerRefs, gw, interpolate, send, sys]);
+    const dispatchSubmission = useCallback((full) => {
+        if (!full.trim()) {
+            return;
+        }
+        if (looksLikeSlashCommand(full)) {
+            appendMessage({ kind: 'slash', role: 'system', text: full });
+            composerActions.pushHistory(full);
+            slashRef.current(full);
+            composerActions.clearIn();
+            return;
+        }
+        if (full.startsWith('!')) {
+            composerActions.clearIn();
+            return shellExec(full.slice(1).trim());
+        }
+        const live = getUiState();
+        if (!live.sid) {
+            composerActions.pushHistory(full);
+            composerActions.enqueue(full);
+            composerActions.clearIn();
+            return;
+        }
+        const editIdx = composerRefs.queueEditRef.current;
+        composerActions.clearIn();
+        if (editIdx !== null) {
+            composerActions.replaceQueue(editIdx, full);
+            const picked = composerRefs.queueRef.current.splice(editIdx, 1)[0];
+            composerActions.syncQueue();
+            composerActions.setQueueEdit(null);
+            if (!picked || !live.sid) {
+                return;
+            }
+            if (getUiState().busy) {
+                // 'interrupt' / 'steer' should reach the live turn instead of
+                // silently going back to the queue.  handleBusyInput resolves
+                // mode-specific behavior (interrupt-and-send, steer, or queue).
+                if (getUiState().busyInputMode === 'queue') {
+                    composerRefs.queueRef.current.unshift(picked);
+                    return composerActions.syncQueue();
+                }
+                return handleBusyInput(picked, { fallbackToFront: true });
+            }
+            return sendQueued(picked);
+        }
+        composerActions.pushHistory(full);
+        if (getUiState().busy) {
+            return handleBusyInput(full);
+        }
+        if (hasInterpolation(full)) {
+            patchUiState({ busy: true });
+            return interpolate(full, send);
+        }
+        send(full);
+    }, [appendMessage, composerActions, composerRefs, handleBusyInput, interpolate, send, sendQueued, shellExec, slashRef]);
+    const submit = useCallback((value) => {
+        if (composerState.completions.length) {
+            const row = composerState.completions[composerState.compIdx];
+            if (row?.text) {
+                const text = value.startsWith('/') && row.text.startsWith('/') ? row.text.slice(1) : row.text;
+                const next = value.slice(0, composerState.compReplace) + text;
+                if (next !== value) {
+                    return composerActions.setInput(next);
+                }
+            }
+        }
+        if (!value.trim() && !composerState.inputBuf.length) {
+            const live = getUiState();
+            const now = Date.now();
+            const doubleTap = now - lastEmptyAt.current < DOUBLE_ENTER_MS;
+            lastEmptyAt.current = now;
+            if (doubleTap && live.busy && live.sid) {
+                return turnController.interruptTurn({ appendMessage, gw, sid: live.sid, sys });
+            }
+            if (doubleTap && live.sid && composerRefs.queueRef.current.length) {
+                const next = composerActions.dequeue();
+                composerActions.syncQueue();
+                if (next) {
+                    composerActions.setQueueEdit(null);
+                    dispatchSubmission(next);
+                }
+            }
+            return;
+        }
+        lastEmptyAt.current = 0;
+        if (value.endsWith('\\')) {
+            composerActions.setInputBuf(prev => [...prev, value.slice(0, -1)]);
+            return composerActions.setInput('');
+        }
+        dispatchSubmission([...composerState.inputBuf, value].join('\n'));
+    }, [appendMessage, composerActions, composerRefs, composerState, dispatchSubmission, gw, sys]);
+    submitRef.current = submit;
+    return { dispatchSubmission, send, sendQueued, submit };
+}

package/dist/app.js

@@ -0,0 +1,15 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+// @ts-nocheck
+// SPDX-License-Identifier: MIT
+// Ported from CVC Agent (https://github.com/NousResearch/cvc)
+// Original Copyright (c) 2025 Nous Research. CVC adaptations (c) 2026 Jai Kumar Meena.
+import { useStore } from '@nanostores/react';
+import { GatewayProvider } from './app/gatewayContext.js';
+import { $uiState } from './app/uiStore.js';
+import { useMainApp } from './app/useMainApp.js';
+import { AppLayout } from './components/appLayout.js';
+export function App({ gw }) {
+    const { appActions, appComposer, appProgress, appStatus, appTranscript, gateway } = useMainApp(gw);
+    const { mouseTracking } = useStore($uiState);
+    return (_jsx(GatewayProvider, { value: gateway, children: _jsx(AppLayout, { actions: appActions, composer: appComposer, mouseTracking: mouseTracking, progress: appProgress, status: appStatus, transcript: appTranscript }) }));
+}

package/dist/banner.js

@@ -0,0 +1,63 @@
+// SPDX-License-Identifier: MIT
+// Ported from CVC Agent (https://github.com/NousResearch/cvc)
+// Original Copyright (c) 2025 Nous Research. CVC adaptations (c) 2026 Jai Kumar Meena.
+//
+// CVC ASCII banner. Rendered once at startup by <Branding/>.
+// Colour applied at render-time via Ink <Text color="..."> wrappers.
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { dirname, resolve } from 'node:path';
+function readPkgVersion() {
+    try {
+        // src/banner.ts → ../package.json (src) or dist/banner.js → ../package.json (dist)
+        const here = dirname(fileURLToPath(import.meta.url));
+        const candidates = [resolve(here, '../package.json'), resolve(here, '../../package.json')];
+        for (const p of candidates) {
+            try {
+                const raw = readFileSync(p, 'utf8');
+                const parsed = JSON.parse(raw);
+                if (parsed.name === 'cvc-tui' && typeof parsed.version === 'string') {
+                    return parsed.version;
+                }
+            }
+            catch {
+                /* try next */
+            }
+        }
+    }
+    catch {
+        /* fall through */
+    }
+    return '0.0.0';
+}
+export const CVC_BANNER = String.raw `
+  ██████╗██╗   ██╗ ██████╗
+ ██╔════╝██║   ██║██╔════╝
+ ██║     ██║   ██║██║
+ ██║     ╚██╗ ██╔╝██║
+ ╚██████╗ ╚████╔╝ ╚██████╗
+  ╚═════╝  ╚═══╝   ╚═════╝
+`.trim();
+export const CVC_TAGLINE = 'Cognitive Version Control — git for your AI\u2019s mind';
+export const CVC_BOOT_TIP = 'Type /help for commands · Ctrl+C to exit';
+export const BANNER_COLOR = '#e63946';
+export const TAGLINE_COLOR = '#4a9eff';
+/**
+ * Version of cvc-tui as published in package.json.
+ * Wired here so the banner is never out-of-date with the package version
+ * (this fixes the v0.0.1 fallback bug).
+ */
+export const CVC_VERSION = readPkgVersion();
+/**
+ * Returns the banner as a plain (uncoloured) string suitable for tests
+ * and for non-TTY fallbacks. The TTY renderer colours it via Ink.
+ */
+export function renderBannerPlain({ version = CVC_VERSION, model = 'unknown' } = {}) {
+    return [CVC_BANNER, '', `${CVC_TAGLINE}  v${version}  ·  model: ${model}`, CVC_BOOT_TIP].join('\n');
+}
+export const LOGO_WIDTH = 28;
+export const CADUCEUS_WIDTH = 28;
+const _bannerLines = (color) => CVC_BANNER.split('\n').map(t => [color, t]);
+export const logo = (_c, _customLogo) => _bannerLines(BANNER_COLOR);
+export const caduceus = (_c, _customHero) => _bannerLines(BANNER_COLOR);
+export const artWidth = (lines) => lines.reduce((m, [, t]) => Math.max(m, t.length), 0);