camo-cli 2.0.1

package/dist/art.js

@@ -0,0 +1,33 @@
+import chalk from 'chalk';
+export function getEliteHeaderArt() {
+    const c = {
+        g1: chalk.hex('#4ade80'), // Skin Light (Bright Green)
+        g2: chalk.hex('#22c55e'), // Skin Mid
+        g3: chalk.hex('#166534'), // Skin Dark (Shadows)
+        eye: chalk.hex('#fbbf24'), // Eye (Amber)
+        pupil: chalk.hex('#000000'), // Pupil
+        br1: chalk.hex('#a0522d'), // Branch Light
+        br2: chalk.hex('#8b4513'), // Branch Mid
+        leaf: chalk.hex('#86efac'), // Leaf
+        dim: chalk.dim,
+    };
+    const lines = [
+        ``,
+        `                                 ${c.g1('▄▄')}`,
+        `                               ${c.g1('████')}${c.g2('▄')}`,
+        `                           ${c.g2('▄')}${c.g1('██████')}${c.g2('▄')}`,
+        `                          ${c.g2('████████')}${c.g1('█')}${c.g2('▄')}           ${c.leaf('▄▄')}`,
+        `       ${c.g1('▄▄▄▄')}             ${c.g2('▐██')}${c.eye('███')}${c.pupil('█')}${c.eye('█')}${c.g2('██▌')}         ${c.leaf('████')}`,
+        `     ${c.g1('▄██████')}${c.g2('▄')}           ${c.g2('▀██████▀')}        ${c.leaf('▄██████')}`,
+        `    ${c.g1('▐██▀  ▀██▌')}                            ${c.leaf('▀▀')}${c.br1('__')}${c.leaf('▀▀')}`,
+        `    ${c.g2('██')}      ${c.g2('▀')}                           ${c.br1('.-´')}`,
+        `    ${c.g2('▐█▄')}        ${c.g3('▄▄▄')}${c.g2('██████▄')}${c.g3('▄')}       ${c.br1('.-´')}`,
+        `     ${c.g2('▀██▄▄▄▄██████████████')}${c.g3('██▄')}  ${c.br1('.-´')}`,
+        `       ${c.g3('▀▀▀▀▀▀')}    ${c.g3('▐████')}${c.g2('████')}${c.br2('██▄´')}`,
+        `  ${c.br1('================')}${c.g3('██')}${c.g2('██')}${c.g3('█')}${c.br1('====')}${c.br2('▀▀')}${c.br1('======')}`,
+        ``,
+        `   ${chalk.bold.hex('#4ade80')('🦎 CAMO CLI')} ${chalk.dim('v2.1')} ${chalk.dim('• Adaptive Terminal Intelligence')}`,
+        ``
+    ];
+    return lines.join('\n');
+}

package/dist/components/App.js

