cray-code 1.0.0

package/dist/screens/ReplScreen.js

@@ -0,0 +1,763 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * ReplScreen — React/Ink REPL for Cray Code.
+ *
+ * Features:
+ *   - Streaming thinking display (collapsible "Thought for Xs" block)
+ *   - Real-time tool call display with spinner
+ *   - Up/Down arrow key history navigation
+ *   - Clipboard paste support (text + image paths)
+ *   - Escape to cancel, Ctrl+C to cancel or exit
+ */
+import React, { useState, useEffect, useRef, useCallback } from 'react';
+import { render, Text, Box, useInput, useApp, Newline } from 'ink';
+import { existsSync, readFileSync, mkdirSync, writeFileSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+import { ThinkingBlock } from '../components/ThinkingBlock.js';
+import { PermissionPrompt } from '../components/PermissionPrompt.js';
+import { CRAY_LOGO, CRAY_TAGLINE } from '../branding/logo.js';
+import { getAllCommands } from '../commands/registry.js';
+import { nextPermissionMode } from '../types/permission.js';
+import { isBtwInput, extractBtwQuestion, runSideQuestion } from '../utils/sideQuestion.js';
+import { queryStream, setPermissionResolver } from '../queryStream.js';
+import { PluginManager } from '../components/PluginManager.js';
+import { TrustDialog, isDirectoryTrusted, trustDirectory } from '../components/TrustDialog.js';
+import { recordMessages, getCurrentSessionId } from '../services/sessionStorage.js';
+/** Seconds counter for thinking display */
+function useElapsedTimer(active) {
+    const [elapsed, setElapsed] = useState(0);
+    const ref = useRef(0);
+    useEffect(() => {
+        if (!active) {
+            setElapsed(0);
+            ref.current = 0;
+            return;
+        }
+        const iv = setInterval(() => { setElapsed(++ref.current); }, 1000);
+        return () => clearInterval(iv);
+    }, [active]);
+    return elapsed;
+}
+/** Persistent history across sessions — saved to ~/.cray/history.json */
+function useHistory() {
+    const historyPath = join(homedir(), '.cray', 'history.json');
+    // Load existing
+    let saved = [];
+    if (existsSync(historyPath)) {
+        try {
+            saved = JSON.parse(readFileSync(historyPath, 'utf-8'));
+        }
+        catch {
+            saved = [];
+        }
+    }
+    const [history, setHistory] = useState(saved);
+    const [histIdx, setHistIdx] = useState(-1); // -1 = at bottom, typing fresh
+    const [draftBeforeNav, setDraftBeforeNav] = useState('');
+    const push = useCallback((entry) => {
+        if (!entry.trim())
+            return;
+        setHistory((prev) => {
+            const next = [entry, ...prev.filter((h) => h !== entry)].slice(0, 200);
+            // Persist
+            try {
+                mkdirSync(join(homedir(), '.cray'), { recursive: true });
+                writeFileSync(historyPath, JSON.stringify(next, null, 2), 'utf-8');
+            }
+            catch { /* non-fatal */ }
+            return next;
+        });
+    }, []);
+    return { history, histIdx, draftBeforeNav, push, setHistIdx, setDraftBeforeNav };
+}
+const ReplScreen = ({ cray, initialPrompt }) => {
+    const [messages, setMessages] = useState([]);
+    const [loading, setLoading] = useState(false);
+    const [cancelling, setCancelling] = useState(false);
+    const [error, setError] = useState(null);
+    const [inputValue, setInputValue] = useState('');
+    const [turns, setTurns] = useState(0);
+    const [showWelcome, setShowWelcome] = useState(true);
+    // ─── History ──────────────────────────────────────────────────────
+    const { history, histIdx, draftBeforeNav, push, setHistIdx, setDraftBeforeNav } = useHistory();
+    // ─── Permission state ──────────────────────────────────────────────
+    const [permissionMode, setPermissionMode] = useState('default');
+    const [askState, setAskState] = useState(null);
+    // Ref to avoid stale-closure issues during heavy re-rendering (streaming)
+    const askStateRef = useRef(askState);
+    const loadingRef = useRef(false);
+    askStateRef.current = askState;
+    // Live streaming state
+    const [thinkingText, setThinkingText] = useState('');
+    const [thinkingFirstLine, setThinkingFirstLine] = useState('');
+    const [thinkingActive, setThinkingActive] = useState(false);
+    const [thinkingDone, setThinkingDone] = useState(false);
+    const [thinkingFinalElapsed, setThinkingFinalElapsed] = useState(0);
+    const [liveText, setLiveText] = useState('');
+    const [liveTools, setLiveTools] = useState([]);
+    // ─── Trust dialog at startup ────────────────────────────────────
+    const cwd = cray.toolContext?.cwd ?? process.cwd();
+    const [trustConfirmed, setTrustConfirmed] = useState(false);
+    const [trustChecking, setTrustChecking] = useState(true);
+    useEffect(() => {
+        // Check after mount so cwd is definitely available
+        if (isDirectoryTrusted(cwd)) {
+            setTrustConfirmed(true);
+        }
+        setTrustChecking(false);
+    }, [cwd]);
+    // ─── Plugin manager overlay ────────────────────────────────────
+    const [showPluginManager, setShowPluginManager] = useState(false);
+    // ─── Side question (/btw) state ──────────────────────────────────
+    const [sideQActive, setSideQActive] = useState(false);
+    const [sideQResponse, setSideQResponse] = useState(null);
+    const [sideQError, setSideQError] = useState(null);
+    const [sideQQuestion, setSideQQuestion] = useState('');
+    const sideQAbortRef = useRef(null);
+    const elapsed = useElapsedTimer(thinkingActive);
+    const abortRef = useRef(null);
+    const thinkingFirstRef = useRef('');
+    const messagesRef = useRef([]);
+    messagesRef.current = messages;
+    const { exit } = useApp();
+    const freezeThinking = useCallback(() => {
+        if (thinkingText) {
+            setThinkingDone(true);
+            setThinkingActive(false);
+            setThinkingFinalElapsed(elapsed);
+        }
+    }, [thinkingText, elapsed]);
+    const handleCancel = useCallback(() => {
+        if (!loadingRef.current || cancelling)
+            return;
+        setCancelling(true);
+        abortRef.current?.abort();
+    }, [cancelling]);
+    // ─── Side question (/btw) submission ─────────────────────────────
+    const submitSideQuestion = useCallback(async (question) => {
+        if (!question.trim() || sideQActive)
+            return;
+        setSideQActive(true);
+        setSideQResponse(null);
+        setSideQError(null);
+        setSideQQuestion(question);
+        const ctx = cray.toolContext;
+        if (!ctx) {
+            setSideQError('Context not initialized');
+            setSideQActive(false);
+            return;
+        }
+        // Build cache-safe params from current context
+        const systemPrompt = ctx.systemPromptParts?.join('\n') ?? '';
+        const userContext = `Working directory: ${ctx.cwd}\nDate: ${new Date().toISOString().split('T')[0]}`;
+        const systemContext = `Platform: ${process.platform}`;
+        const cacheSafeParams = {
+            systemPrompt,
+            userContext,
+            systemContext,
+            toolUseContext: ctx,
+            forkContextMessages: [...(ctx.messages ?? [])],
+        };
+        try {
+            const result = await runSideQuestion({
+                question,
+                cacheSafeParams,
+            });
+            setSideQResponse(result.response ?? '(No response received)');
+        }
+        catch (err) {
+            setSideQError(err.message || 'Side question failed');
+        }
+        finally {
+            setSideQActive(false);
+        }
+    }, [cray, sideQActive]);
+    // Dismiss side question result
+    const dismissSideQuestion = useCallback(() => {
+        setSideQResponse(null);
+        setSideQError(null);
+        setSideQQuestion('');
+    }, []);
+    const sendMessage = useCallback(async (userInput) => {
+        if (loadingRef.current || !userInput.trim())
+            return;
+        push(userInput);
+        setShowWelcome(false);
+        loadingRef.current = true;
+        thinkingFirstRef.current = '';
+        setLoading(true);
+        setCancelling(false);
+        setError(null);
+        setThinkingText('');
+        setThinkingFirstLine('');
+        setThinkingActive(false);
+        setThinkingDone(false);
+        setLiveText('');
+        setLiveTools([]);
+        const userMsg = { role: 'user', id: `u-${Date.now()}`, timestamp: Date.now(), content: userInput };
+        setMessages((prev) => [...prev, userMsg]);
+        // Persist user message immediately
+        const sId = getCurrentSessionId();
+        if (sId) {
+            recordMessages(cray.toolContext?.cwd ?? process.cwd(), sId, [userMsg]);
+        }
+        const ctx = cray.toolContext;
+        if (!ctx) {
+            setError('Context not initialized');
+            setLoading(false);
+            return;
+        }
+        // Set context.messages to ALL previous history (without the current userMsg,
+        // which historyToConversation will append as the prompt).
+        ctx.messages = [...messagesRef.current];
+        ctx.permissionContext.mode = permissionMode;
+        const ac = new AbortController();
+        abortRef.current = ac;
+        ctx.abortSignal = ac.signal;
+        // Wire up permission resolver (called from inside queryStream)
+        setPermissionResolver(async (toolName, message) => {
+            return new Promise((resolve) => {
+                setAskState({ toolName, message, resolve });
+            });
+        });
+        // Streaming callbacks (real-time text/thinking)
+        const cbs = {
+            onThinking(text, _turn) {
+                if (ac.signal.aborted)
+                    return;
+                setThinkingActive(true);
+                setThinkingDone(false);
+                setThinkingText((p) => {
+                    const next = p + text;
+                    if (!thinkingFirstRef.current) {
+                        const first = next.split('\n').find((l) => l.trim());
+                        if (first) {
+                            thinkingFirstRef.current = first.trim();
+                            setThinkingFirstLine(first.trim());
+                        }
+                    }
+                    return next;
+                });
+            },
+            onText(text, _turn) {
+                if (ac.signal.aborted)
+                    return;
+                freezeThinking();
+                setLiveText((p) => p + text);
+            },
+        };
+        try {
+            // ─── Async generator: for-await event loop (Claude Code pattern) ──
+            for await (const event of queryStream({ prompt: userInput, context: ctx, maxTurns: 25 }, cbs)) {
+                if (ac.signal.aborted)
+                    break;
+                onQueryEvent(event);
+            }
+        }
+        catch (err) {
+            if (err.name === 'AbortError') {
+                setLiveTools((prev) => prev.map((t) => t.status === 'running' ? { ...t, status: 'cancelled' } : t));
+                setError('Operation cancelled.');
+            }
+            else {
+                setError(err.message);
+            }
+        }
+        finally {
+            freezeThinking();
+            loadingRef.current = false;
+            setLoading(false);
+            setCancelling(false);
+            setThinkingText('');
+            setThinkingFirstLine('');
+            setThinkingActive(false);
+            setThinkingDone(false);
+            setLiveText('');
+            setLiveTools([]);
+            abortRef.current = null;
+            setPermissionResolver(null);
+        }
+    }, [cray, freezeThinking, push, permissionMode]);
+    // ─── onQueryEvent: dispatch typed events to React state (Claude Code pattern) ──
+    const onQueryEvent = useCallback((event) => {
+        switch (event.type) {
+            case 'thinking_done':
+                freezeThinking();
+                break;
+            case 'tool_start':
+                freezeThinking();
+                setLiveTools((prev) => [...prev, {
+                        id: event.toolId,
+                        name: event.toolName,
+                        input: event.input,
+                        status: 'running',
+                    }]);
+                break;
+            case 'tool_end':
+                setLiveTools((prev) => prev.map((t) => t.id === event.toolId && t.status === 'running'
+                    ? { ...t, status: event.isError ? 'error' : 'done', result: event.result }
+                    : t));
+                break;
+            case 'turn_end':
+                setTurns(event.turn);
+                break;
+            case 'request_start':
+                break;
+            case 'error':
+                setError(event.message);
+                break;
+            case 'cancelled':
+                setLiveTools((prev) => prev.map((t) => t.status === 'running' ? { ...t, status: 'cancelled' } : t));
+                break;
+            case 'done': {
+                const newMsgs = event.messages;
+                setMessages((prev) => {
+                    const ids = new Set(prev.map((m) => m.id));
+                    return [...prev, ...newMsgs.filter((m) => !ids.has(m.id))];
+                });
+                setTurns(event.totalTurns);
+                // ─── Update context.messages for next turn's context persistence ───
+                if (newMsgs.length > 0) {
+                    const ctx = cray.toolContext;
+                    if (ctx) {
+                        const existingIds = new Set(ctx.messages.map((m) => m.id));
+                        ctx.messages.push(...newMsgs.filter((m) => !existingIds.has(m.id)));
+                    }
+                }
+                // ─── Persist new messages to JSONL session file ───
+                const sessionId = getCurrentSessionId();
+                if (sessionId && newMsgs.length > 0) {
+                    const cwd = cray.toolContext?.cwd ?? process.cwd();
+                    recordMessages(cwd, sessionId, newMsgs);
+                }
+                break;
+            }
+            default:
+                break;
+        }
+    }, [freezeThinking, cray]);
+    // ─── Keyboard Input ──────────────────────────────────────────────
+    useInput((input, key) => {
+        // Don't process main-screen input while trust is pending
+        if (!trustConfirmed)
+            return;
+        // Plugin manager overlay takes all interaction
+        if (showPluginManager)
+            return;
+        const curAsk = askStateRef.current;
+        // ─── Permission prompt active — intercept Y/A/N/Esc ─────────────
+        if (curAsk) {
+            if (key.escape) {
+                const r = curAsk.resolve;
+                setAskState(null);
+                r('deny');
+                return;
+            }
+            const ch = input.toLowerCase();
+            if (ch === 'y') {
+                const r = curAsk.resolve;
+                setAskState(null);
+                r('allow');
+                return;
+            }
+            if (ch === 'a') {
+                const r = curAsk.resolve;
+                setAskState(null);
+                r('allowAll');
+                return;
+            }
+            if (ch === 'n') {
+                const r = curAsk.resolve;
+                setAskState(null);
+                r('deny');
+                return;
+            }
+            return; // swallow all other input while prompt is up
+        }
+        const loading = loadingRef.current;
+        // ─── Always-available keys ────────────────────────────────────
+        // Escape — cancel during loading, clear input otherwise
+        if (key.escape) {
+            if (loading) {
+                handleCancel();
+                return;
+            }
+            setInputValue('');
+            setHistIdx(-1);
+            return;
+        }
+        // Ctrl+C — cancel during loading, exit otherwise
+        if (input === '\x03') {
+            if (loading) {
+                handleCancel();
+                return;
+            }
+            cray.shutdown().then(() => exit());
+            return;
+        }
+        // Shift+Tab — cycle permission mode
+        if (key.shift && key.tab) {
+            const next = nextPermissionMode(permissionMode);
+            setPermissionMode(next);
+            const ctx = cray.toolContext;
+            if (ctx)
+                ctx.permissionContext.mode = next;
+            return;
+        }
+        // ─── Up/Down arrow — history navigation (works even during loading) ──
+        if (key.upArrow) {
+            if (history.length === 0)
+                return;
+            if (histIdx === -1)
+                setDraftBeforeNav(inputValue);
+            const nextIdx = Math.min(histIdx + 1, history.length - 1);
+            setHistIdx(nextIdx);
+            setInputValue(history[nextIdx] ?? '');
+            return;
+        }
+        if (key.downArrow) {
+            const nextIdx = histIdx - 1;
+            if (nextIdx < -1)
+                return;
+            setHistIdx(nextIdx);
+            setInputValue(nextIdx === -1 ? draftBeforeNav : (history[nextIdx] ?? ''));
+            return;
+        }
+        // ─── During loading, allow /btw input and Esc to dismiss side Q ──
+        if (loading) {
+            // Esc — during loading with side Q visible, dismiss it
+            if (key.escape) {
+                if (sideQResponse || sideQError) {
+                    dismissSideQuestion();
+                    return;
+                }
+                handleCancel();
+                return;
+            }
+            // Enter — during loading, only /btw is allowed
+            if (key.return) {
+                const val = inputValue.trim();
+                if (isBtwInput(val)) {
+                    const question = extractBtwQuestion(val);
+                    if (question) {
+                        push(val);
+                        setInputValue('');
+                        setHistIdx(-1);
+                        submitSideQuestion(question);
+                    }
+                }
+                return;
+            }
+            // Backspace / Delete during loading
+            if (key.backspace || key.delete) {
+                setInputValue((p) => p.slice(0, -1));
+                return;
+            }
+            // Normal text input during loading — only allow /-prefixed input
+            if (input && !key.ctrl && !key.meta) {
+                const candidate = inputValue + input;
+                // Only accept input that could be /btw or similar
+                if (candidate.startsWith('/')) {
+                    setInputValue(candidate);
+                }
+                return;
+            }
+            return;
+        }
+        // ─── Tab — autocomplete command names ───────────────────────────
+        if (key.tab) {
+            const val = inputValue;
+            if (val.startsWith('/')) {
+                const partial = val.replace(/^\//, '').split(/\s+/)[0];
+                const matches = getAllCommands().filter((c) => c.name.startsWith(partial) && c.userInvocable);
+                if (matches.length === 1) {
+                    setInputValue(`/${matches[0].name} `);
+                }
+                else if (matches.length > 1) {
+                    const common = matches.reduce((prefix, m) => {
+                        while (prefix && !m.name.startsWith(prefix))
+                            prefix = prefix.slice(0, -1);
+                        return prefix;
+                    }, partial);
+                    if (common && common !== partial)
+                        setInputValue(`/${common}`);
+                }
+            }
+            return;
+        }
+        // ─── Enter — submit ────────────────────────────────────────────
+        if (key.return) {
+            const val = inputValue.trim();
+            if (!val)
+                return;
+            // ─── /compact: run real compaction on the live message store ──
+            if (val === '/compact' || val.startsWith('/compact ')) {
+                const keepArg = val.split(/\s+/)[1];
+                const keepTurns = keepArg ? parseInt(keepArg, 10) || 3 : 3;
+                const result = cray.compact({ keepLastTurns: keepTurns });
+                setMessages(result.messages);
+                const msg = `Context compacted: ${result.removedCount} messages summarized → ${result.keptCount} kept (saved ~${result.estimatedTokensSaved} tokens). Keeping last ${keepTurns} turns intact.`;
+                setMessages((p) => [...p, { role: 'system', id: `sys-${Date.now()}`, timestamp: Date.now(), content: msg }]);
+                setInputValue('');
+                setHistIdx(-1);
+                return;
+            }
+            // ─── /btw — side question (agent is not running) ──
+            if (isBtwInput(val)) {
+                const question = extractBtwQuestion(val);
+                if (!question) {
+                    setMessages((p) => [...p, { role: 'system', id: `sys-${Date.now()}`, timestamp: Date.now(), content: 'Usage: /btw <question> — ask a side question without interrupting the conversation.' }]);
+                }
+                else {
+                    // When agent is idle, /btw runs immediately and shows answer inline
+                    push(val);
+                    submitSideQuestion(question);
+                }
+                setInputValue('');
+                setHistIdx(-1);
+                setShowWelcome(false);
+                return;
+            }
+            // ─── /plugin /plugins /marketplace — open interactive manager ──
+            if (val === '/plugin' || val === '/plugins' || val === '/marketplace') {
+                setInputValue('');
+                setShowWelcome(false);
+                setShowPluginManager(true);
+                return;
+            }
+            // Slash command
+            if (val.startsWith('/')) {
+                // /plugin subcommands — still go through command execution
+                if (val.startsWith('/plugin ')) {
+                    cray.executeCommand(val).then((r) => {
+                        setInputValue('');
+                        setShowWelcome(false);
+                        if (r.message) {
+                            setMessages((p) => [...p, { role: 'system', id: `sys-${Date.now()}`, timestamp: Date.now(), content: r.message }]);
+                        }
+                    });
+                    return;
+                }
+                cray.executeCommand(val).then((r) => {
+                    if (val === '/exit' || val === '/quit' || val === '/q')
+                        cray.shutdown().then(() => exit());
+                    setInputValue('');
+                    setShowWelcome(false);
+                    if (r.message) {
+                        setMessages((p) => [...p, { role: 'system', id: `sys-${Date.now()}`, timestamp: Date.now(), content: r.message }]);
+                    }
+                });
+                setInputValue('');
+                setHistIdx(-1);
+                return;
+            }
+            sendMessage(val);
+            setInputValue('');
+            setHistIdx(-1);
+            return;
+        }
+        // ─── Backspace / Delete ─────────────────────────────────────────
+        if (key.backspace || key.delete) {
+            setInputValue((p) => p.slice(0, -1));
+            return;
+        }
+        // ─── Normal text input (includes pasted text) ───────────────────
+        // Ink sends clipboard paste as a single `input` containing all chars.
+        // Multi-line pastes are flattened. Image pastes come as base64 strings
+        // with OSC sequences — we detect and handle those.
+        if (input && !key.ctrl && !key.meta) {
+            // Detect image paste (base64 data URI or OSC-52 clipboard)
+            if (input.startsWith('data:image/') || input.includes('\x1b]52;')) {
+                const imgPath = extractPastedImage(input);
+                if (imgPath) {
+                    setInputValue((p) => p + ` ${imgPath} `);
+                    return;
+                }
+            }
+            // Normal text paste: append all at once
+            setInputValue((p) => p + input);
+        }
+    });
+    // Auto-send initial prompt
+    useEffect(() => {
+        if (initialPrompt && !loading && messages.length === 0) {
+            const t = setTimeout(() => sendMessage(initialPrompt), 100);
+            return () => clearTimeout(t);
+        }
+    }, [initialPrompt]);
+    // ─── Render ──────────────────────────────────────────────────────
+    const thinkingBlock = (thinkingText || thinkingDone) ? (_jsx(ThinkingBlock, { lastLine: thinkingText, firstLine: thinkingFirstLine, elapsed: elapsed, started: thinkingActive || thinkingDone, finished: thinkingDone, completeElapsed: thinkingFinalElapsed })) : null;
+    // ─── Trust guard: render ONLY the dialog until confirmed ──────
+    if (!trustConfirmed) {
+        // Brief loading state while checking disk
+        if (trustChecking) {
+            return (_jsxs(Box, { flexDirection: "column", padding: 1, children: [_jsx(Text, { color: "#6C5CE7", children: CRAY_LOGO }), _jsxs(Text, { bold: true, color: "#A29BFE", children: ["  ", CRAY_TAGLINE] }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: "  Initializing..." }) })] }));
+        }
+        return (_jsx(TrustDialog, { cwd: cwd, onAccept: () => {
+                trustDirectory(cwd);
+                setTrustConfirmed(true);
+            }, onReject: () => {
+                cray.shutdown().then(() => exit());
+            } }));
+    }
+    return (_jsxs(Box, { flexDirection: "column", padding: 1, children: [showPluginManager && (_jsx(Box, { flexDirection: "column", children: _jsx(PluginManager, { onDone: () => setShowPluginManager(false) }) })), (sideQResponse || sideQError) && (_jsxs(Box, { flexDirection: "column", marginBottom: 1, borderStyle: "single", borderColor: "#FDCB6E", paddingLeft: 1, paddingRight: 1, children: [_jsxs(Box, { children: [_jsx(Text, { bold: true, color: "#FDCB6E", children: "/btw " }), _jsx(Text, { dimColor: true, children: sideQQuestion })] }), sideQError ? (_jsx(Box, { children: _jsxs(Text, { color: "#E17055", children: ["Error: ", sideQError] }) })) : (_jsx(Box, { children: _jsx(Text, { color: "#00B894", children: sideQResponse }) })), _jsx(Box, { children: _jsx(Text, { dimColor: true, children: "Esc to dismiss" }) })] })), sideQActive && (_jsx(Box, { marginBottom: 1, children: _jsxs(Text, { color: "#FDCB6E", children: ["  /btw", sideQQuestion ? ` ${sideQQuestion}` : '', " \u2014 answering..."] }) })), showWelcome && messages.length === 0 && !loading && (_jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [_jsx(Text, { color: "#6C5CE7", children: CRAY_LOGO }), _jsxs(Text, { bold: true, color: "#A29BFE", children: ["  ", CRAY_TAGLINE] }), _jsx(Newline, {}), _jsx(Text, { dimColor: true, children: "  \u2191\u2193 history  |  Tab complete  |  Ctrl+V paste  |  Esc cancel" }), _jsx(Newline, {})] })), messages.map((msg) => (_jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [msg.role === 'user' && (_jsx(Box, { children: _jsx(Text, { bold: true, color: "#A29BFE", children: typeof msg.content === 'string'
+                                ? msg.content
+                                : msg.content.filter((c) => c.type === 'text').map((c) => c.text).join('') }) })), msg.role === 'assistant' &&
+                        renderAssistantContent(msg.content), msg.role === 'system' && (_jsx(Box, { children: _jsx(Text, { dimColor: true, children: typeof msg.content === 'string' ? msg.content : '[system]' }) }))] }, msg.id))), thinkingBlock, liveText && _jsx(Box, { marginBottom: 1, children: _jsx(Text, { children: liveText }) }), loading && liveTools.length > 0 && !liveText && !thinkingActive && !thinkingDone && (_jsx(Box, { marginBottom: 1, children: _jsx(Text, { dimColor: true, children: "  ..." }) })), cancelling && _jsx(Box, { marginY: 1, children: _jsx(Text, { color: "#FDCB6E", children: "Cancelling..." }) }), askState && (_jsx(PermissionPrompt, { toolName: askState.toolName, message: askState.message })), error && _jsx(Box, { marginY: 1, children: _jsxs(Text, { color: "#E17055", bold: true, children: ["Error: ", error] }) }), _jsx(Newline, {}), loading && (_jsx(Box, { children: _jsx(Text, { dimColor: true, children: cancelling ? '  Cancelling...' : '  Processing... (Esc to cancel, /btw to ask side Q)' }) })), _jsx(Box, { children: _jsx(Text, { dimColor: true, children: '─'.repeat(80) }) }), _jsxs(Box, { children: [_jsx(Text, { color: "#6C5CE7", bold: true, children: "Cray> " }), _jsx(Text, { children: inputValue }), _jsx(Text, { children: '█' })] }), _jsx(Box, { children: _jsx(Text, { dimColor: true, children: '─'.repeat(80) }) })] }));
+};
+// ─── Assistant content renderer (Claude Code-style concise output) ─────
+/** Tools worth showing in output — the rest are internal housekeeping */
+const VISIBLE_TOOLS = new Set([
+    'read', 'view', 'cat',
+    'write', 'create',
+    'edit', 'modify', 'replace',
+    'bash', 'shell', 'exec',
+    'glob', 'ls', 'find',
+    'grep', 'search', 'rg',
+    'web_fetch', 'web_search',
+    'notebook_read', 'nb_read', 'read_notebook',
+    'notebook_edit', 'nb_edit', 'edit_notebook',
+]);
+function renderAssistantContent(content) {
+    const blocks = Array.isArray(content) ? content : [];
+    const nodes = [];
+    // Pair tool_use with following tool_result, collect standalone blocks
+    let i = 0;
+    while (i < blocks.length) {
+        const b = blocks[i];
+        if (b.type === 'thinking') {
+            nodes.push(_jsx(ThinkingBlock, { lastLine: b.thinking ?? '', firstLine: (b.thinking ?? '').split('\n').find((l) => l.trim())?.trim() ?? '', elapsed: 0, started: true, finished: true, completeElapsed: 0 }, `t-${i}`));
+            i++;
+            continue;
+        }
+        if (b.type === 'text') {
+            nodes.push(_jsx(Box, { marginTop: nodes.length === 0 ? 0 : 1, children: _jsx(Text, { children: b.text }) }, `x-${i}`));
+            i++;
+            continue;
+        }
+        if (b.type === 'tool_use') {
+            const next = blocks[i + 1];
+            const hasResult = next?.type === 'tool_result';
+            // Only show visible tools
+            if (VISIBLE_TOOLS.has(b.name)) {
+                const label = toolOneLiner(b.name, b.input, hasResult ? String(next.content ?? '') : undefined, next?.is_error);
+                const isFileOp = ['read', 'write', 'edit', 'view', 'cat', 'create', 'modify', 'replace'].includes(b.name);
+                nodes.push(isFileOp
+                    ? _jsx(Box, { borderStyle: "round", borderColor: "#636E72", paddingLeft: 1, paddingRight: 1, children: _jsx(Text, { color: "#00B894", children: label }) }, `tu-${i}`)
+                    : _jsx(Box, { children: _jsxs(Text, { color: "#00B894", children: ["  ", label] }) }, `tu-${i}`));
+            }
+            i += hasResult ? 2 : 1; // skip the tool_result we consumed
+            continue;
+        }
+        // Standalone tool_result (shouldn't normally happen)
+        if (b.type === 'tool_result') {
+            i++;
+            continue;
+        }
+        i++;
+    }
+    return nodes;
+}
+function toolOneLiner(name, input, result, isError) {
+    switch (name) {
+        case 'read':
+        case 'view':
+        case 'cat': {
+            const fp = String(input.file_path ?? '');
+            const fn = fp.split(/[/\\]/).pop() || fp;
+            const lines = result ? result.split('\n').length : 0;
+            return `Read ${fn}${lines ? ` (${lines} lines)` : ''}`;
+        }
+        case 'write':
+        case 'create': {
+            const fp = String(input.file_path ?? '');
+            const fn = fp.split(/[/\\]/).pop() || fp;
+            return `Write ${fn}`;
+        }
+        case 'edit':
+        case 'modify':
+        case 'replace': {
+            const fp = String(input.file_path ?? '');
+            const fn = fp.split(/[/\\]/).pop() || fp;
+            const old = String(input.old_string ?? '').replace(/\n/g, '↵').slice(0, 60);
+            return `Edit ${fn} — "${old}"`;
+        }
+        case 'bash':
+        case 'shell':
+        case 'exec': {
+            const cmd = String(input.command ?? '').replace(/\n/g, '; ').slice(0, 80);
+            const status = isError ? ' (failed)' : '';
+            return `$ ${cmd}${status}`;
+        }
+        case 'glob':
+        case 'ls':
+        case 'find': {
+            const p = String(input.pattern ?? '');
+            const count = result ? result.split('\n').filter(Boolean).length : 0;
+            return `Glob ${p}${count ? ` → ${count} files` : ''}`;
+        }
+        case 'grep':
+        case 'search':
+        case 'rg': {
+            const p = String(input.pattern ?? '');
+            const count = result ? result.split('\n').filter(Boolean).length : 0;
+            return `Grep "${p.slice(0, 60)}"${count ? ` → ${count} matches` : ''}`;
+        }
+        case 'web_fetch':
+        case 'fetch': {
+            const u = String(input.url ?? '');
+            return `Fetch ${u.slice(0, 60)}`;
+        }
+        case 'web_search':
+        case 'search_web': {
+            const q = String(input.query ?? '');
+            return `Search "${q.slice(0, 50)}"`;
+        }
+        case 'notebook_read':
+        case 'nb_read':
+        case 'read_notebook': {
+            const fp = String(input.file_path ?? '');
+            const fn = fp.split(/[/\\]/).pop() || fp;
+            const pages = input.pages ? ` cells ${input.pages}` : '';
+            return `Notebook ${fn}${pages}`;
+        }
+        case 'notebook_edit':
+        case 'nb_edit':
+        case 'edit_notebook': {
+            const fp = String(input.notebook_path ?? '');
+            const fn = fp.split(/[/\\]/).pop() || fp;
+            const mode = input.edit_mode === 'delete' ? 'Delete cell' : input.edit_mode === 'insert' ? 'Insert cell' : 'Edit cell';
+            return `${mode} in ${fn}`;
+        }
+        default:
+            return `${name}`;
+    }
+}
+// ─── Extract image path from clipboard paste data ────────────────────
+function extractPastedImage(input) {
+    // data:image/png;base64,... → save to temp dir, return path
+    const dataUriMatch = input.match(/^data:(image\/\w+);base64,(.+)$/);
+    if (dataUriMatch) {
+        try {
+            const ext = dataUriMatch[1].split('/')[1] || 'png';
+            const tmpDir = join(homedir(), '.cray', 'pasted');
+            mkdirSync(tmpDir, { recursive: true });
+            const filename = `paste-${Date.now()}.${ext}`;
+            const filepath = join(tmpDir, filename);
+            const buffer = Buffer.from(dataUriMatch[2], 'base64');
+            writeFileSync(filepath, buffer);
+            return filepath;
+        }
+        catch {
+            return null;
+        }
+    }
+    return null;
+}
+export default ReplScreen;
+export function mountReplScreen(cray, initialPrompt) {
+    const { unmount } = render(React.createElement(ReplScreen, { cray, initialPrompt }), { exitOnCtrlC: false });
+    return { unmount };
+}
+//# sourceMappingURL=ReplScreen.js.map