@@ -0,0 +1,71 @@
+import React, { useState, useEffect, useRef, useCallback } from 'react';
+import { Box, useApp } from 'ink';
+import { SetupScreen } from './SetupScreen.js';
+import { ChatInterface } from './Chat.js';
+import { config } from '../config/store.js';
+// View States
+var ViewState;
+(function (ViewState) {
+    ViewState["CHAT_VIEW"] = "CHAT_VIEW";
+    ViewState["SETUP_VIEW"] = "SETUP_VIEW";
+    ViewState["HITL_VIEW"] = "HITL_VIEW";
+})(ViewState || (ViewState = {}));
+export const App = ({ initialInput, verbose }) => {
+    const { exit } = useApp();
+    // Determine initial view based on API key presence
+    const hasApiKey = Boolean(config.get('googleApiKey'));
+    // State
+    const [view, setView] = useState(hasApiKey ? ViewState.CHAT_VIEW : ViewState.SETUP_VIEW);
+    const [apiKey, setApiKey] = useState(config.get('googleApiKey') || null);
+    const [hitlRequest, setHitlRequest] = useState(null);
+    // HITL Resolver logic
+    const hitlResolveRef = useRef(null);
+    const createHITLRequest = useCallback((request) => {
+        return new Promise((resolve) => {
+            hitlResolveRef.current = resolve;
+            setHitlRequest(request);
+            setView(ViewState.HITL_VIEW);
+        });
+    }, []);
+    const resolveHITL = useCallback((approved, scope) => {
+        if (hitlResolveRef.current) {
+            const resolver = hitlResolveRef.current;
+            hitlResolveRef.current = null;
+            setHitlRequest(null);
+            setView(ViewState.CHAT_VIEW);
+            resolver({ approved, scope });
+        }
+    }, []);
+    // Initialize Agent Context only once
+    useEffect(() => {
+        import('../agent.js').then(module => {
+            module.initializeAgentContext();
+        });
+        // Cleanup on unmount
+        return () => {
+            import('../agent.js').then(module => {
+                module.cleanupAgent();
+            });
+        };
+    }, []);
+    const handleCommand = useCallback((cmd) => {
+        // App-level interception removed for /model so Chat.tsx can handle it
+        if (cmd.trim() === '/exit') {
+            exit();
+            return true;
+        }
+        return false;
+    }, [exit]);
+    const handleSetupComplete = useCallback(() => {
+        const key = config.get('googleApiKey');
+        setApiKey(key);
+        if (key) {
+            setView(ViewState.CHAT_VIEW);
+        }
+    }, []);
+    return (React.createElement(Box, { flexDirection: "column", height: "100%" },
+        view === ViewState.SETUP_VIEW && (React.createElement(Box, { flexDirection: "column", justifyContent: "center", alignItems: "center", flexGrow: 1, marginBottom: 1 },
+            React.createElement(SetupScreen, { onComplete: handleSetupComplete }))),
+        React.createElement(Box, { flexGrow: 1, flexDirection: "column" },
+            React.createElement(ChatInterface, { active: view === ViewState.CHAT_VIEW, onCommand: handleCommand, apiKey: apiKey, verbose: verbose, onRequestHITL: createHITLRequest, hitlRequest: view === ViewState.HITL_VIEW ? hitlRequest : null, onResolveHITL: view === ViewState.HITL_VIEW ? resolveHITL : undefined }))));
+};

package/dist/components/Chat.js

@@ -0,0 +1,509 @@
+import React, { useState, useEffect, useRef, useCallback, useMemo } from 'react';
+import { Box, Text, useInput, useApp } from 'ink';
+import TextInput from 'ink-text-input';
+import { HITLConfirmation } from './HITLConfirmation.js';
+import { getContextStats, formatTokenUsage } from '../utils/tokenCounter.js';
+import fs from 'fs/promises';
+import { config } from '../config/store.js';
+export const ChatInterface = ({ active, onCommand, apiKey, verbose, onRequestHITL, hitlRequest, onResolveHITL }) => {
+    const [input, setInput] = useState('');
+    const [messages, setMessages] = useState([]);
+    const [isProcessing, setIsProcessing] = useState(false);
+    const [status, setStatus] = useState('');
+    const [mode, setMode] = useState('manual');
+    // Command history
+    const [commandHistory, setCommandHistory] = useState([]);
+    const [historyIndex, setHistoryIndex] = useState(-1);
+    // Ctrl+C tracking
+    const lastCtrlCRef = useRef(0);
+    const { exit } = useApp();
+    // Refs
+    const messagesRef = useRef([]);
+    const pendingChunksRef = useRef('');
+    const assistantIdRef = useRef(null);
+    const updateIntervalRef = useRef(null);
+    // Thinking animation
+    const [dots, setDots] = useState('');
+    useEffect(() => {
+        let interval;
+        if (isProcessing && status === 'thinking...') {
+            interval = setInterval(() => {
+                setDots(prev => prev.length >= 3 ? '' : prev + '.');
+            }, 500);
+        }
+        else {
+            setDots('');
+        }
+        return () => clearInterval(interval);
+    }, [isProcessing, status]);
+    const COMMANDS = useMemo(() => [
+        { name: '/context', description: 'Show token usage' },
+        { name: '/report', description: 'Show decision report' },
+        { name: '/model', description: 'Change AI model' },
+        { name: '/provider', description: 'Manage API provider and keys' },
+        { name: '/help', description: 'Show help' },
+        { name: '/exit', description: 'Exit CAMO' }
+    ], []);
+    // Suggestions state
+    const [suggestionIndex, setSuggestionIndex] = useState(0);
+    const [suggestionsDismissed, setSuggestionsDismissed] = useState(false);
+    const [suggestionScrollTop, setSuggestionScrollTop] = useState(0);
+    const suggestions = useMemo(() => {
+        // Special case for /model
+        if (input.startsWith('/model ')) {
+            const search = input.replace('/model ', '').toLowerCase();
+            const currentModel = config.get('selectedModel') || 'gemini-2-flash';
+            const models = [
+                { name: 'gemini-3-flash', description: 'Am schnellsten' },
+                { name: 'gemini-3-pro', description: 'Am besten' },
+                { name: 'gemini-2-flash', description: 'Schnell & stabil' },
+                { name: 'gemini-2-pro', description: 'Fortgeschritten & komplex' }
+            ];
+            return models
+                .filter(m => m.name.toLowerCase().includes(search))
+                .map(m => ({
+                name: m.name,
+                description: m.description
+            }));
+        }
+        return COMMANDS.filter(cmd => cmd.name.toLowerCase().startsWith(input.toLowerCase()));
+    }, [input, COMMANDS]);
+    const showSuggestions = input.startsWith('/') && suggestions.length > 0 && !suggestionsDismissed;
+    // Reset suggestions
+    useEffect(() => {
+        setSuggestionIndex(0);
+        setSuggestionScrollTop(0);
+        setSuggestionsDismissed(false);
+    }, [input]);
+    // Keyboard handling
+    useInput((inputChar, key) => {
+        if (!active)
+            return;
+        if (key.ctrl && inputChar === 'c') {
+            const now = Date.now();
+            if (now - lastCtrlCRef.current < 500) {
+                exit();
+            }
+            else {
+                setInput('');
+                setHistoryIndex(-1);
+                lastCtrlCRef.current = now;
+            }
+            return;
+        }
+        if (showSuggestions) {
+            if (key.escape) {
+                setSuggestionsDismissed(true);
+                return;
+            }
+            if (key.upArrow) {
+                const newIndex = suggestionIndex > 0 ? suggestionIndex - 1 : suggestions.length - 1;
+                setSuggestionIndex(newIndex);
+                if (newIndex < suggestionScrollTop) {
+                    setSuggestionScrollTop(newIndex);
+                }
+                else if (newIndex >= suggestionScrollTop + 4) {
+                    setSuggestionScrollTop(newIndex - 3);
+                }
+                return;
+            }
+            if (key.downArrow) {
+                const newIndex = suggestionIndex < suggestions.length - 1 ? suggestionIndex + 1 : 0;
+                setSuggestionIndex(newIndex);
+                if (newIndex >= suggestionScrollTop + 4) {
+                    setSuggestionScrollTop(newIndex - 3);
+                }
+                else if (newIndex < suggestionScrollTop) {
+                    setSuggestionScrollTop(newIndex);
+                }
+                return;
+            }
+            if (key.tab || key.return) {
+                if (suggestionIndex >= 0 && suggestionIndex < suggestions.length) {
+                    const selected = suggestions[suggestionIndex];
+                    if (input.startsWith('/model ')) {
+                        setInput(`/model ${selected.name}`);
+                    }
+                    else {
+                        // If completing a command, add space so arguments can be typed
+                        setInput(selected.name + ' ');
+                    }
+                    setSuggestionIndex(0);
+                    setSuggestionsDismissed(true);
+                }
+                else if (suggestions.length > 0) {
+                    const selected = suggestions[0];
+                    if (input.startsWith('/model ')) {
+                        setInput(`/model ${selected.name}`);
+                    }
+                    else {
+                        setInput(selected.name + ' ');
+                    }
+                    setSuggestionIndex(0);
+                    setSuggestionsDismissed(true);
+                }
+                return;
+            }
+        }
+        if (!showSuggestions) {
+            if (key.upArrow && commandHistory.length > 0 && !isProcessing) {
+                const newIndex = historyIndex < commandHistory.length - 1 ? historyIndex + 1 : historyIndex;
+                setHistoryIndex(newIndex);
+                setInput(commandHistory[commandHistory.length - 1 - newIndex] || '');
+                return;
+            }
+            if (key.downArrow && historyIndex > 0) {
+                const newIndex = historyIndex - 1;
+                setHistoryIndex(newIndex);
+                setInput(commandHistory[commandHistory.length - 1 - newIndex] || '');
+                return;
+            }
+        }
+    });
+    // Initialize mode
+    useEffect(() => {
+        import('../utils/PermissionManager.js').then(({ PermissionManager }) => {
+            setMode(PermissionManager.getInstance().getMode());
+        });
+    }, []);
+    const handleCommand = useCallback(async (value) => {
+        const [cmd, ...args] = value.slice(1).split(' ');
+        if (cmd === 'context') {
+            const stats = getContextStats(messages.map(m => ({ role: m.role, content: m.content })));
+            const systemMsg = {
+                id: Date.now().toString(),
+                role: 'system',
+                content: `⏺ Context: ${formatTokenUsage(stats)}`,
+                timestamp: Date.now()
+            };
+            setMessages(prev => [...prev, systemMsg]);
+            return true;
+        }
+        if (cmd === 'report') {
+            const { getSessionReport } = await import('../agent.js');
+            const report = await getSessionReport();
+            const systemMsg = {
+                id: Date.now().toString(),
+                role: 'system',
+                content: `⏺ ${report}`,
+                timestamp: Date.now()
+            };
+            setMessages(prev => [...prev, systemMsg]);
+            return true;
+        }
+        // Handle /model (show current)
+        if (cmd === 'model' && args.length === 0) {
+            const current = config.get('selectedModel') || 'gemini-2-flash';
+            const systemMsg = {
+                id: Date.now().toString(),
+                role: 'system',
+                content: `⏺ Current: **${current}**`,
+                timestamp: Date.now()
+            };
+            setMessages(prev => [...prev, systemMsg]);
+            return true;
+        }
+        // Handle /model [name]
+        if (cmd === 'model' && args.length > 0) {
+            const targetModel = args[0];
+            if (['gemini-3-flash', 'gemini-3-pro', 'gemini-2-flash', 'gemini-2-pro'].includes(targetModel)) {
+                config.set('selectedModel', targetModel);
+                const systemMsg = {
+                    id: Date.now().toString(),
+                    role: 'system',
+                    content: `⏺ Model set to **${targetModel}**`,
+                    timestamp: Date.now()
+                };
+                setMessages(prev => [...prev, systemMsg]);
+            }
+            else {
+                const systemMsg = {
+                    id: Date.now().toString(),
+                    role: 'system',
+                    content: `⏺ Invalid model. Available: gemini-3-flash, gemini-3-pro, gemini-2-flash, gemini-2-pro`,
+                    timestamp: Date.now()
+                };
+                setMessages(prev => [...prev, systemMsg]);
+            }
+            return true;
+        }
+        // Handle /provider (show info)
+        if (cmd === 'provider' && (args.length === 0 || args[0] !== 'key')) {
+            const googleKey = config.get('googleApiKey');
+            const maskedKey = googleKey ? `...${googleKey.slice(-4)}` : 'Not set';
+            const providerInfo = [
+                '⏺ **Provider Management**',
+                '',
+                '**Current Provider:** Google',
+                `**API Key:** ${maskedKey}`,
+                '',
+                '**Commands:**',
+                '• `/provider key [new-key]` - Update Google API key',
+                '• `/provider` - Show this info'
+            ].join('\n');
+            const systemMsg = {
+                id: Date.now().toString(),
+                role: 'system',
+                content: providerInfo,
+                timestamp: Date.now()
+            };
+            setMessages(prev => [...prev, systemMsg]);
+            return true;
+        }
+        // Handle /provider key [new-key]
+        if (cmd === 'provider' && args.length >= 2 && args[0] === 'key') {
+            const newKey = args.slice(1).join(' ');
+            config.set('googleApiKey', newKey);
+            const maskedNew = `...${newKey.slice(-4)}`;
+            const systemMsg = {
+                id: Date.now().toString(),
+                role: 'system',
+                content: `⏺ Google API key updated to ${maskedNew}`,
+                timestamp: Date.now()
+            };
+            setMessages(prev => [...prev, systemMsg]);
+            return true;
+        }
+        if (value.trim() === '/help' || value.trim() === '/') {
+            const helpText = `⏺ Commands:
+  /context  - Show token usage
+  /report   - Show decision report
+  /model    - Change Model (Gemini 3)
+  /exit     - Exit CAMO
+  /help     - Show this help`;
+            const systemMsg = {
+                id: Date.now().toString(),
+                role: 'system',
+                content: helpText,
+                timestamp: Date.now()
+            };
+            setMessages(prev => [...prev, systemMsg]);
+            return true;
+        }
+        if (onCommand(value)) {
+            return true;
+        }
+        return false;
+    }, [config, messages, onCommand]);
+    const handleSubmit = useCallback(async (value) => {
+        if (!value.trim())
+            return;
+        if (value.startsWith('/')) {
+            if (await handleCommand(value)) {
+                setInput('');
+                return;
+            }
+        }
+        setCommandHistory(prev => [...prev, value]);
+        setHistoryIndex(-1);
+        const lines = value.split('\n');
+        const isPaste = lines.length > 10;
+        const displayContent = isPaste ? `[Pasted Text: ${lines.length} lines]` : value;
+        const userMsg = {
+            id: Date.now().toString(),
+            role: 'user',
+            content: value,
+            displayContent: displayContent,
+            timestamp: Date.now(),
+        };
+        const currentMessages = [...messagesRef.current, userMsg];
+        setIsProcessing(true);
+        setInput('');
+        setMessages(prev => [...prev, userMsg]);
+        messagesRef.current = currentMessages;
+        try {
+            const { runEliteAgent } = await import('../agent.js');
+            await fs.appendFile('debug_chat.log', `[${new Date().toISOString()}] Starting agent for: ${value}\n`);
+            setStatus('thinking...');
+            const assistantId = (Date.now() + 1).toString();
+            assistantIdRef.current = assistantId;
+            pendingChunksRef.current = '';
+            const assistantPlaceholder = {
+                id: assistantId,
+                role: 'assistant',
+                content: '',
+                timestamp: Date.now()
+            };
+            setMessages(prev => [...prev, assistantPlaceholder]);
+            messagesRef.current = [...messagesRef.current, assistantPlaceholder];
+            updateIntervalRef.current = setInterval(() => {
+                if (pendingChunksRef.current && assistantIdRef.current) {
+                    const id = assistantIdRef.current;
+                    const chunks = pendingChunksRef.current;
+                    pendingChunksRef.current = '';
+                    setMessages(prev => prev.map(m => m.id === id ? { ...m, content: m.content + chunks } : m));
+                    messagesRef.current = messagesRef.current.map(m => m.id === id ? { ...m, content: m.content + chunks } : m);
+                }
+            }, 100);
+            await runEliteAgent(value, currentMessages, {
+                onChunk: (chunk) => {
+                    if (status === 'thinking...')
+                        setStatus('');
+                    fs.appendFile('debug_chat.log', `[CHUNK] ${chunk}\n`).catch(() => { });
+                    pendingChunksRef.current += chunk;
+                },
+                onHITL: onRequestHITL
+            });
+            // Clear interval before final flush
+            if (updateIntervalRef.current) {
+                clearInterval(updateIntervalRef.current);
+                updateIntervalRef.current = null;
+            }
+            // Final flush of any remaining chunks
+            if (pendingChunksRef.current && assistantIdRef.current) {
+                const id = assistantIdRef.current;
+                const pendingContent = pendingChunksRef.current;
+                await fs.appendFile('debug_chat.log', `[FINAL FLUSH] Content length: ${pendingContent.length}\n`).catch(() => { });
+                setMessages(prev => {
+                    const updated = prev.map(m => m.id === id ? { ...m, content: m.content + pendingContent } : m);
+                    fs.appendFile('debug_chat.log', `[FINAL FLUSH] Updated message count: ${updated.length}\n`).catch(() => { });
+                    return updated;
+                });
+                messagesRef.current = messagesRef.current.map(m => m.id === id ? { ...m, content: m.content + pendingContent } : m);
+                pendingChunksRef.current = '';
+            }
+            await fs.appendFile('debug_chat.log', `[FLUSH] ${messagesRef.current[messagesRef.current.length - 1]?.content || 'NO CONTENT'}\n`).catch(() => { });
+        }
+        catch (e) {
+            await fs.appendFile('debug_chat.log', `[ERROR] ${e.message}\n`);
+            setStatus(`Error: ${e.message}`);
+        }
+        finally {
+            if (updateIntervalRef.current) {
+                clearInterval(updateIntervalRef.current);
+                updateIntervalRef.current = null;
+            }
+            assistantIdRef.current = null;
+            setIsProcessing(false);
+            setStatus(prev => prev.startsWith('Error') ? prev : '');
+        }
+    }, [handleCommand, onRequestHITL]);
+    const handleInputChange = useCallback((value) => {
+        setInput(value);
+    }, []);
+    const renderMessageContent = useCallback((content) => {
+        const lines = content.trim().split('\n');
+        let bufferLineCount = 0;
+        let isTextBlock = false;
+        return lines.map((line, i) => {
+            if (line.includes('[LOOP_STATUS]'))
+                return null;
+            if (line.includes('[done]'))
+                return null;
+            if (line.includes('[TOOL_STATUS]')) {
+                const text = line.replace(/\[TOOL_STATUS\]|\[\/TOOL_STATUS\]/g, '');
+                isTextBlock = false;
+                return React.createElement(Text, { key: i, color: "gray", dimColor: true },
+                    "    \u21B3 ",
+                    text);
+            }
+            if (line.includes('[BUFFER_LINE]')) {
+                const text = line.replace(/\[BUFFER_LINE\]|\[\/BUFFER_LINE\]/g, '');
+                bufferLineCount++;
+                isTextBlock = false;
+                if (bufferLineCount <= 3) {
+                    return React.createElement(Text, { key: i, color: "gray", dimColor: true },
+                        "    \u21B3 ",
+                        text.slice(0, 70));
+                }
+                return null;
+            }
+            if (line.includes('[PLAN_DELTA]')) {
+                const delta = line.replace(/\[PLAN_DELTA\]|\[\/PLAN_DELTA\]/g, '');
+                isTextBlock = false;
+                return React.createElement(Text, { key: i, color: "cyan" },
+                    "\u23FA ",
+                    delta);
+            }
+            if (line.includes('[INTERNAL_THOUGHT]')) {
+                const thought = line.replace(/\[INTERNAL_THOUGHT\]|\[\/INTERNAL_THOUGHT\]/g, '');
+                isTextBlock = false;
+                return React.createElement(Text, { key: i, color: "gray", dimColor: true, italic: true },
+                    "  \uD83D\uDCAD ",
+                    thought.slice(0, 60),
+                    "...");
+            }
+            if (line.startsWith('⏺')) {
+                const textWithoutBullet = line.slice(1).trim();
+                isTextBlock = false;
+                return (React.createElement(Box, { key: i },
+                    React.createElement(Text, { color: "green" }, "\u23FA "),
+                    React.createElement(Text, { color: "white" }, textWithoutBullet)));
+            }
+            // Regular text
+            if (line.trim() && !line.includes('↳')) {
+                // Filter only specific internal tags
+                const hiddenTags = [
+                    '[LOOP_STATUS]',
+                    '[TOOL_STATUS]',
+                    '[BUFFER_LINE]',
+                    '[PLAN_DELTA]',
+                    '[INTERNAL_THOUGHT]',
+                    '[done]',
+                    '[TASK_COMPLETE]',
+                    '[ASK_USER]',
+                    '[PLAN_READY]'
+                ];
+                // If line starts with a known hidden tag, skip it
+                if (hiddenTags.some(tag => line.startsWith(tag)))
+                    return null;
+                if (!isTextBlock) {
+                    // Start of new text block - Always use large bullet
+                    isTextBlock = true;
+                    return (React.createElement(Box, { key: i },
+                        React.createElement(Text, { color: "white" }, "\u2022 "),
+                        React.createElement(Text, { color: "white" }, line)));
+                }
+                else {
+                    // Continuation line - no bullet, just indent
+                    return (React.createElement(Box, { key: i, paddingLeft: 2 },
+                        React.createElement(Text, { color: "white" }, line)));
+                }
+            }
+            return null;
+        }).filter(Boolean);
+    }, []);
+    return (React.createElement(Box, { flexDirection: "column" },
+        React.createElement(Box, { flexDirection: "column" }, messages.map((msg, i) => (React.createElement(Box, { key: msg.id, paddingBottom: msg.role === 'assistant' ? 1 : 0, flexDirection: "column" }, msg.role === 'user' ? (React.createElement(Text, { color: "gray" },
+            "> ",
+            msg.displayContent || msg.content)) : (React.createElement(Box, { flexDirection: "column" }, renderMessageContent(msg.content))))))),
+        React.createElement(Box, { flexDirection: "column" },
+            hitlRequest && onResolveHITL ? (React.createElement(HITLConfirmation, { request: hitlRequest, onResolve: onResolveHITL })) : (React.createElement(Box, { borderStyle: "single", borderColor: active ? "white" : "gray", flexDirection: "column", paddingX: 1 },
+                (showSuggestions || input.trim() === '?') && (React.createElement(Box, { flexDirection: "column", borderStyle: "single", borderColor: "gray", paddingX: 1, marginBottom: 0 }, input.trim() === '?' ? (React.createElement(React.Fragment, null,
+                    React.createElement(Text, { color: "white", bold: true }, "Shortcuts"),
+                    React.createElement(Box, { flexDirection: "column", marginLeft: 1 },
+                        React.createElement(Box, { flexDirection: "row", justifyContent: "space-between", width: "100%" },
+                            React.createElement(Text, { color: "gray" }, "Double Ctrl+C"),
+                            React.createElement(Text, { color: "white" }, "Exit session")),
+                        React.createElement(Box, { flexDirection: "row", justifyContent: "space-between", width: "100%" },
+                            React.createElement(Text, { color: "gray" }, "Shift+Enter"),
+                            React.createElement(Text, { color: "white" }, "New line")),
+                        React.createElement(Box, { flexDirection: "row", justifyContent: "space-between", width: "100%" },
+                            React.createElement(Text, { color: "gray" }, "Tab"),
+                            React.createElement(Text, { color: "white" }, "Autocomplete")),
+                        React.createElement(Box, { flexDirection: "row", justifyContent: "space-between", width: "100%" },
+                            React.createElement(Text, { color: "gray" }, "Ctrl+C"),
+                            React.createElement(Text, { color: "white" }, "Clear input")),
+                        React.createElement(Box, { flexDirection: "row", justifyContent: "space-between", width: "100%" },
+                            React.createElement(Text, { color: "gray" }, "\u2191/\u2193"),
+                            React.createElement(Text, { color: "white" }, "History")),
+                        React.createElement(Box, { flexDirection: "row", justifyContent: "space-between", width: "100%" },
+                            React.createElement(Text, { color: "gray" }, "/"),
+                            React.createElement(Text, { color: "white" }, "Commands"))))) : (suggestions.slice(suggestionScrollTop, suggestionScrollTop + 4).map((cmd, i) => {
+                    const realIndex = suggestionScrollTop + i;
+                    const isSelected = realIndex === suggestionIndex;
+                    return (React.createElement(Box, { key: cmd.name, flexDirection: "row", justifyContent: "space-between" },
+                        React.createElement(Box, null,
+                            React.createElement(Text, { color: isSelected ? 'white' : 'gray' },
+                                isSelected ? '> ' : '  ',
+                                cmd.name)),
+                        React.createElement(Box, { marginLeft: 2 },
+                            React.createElement(Text, { color: "gray", dimColor: true }, cmd.description))));
+                })))),
+                (isProcessing || status.startsWith('Error')) && status && (React.createElement(Text, { color: status.startsWith('Error') ? 'red' : 'gray', dimColor: true }, status === 'thinking...' ? `Thinking ${dots}` : status)),
+                React.createElement(Box, null,
+                    React.createElement(Text, { color: active ? "white" : "gray" }, "> "),
+                    active ? (React.createElement(TextInput, { value: input, onChange: handleInputChange, onSubmit: handleSubmit, placeholder: "Type a message..." })) : (React.createElement(Text, { color: "gray" }, input))))),
+            !hitlRequest && active && (React.createElement(Box, { marginTop: 0, paddingLeft: 1 },
+                React.createElement(Text, { color: "gray", dimColor: true }, "? for shortcuts"))))));
+};