@compass-ai/nova 1.0.73 → 1.0.74

package/dist/ui/components/Prompt.js

@@ -0,0 +1,632 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+/**
+ * React/ink component for interactive command prompt
+ * Displays approval mode indicator, token usage, and model information
+ * Handles user input with support for history navigation, auto-completion, and multiline input
+ */
+import React, { useState, useCallback, useEffect, useRef } from 'react';
+import { Box, Text, useInput, useStdin } from 'ink';
+import { ApprovalMode } from '../../types/approval.js';
+import { formatTokenCount } from '../../utils/format.js';
+import { getHistoryManager } from '../../core/history-manager.js';
+import { getCompletions, applyCompletion, shouldShowCompletions, } from '../../core/autocomplete.js';
+import { logger } from '../../utils/logger.js';
+/**
+ * Finds the next enabled (non-disabled) completion index in the given direction.
+ * Wraps around the list. Returns -1 if all items are disabled.
+ */
+function findNextEnabledIndex(items, currentIndex, direction) {
+    if (items.length === 0)
+        return -1;
+    const step = direction === 'down' ? 1 : -1;
+    let idx = (currentIndex + step + items.length) % items.length;
+    for (let i = 0; i < items.length; i++) {
+        if (!items[idx]?.disabled)
+            return idx;
+        idx = (idx + step + items.length) % items.length;
+    }
+    return -1; // all disabled
+}
+/**
+ * Finds the first enabled (non-disabled) index in the list.
+ * Returns -1 if all items are disabled.
+ */
+function findFirstEnabledIndex(items) {
+    return items.findIndex(item => !item.disabled);
+}
+/**
+ * Gets the mode indicator emoji based on approval mode
+ */
+function getModeIndicator(mode) {
+    switch (mode) {
+        case ApprovalMode.AUTO:
+            return '⚡';
+        case ApprovalMode.STRICT:
+            return '🔒';
+        case ApprovalMode.SMART:
+            return '🧠';
+        case ApprovalMode.MANUAL:
+        default:
+            return '✋';
+    }
+}
+/**
+ * Gets the color for the mode indicator based on approval mode
+ */
+function getModeColor(mode) {
+    switch (mode) {
+        case ApprovalMode.AUTO:
+            return 'yellow';
+        case ApprovalMode.STRICT:
+            return 'red';
+        case ApprovalMode.SMART:
+            return 'cyan';
+        case ApprovalMode.MANUAL:
+        default:
+            return 'green';
+    }
+}
+/**
+ * Memoized completion list component to prevent re-computation during typing
+ */
+const CompletionList = React.memo(({ completions, selectedCompletion, currentModel }) => {
+    // Detect if we're showing model completions
+    const isModelList = completions.length > 0 && completions[0].type === 'model';
+    // Dynamic sizing: use 40% of terminal height, min 8, max 20
+    const terminalRows = process.stdout.rows || 24;
+    const maxVisible = Math.max(8, Math.min(20, Math.floor(terminalRows * 0.4)));
+    // Calculate visible window around selected item
+    let startIndex = 0;
+    if (completions.length > maxVisible) {
+        const halfWindow = Math.floor(maxVisible / 2);
+        startIndex = Math.max(0, Math.min(selectedCompletion - halfWindow, completions.length - maxVisible));
+    }
+    const endIndex = Math.min(startIndex + maxVisible, completions.length);
+    const visibleCompletions = completions.slice(startIndex, endIndex);
+    return (_jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [isModelList && currentModel && (_jsxs(Box, { marginBottom: 0, paddingX: 1, children: [_jsx(Text, { dimColor: true, children: "Current model: " }), _jsx(Text, { bold: true, color: "cyan", children: currentModel })] })), _jsxs(Box, { borderStyle: "round", borderColor: "gray", flexDirection: "column", paddingX: 1, children: [startIndex > 0 && (_jsxs(Text, { dimColor: true, children: ["  \u2191 ", startIndex, " more above"] })), visibleCompletions.map((completion, idx) => {
+                        const actualIndex = startIndex + idx;
+                        const isDisabled = completion.disabled === true;
+                        const isSelected = actualIndex === selectedCompletion;
+                        return (_jsxs(Box, { children: [_jsxs(Text, { color: isDisabled ? 'gray' : isSelected ? 'cyan' : undefined, bold: isSelected && !isDisabled, dimColor: isDisabled, children: [isSelected && !isDisabled ? '❯ ' : '  ', completion.display] }), isDisabled && (_jsx(Text, { color: "gray", children: " \uD83D\uDD12" })), completion.description && (_jsxs(Text, { dimColor: true, children: [" - ", completion.description] })), isDisabled && completion.disabledReason && (_jsxs(Text, { color: "gray", italic: true, children: [" (", completion.disabledReason, ")"] }))] }, completion.value));
+                    }), endIndex < completions.length && (_jsxs(Text, { dimColor: true, children: ["  \u2193 ", completions.length - endIndex, " more below"] }))] }), _jsxs(Text, { dimColor: true, children: ["Tab to complete \u2022 \u2191\u2193 to navigate \u2022 Esc to close ", completions.length > maxVisible && `(${selectedCompletion + 1}/${completions.length})`] })] }));
+});
+/**
+ * Interactive command prompt component for the Compass CLI.
+ * Provides a rich input experience with:
+ * - Multiline input (Shift+Enter for new line, Enter to submit)
+ * - Approval mode indicator showing current safety level
+ * - Token usage display for cost awareness
+ * - Model name display
+ * - Command history navigation (up/down arrows when on single line)
+ * - Tab completion for slash commands and file paths
+ * - Paste handling with truncated display
+ */
+const PromptComponent = ({ approvalMode, tokenCount, model, activeAgentName, onSubmit, onPaste, disabled = false, isProcessing = false, placeholder = 'Type or paste your message...', projectRoot = process.cwd(), showStatusBar = true, promptSymbol = '❯', maxLength = 100000, maxDisplayLines = 50, suggestionOffer, onInputChange, }) => {
+    const [value, setValue] = useState('');
+    const [cursorPosition, setCursorPosition] = useState(0);
+    const [historyManager, setHistoryManager] = useState(null);
+    const [completions, setCompletions] = useState([]);
+    const [selectedCompletion, setSelectedCompletion] = useState(0);
+    const [showCompletions, setShowCompletions] = useState(false);
+    const [pasteInfo, setPasteInfo] = useState(null);
+    const [showFullInput, setShowFullInput] = useState(false);
+    const [terminalWidth, setTerminalWidth] = useState(process.stdout.columns || 80);
+    const isNavigatingRef = useRef(false);
+    const lastEscTimeRef = useRef(0);
+    const originalInputRef = useRef('');
+    const previousValueRef = useRef(null);
+    // Refs to track current values for use in callbacks (avoids stale closure issues)
+    const valueRef = useRef(value);
+    const cursorRef = useRef(cursorPosition);
+    // Wrapper functions that update both state and refs synchronously
+    const setValueAndRef = useCallback((newValue) => {
+        valueRef.current = newValue;
+        setValue(newValue);
+        onInputChange?.(newValue);
+    }, [onInputChange]);
+    const setCursorAndRef = useCallback((newCursor) => {
+        cursorRef.current = newCursor;
+        setCursorPosition(newCursor);
+    }, []);
+    const { isRawModeSupported } = useStdin();
+    // Initialize history manager
+    useEffect(() => {
+        let mounted = true;
+        async function initHistory() {
+            const manager = await getHistoryManager();
+            if (mounted) {
+                setHistoryManager(manager);
+            }
+        }
+        initHistory();
+        return () => {
+            mounted = false;
+        };
+    }, []);
+    // Listen for terminal resize events
+    useEffect(() => {
+        const handleResize = () => {
+            setTerminalWidth(process.stdout.columns || 80);
+        };
+        process.stdout.on('resize', handleResize);
+        return () => {
+            process.stdout.off('resize', handleResize);
+        };
+    }, []);
+    // Detect paste operations (large changes) - optimized to avoid unnecessary updates
+    // Paste info persists until submit so user knows content is collapsed
+    useEffect(() => {
+        const prevValue = previousValueRef.current;
+        previousValueRef.current = value;
+        // Skip if no previous value or values are the same
+        if (prevValue == null || prevValue === value)
+            return;
+        const addedLines = value.split('\n').length - prevValue.split('\n').length;
+        if (addedLines > 5) {
+            setPasteInfo({ count: addedLines });
+            setShowFullInput(false); // Collapse by default when pasting
+        }
+    }, [value]);
+    // Debounce timer ref for completion updates
+    const completionDebounceRef = useRef(null);
+    // Update completions when value changes (debounced to reduce flickering)
+    useEffect(() => {
+        let mounted = true;
+        // Clear any pending debounce
+        if (completionDebounceRef.current) {
+            clearTimeout(completionDebounceRef.current);
+            completionDebounceRef.current = null;
+        }
+        // Skip if navigating through completions
+        if (isNavigatingRef.current) {
+            return;
+        }
+        // Only show completions for single-line input starting with /
+        const isMultiline = value.includes('\n');
+        if (!value || disabled || isMultiline) {
+            setCompletions([]);
+            setShowCompletions(false);
+            originalInputRef.current = '';
+            return;
+        }
+        // Debounce completion fetching to reduce flickering during rapid typing
+        completionDebounceRef.current = setTimeout(async () => {
+            if (!mounted || isNavigatingRef.current)
+                return;
+            if (shouldShowCompletions(value, value.length)) {
+                const results = await getCompletions(value, value.length, projectRoot);
+                if (mounted && !isNavigatingRef.current) {
+                    // Batch these updates together
+                    setCompletions(results);
+                    setShowCompletions(results.length > 0);
+                    setSelectedCompletion(findFirstEnabledIndex(results));
+                    originalInputRef.current = value;
+                }
+            }
+            else {
+                if (mounted) {
+                    setCompletions([]);
+                    setShowCompletions(false);
+                    originalInputRef.current = '';
+                }
+            }
+        }, 100); // 100ms debounce for completions
+        return () => {
+            mounted = false;
+            if (completionDebounceRef.current) {
+                clearTimeout(completionDebounceRef.current);
+            }
+        };
+    }, [value, disabled, projectRoot]);
+    /**
+     * Handles input submission
+     */
+    const handleSubmit = useCallback((input) => {
+        const trimmed = input.trim();
+        if (trimmed) {
+            if (historyManager) {
+                historyManager.add(trimmed);
+                historyManager.save();
+            }
+            onSubmit(trimmed);
+            setValueAndRef('');
+            setCursorAndRef(0);
+            setShowCompletions(false);
+            setCompletions([]);
+            // Clear paste info on submit
+            setPasteInfo(null);
+            setShowFullInput(false);
+        }
+    }, [onSubmit, historyManager, setValueAndRef, setCursorAndRef]);
+    /**
+     * Insert text at cursor position
+     * Uses refs to get current values to avoid stale closure issues
+     */
+    const insertAtCursor = useCallback((text) => {
+        const currentValue = valueRef.current;
+        const currentCursor = cursorRef.current;
+        const newValue = currentValue.slice(0, currentCursor) + text + currentValue.slice(currentCursor);
+        if (newValue.length > maxLength) {
+            const truncated = newValue.slice(0, maxLength);
+            setValueAndRef(truncated);
+            setCursorAndRef(Math.min(currentCursor + text.length, maxLength));
+            return;
+        }
+        setValueAndRef(newValue);
+        setCursorAndRef(currentCursor + text.length);
+    }, [maxLength, setValueAndRef, setCursorAndRef]);
+    /**
+     * Get cursor line and column position
+     * Computed directly from current state values
+     */
+    const getCursorLineCol = () => {
+        const lines = value.split('\n');
+        let charCount = 0;
+        for (let i = 0; i < lines.length; i++) {
+            const lineEndPos = charCount + lines[i].length;
+            // Cursor is on this line if position is within the line
+            // OR if we're at the end of the last line
+            if (cursorPosition <= lineEndPos) {
+                return { line: i, col: cursorPosition - charCount, totalLines: lines.length };
+            }
+            charCount = lineEndPos + 1; // +1 for the newline character
+        }
+        // Fallback: cursor at end of last line
+        return { line: lines.length - 1, col: lines[lines.length - 1].length, totalLines: lines.length };
+    };
+    /**
+     * Handles special key inputs
+     * Uses refs to access current values to avoid stale closure issues
+     */
+    useInput((input, key) => {
+        if (disabled) {
+            return;
+        }
+        // Get current values from refs to avoid stale closures
+        const currentValue = valueRef.current;
+        const currentCursor = cursorRef.current;
+        const isMultiline = currentValue.includes('\n');
+        // Calculate cursor line/col for current values
+        const getCursorInfo = () => {
+            const lines = currentValue.split('\n');
+            let charCount = 0;
+            for (let i = 0; i < lines.length; i++) {
+                const lineEndPos = charCount + lines[i].length;
+                if (currentCursor <= lineEndPos) {
+                    return { line: i, col: currentCursor - charCount, totalLines: lines.length };
+                }
+                charCount = lineEndPos + 1;
+            }
+            return { line: lines.length - 1, col: lines[lines.length - 1].length, totalLines: lines.length };
+        };
+        const { line: cursorLine, col: cursorCol, totalLines } = getCursorInfo();
+        // When completions are shown, handle them first
+        if (showCompletions && completions.length > 0) {
+            if (key.return) {
+                const completion = completions[selectedCompletion];
+                // Block selection of disabled or undefined items
+                if (!completion || completion.disabled)
+                    return;
+                const { newInput } = applyCompletion(currentValue, currentValue.length, completion);
+                // If executeOnComplete is true, submit immediately
+                if (completion.executeOnComplete) {
+                    setShowCompletions(false);
+                    setCompletions([]);
+                    handleSubmit(newInput);
+                }
+                else {
+                    setValueAndRef(newInput);
+                    setCursorAndRef(newInput.length);
+                    setShowCompletions(false);
+                    setCompletions([]);
+                }
+                return;
+            }
+            if (key.tab) {
+                const completion = completions[selectedCompletion];
+                // Block selection of disabled or undefined items
+                if (!completion || completion.disabled)
+                    return;
+                const { newInput } = applyCompletion(currentValue, currentValue.length, completion);
+                // If executeOnComplete is true, submit immediately
+                if (completion.executeOnComplete) {
+                    setShowCompletions(false);
+                    setCompletions([]);
+                    handleSubmit(newInput);
+                }
+                else {
+                    setValueAndRef(newInput);
+                    setCursorAndRef(newInput.length);
+                    setShowCompletions(false);
+                }
+                return;
+            }
+            if (key.downArrow || (key.ctrl && input === 'n')) {
+                const newIndex = findNextEnabledIndex(completions, selectedCompletion, 'down');
+                if (newIndex === -1)
+                    return; // all disabled
+                setSelectedCompletion(newIndex);
+                isNavigatingRef.current = true;
+                const completion = completions[newIndex];
+                const { newInput } = applyCompletion(originalInputRef.current, originalInputRef.current.length, completion);
+                setValueAndRef(newInput);
+                setCursorAndRef(newInput.length);
+                setTimeout(() => { isNavigatingRef.current = false; }, 0);
+                return;
+            }
+            if (key.upArrow || (key.ctrl && input === 'p')) {
+                const newIndex = findNextEnabledIndex(completions, selectedCompletion, 'up');
+                if (newIndex === -1)
+                    return; // all disabled
+                setSelectedCompletion(newIndex);
+                isNavigatingRef.current = true;
+                const completion = completions[newIndex];
+                const { newInput } = applyCompletion(originalInputRef.current, originalInputRef.current.length, completion);
+                setValueAndRef(newInput);
+                setCursorAndRef(newInput.length);
+                setTimeout(() => { isNavigatingRef.current = false; }, 0);
+                return;
+            }
+            if (key.escape) {
+                setShowCompletions(false);
+                if (originalInputRef.current) {
+                    setValueAndRef(originalInputRef.current);
+                    setCursorAndRef(originalInputRef.current.length);
+                }
+                return;
+            }
+        }
+        // Tab to accept suggestionOffer when input is empty
+        if (key.tab && !currentValue && suggestionOffer) {
+            setValueAndRef(suggestionOffer);
+            setCursorAndRef(suggestionOffer.length);
+            return;
+        }
+        // Ctrl+V: Paste clipboard content (images or files)
+        if (key.ctrl && input === 'v') {
+            if (onPaste) {
+                // Call the parent's onPaste handler to process clipboard content
+                onPaste().catch(err => {
+                    logger.debug('Failed to paste from clipboard', { error: err });
+                });
+            }
+            return;
+        }
+        // Double Escape: clear input completely (only if no other input)
+        if (key.escape && !input) {
+            const now = Date.now();
+            if (now - lastEscTimeRef.current < 500) {
+                // Double Esc within 500ms - clear input
+                setValueAndRef('');
+                setCursorAndRef(0);
+                lastEscTimeRef.current = 0;
+                return;
+            }
+            lastEscTimeRef.current = now;
+            return;
+        }
+        // Shit+Enter or Ctrl+Enter: insert newline
+        if ((key.meta && key.return) || (key.ctrl && key.return)) {
+            insertAtCursor('\n');
+            return;
+        }
+        // Check if input itself is a newline (some terminals send this for Shit+Enter)
+        if (input === '\n' && !key.return) {
+            insertAtCursor('\n');
+            return;
+        }
+        // Enter: submit
+        if (key.return) {
+            handleSubmit(currentValue);
+            return;
+        }
+        // Backspace
+        if (key.backspace || key.delete) {
+            if (currentCursor > 0) {
+                const newValue = currentValue.slice(0, currentCursor - 1) + currentValue.slice(currentCursor);
+                setValueAndRef(newValue);
+                setCursorAndRef(currentCursor - 1);
+            }
+            return;
+        }
+        // Arrow navigation
+        if (key.leftArrow) {
+            setCursorAndRef(Math.max(0, currentCursor - 1));
+            return;
+        }
+        if (key.rightArrow) {
+            setCursorAndRef(Math.min(currentValue.length, currentCursor + 1));
+            return;
+        }
+        // Up arrow: history navigation (empty input) or cursor movement (multiline with content)
+        if (key.upArrow) {
+            if (isMultiline && cursorLine > 0) {
+                // Move up in multiline
+                const lines = currentValue.split('\n');
+                let newPos = 0;
+                for (let i = 0; i < cursorLine - 1; i++) {
+                    newPos += lines[i].length + 1;
+                }
+                newPos += Math.min(cursorCol, lines[cursorLine - 1].length);
+                setCursorAndRef(newPos);
+            }
+            else if (!currentValue && historyManager) {
+                // History navigation only when input is empty
+                const previous = historyManager.previous(currentValue);
+                if (previous !== null) {
+                    setValueAndRef(previous);
+                    setCursorAndRef(previous.length);
+                }
+            }
+            return;
+        }
+        // Down arrow: history navigation (empty input) or cursor movement (multiline with content)
+        if (key.downArrow) {
+            if (isMultiline && cursorLine < totalLines - 1) {
+                // Move down in multiline
+                const lines = currentValue.split('\n');
+                let newPos = 0;
+                for (let i = 0; i <= cursorLine; i++) {
+                    newPos += lines[i].length + 1;
+                }
+                newPos += Math.min(cursorCol, lines[cursorLine + 1].length);
+                setCursorAndRef(newPos);
+            }
+            else if (!currentValue && historyManager) {
+                // History navigation only when input is empty
+                const next = historyManager.next();
+                if (next !== null) {
+                    setValueAndRef(next);
+                    setCursorAndRef(next.length);
+                }
+            }
+            return;
+        }
+        // Ctrl+A: start of line/input
+        if (key.ctrl && input === 'a') {
+            if (isMultiline) {
+                const lines = currentValue.split('\n');
+                let lineStart = 0;
+                for (let i = 0; i < cursorLine; i++) {
+                    lineStart += lines[i].length + 1;
+                }
+                setCursorAndRef(lineStart);
+            }
+            else {
+                setCursorAndRef(0);
+            }
+            return;
+        }
+        // Ctrl+E: end of line/input
+        if (key.ctrl && input === 'e') {
+            if (isMultiline) {
+                const lines = currentValue.split('\n');
+                let lineEnd = 0;
+                for (let i = 0; i <= cursorLine; i++) {
+                    lineEnd += lines[i].length + (i < cursorLine ? 1 : 0);
+                }
+                setCursorAndRef(lineEnd);
+            }
+            else {
+                setCursorAndRef(currentValue.length);
+            }
+            return;
+        }
+        // Ctrl+C to clear input
+        if (key.ctrl && input === 'c') {
+            setValueAndRef('');
+            setCursorAndRef(0);
+            setShowCompletions(false);
+            if (historyManager) {
+                historyManager.resetPosition();
+            }
+            return;
+        }
+        // Ctrl+U to clear line before cursor
+        if (key.ctrl && input === 'u') {
+            if (isMultiline) {
+                const lines = currentValue.split('\n');
+                let lineStart = 0;
+                for (let i = 0; i < cursorLine; i++) {
+                    lineStart += lines[i].length + 1;
+                }
+                const newValue = currentValue.slice(0, lineStart) + currentValue.slice(currentCursor);
+                setValueAndRef(newValue);
+                setCursorAndRef(lineStart);
+            }
+            else {
+                setValueAndRef(currentValue.slice(currentCursor));
+                setCursorAndRef(0);
+            }
+            return;
+        }
+        // Ctrl+K to clear line after cursor
+        if (key.ctrl && input === 'k') {
+            if (isMultiline) {
+                const lines = currentValue.split('\n');
+                let lineEnd = 0;
+                for (let i = 0; i <= cursorLine; i++) {
+                    lineEnd += lines[i].length + (i < cursorLine ? 1 : 0);
+                }
+                const newValue = currentValue.slice(0, currentCursor) + currentValue.slice(lineEnd);
+                setValueAndRef(newValue);
+            }
+            else {
+                setValueAndRef(currentValue.slice(0, currentCursor));
+            }
+            return;
+        }
+        // Ctrl+W to delete word
+        if (key.ctrl && input === 'w') {
+            const beforeCursor = currentValue.slice(0, currentCursor);
+            const match = beforeCursor.match(/(?:^|\s)(\S+)$/);
+            if (match) {
+                const deleteLength = match[1].length;
+                const newValue = currentValue.slice(0, currentCursor - deleteLength) + currentValue.slice(currentCursor);
+                setValueAndRef(newValue);
+                setCursorAndRef(currentCursor - deleteLength);
+            }
+            return;
+        }
+        // Ctrl+O to toggle full input display (for pasted content)
+        if (key.ctrl && input === 'o') {
+            setShowFullInput(prev => !prev);
+            return;
+        }
+        // Regular character input (including paste)
+        if (input) {
+            // Skip if it's a control key combination (but allow the input itself)
+            if (key.ctrl || key.meta) {
+                return;
+            }
+            // Convert carriage returns to newlines and handle paste
+            // Replace \r\n and \r with \n for cross-platform compatibility
+            const sanitizedInput = input.replace(/\r\n/g, '\n').replace(/\r/g, '\n');
+            insertAtCursor(sanitizedInput);
+        }
+    }, { isActive: isRawModeSupported });
+    const modeIndicator = getModeIndicator(approvalMode);
+    const modeColor = getModeColor(approvalMode);
+    // Get terminal width for horizontal lines (recalculates on resize)
+    // Using soft dividers with faded edges for a more polished look
+    const horizontalLine = React.useMemo(() => {
+        const lineWidth = terminalWidth - 2;
+        if (lineWidth < 5)
+            return '─'.repeat(lineWidth);
+        return '╶' + '─'.repeat(Math.max(1, lineWidth - 2)) + '╴';
+    }, [terminalWidth]);
+    // Calculate display lines with truncation
+    const allLines = value.split('\n');
+    const totalLines = allLines.length;
+    const isMultiline = totalLines > 1;
+    const { line: cursorLine, col: cursorCol } = getCursorLineCol();
+    let displayLines = allLines;
+    let truncatedCount = 0;
+    let displayStartLine = 0;
+    // Use a very small display limit when pasted content is collapsed
+    const effectiveMaxLines = (pasteInfo && !showFullInput) ? 3 : maxDisplayLines;
+    if (totalLines > effectiveMaxLines) {
+        const halfDisplay = Math.floor(effectiveMaxLines / 2);
+        displayStartLine = Math.max(0, cursorLine - halfDisplay);
+        const endLine = Math.min(totalLines, displayStartLine + effectiveMaxLines);
+        displayStartLine = Math.max(0, endLine - effectiveMaxLines);
+        displayLines = allLines.slice(displayStartLine, endLine);
+        truncatedCount = totalLines - effectiveMaxLines;
+    }
+    const charCount = value.length;
+    const adjustedCursorLine = cursorLine - displayStartLine;
+    const symbolColor = isProcessing ? 'yellow' : 'cyan';
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { children: _jsx(Text, { dimColor: true, children: horizontalLine }) }), showStatusBar && (_jsxs(Box, { marginBottom: 1, children: [_jsxs(Text, { color: modeColor, children: [modeIndicator, " "] }), _jsx(Text, { dimColor: true, children: approvalMode.toUpperCase() }), activeAgentName && (_jsxs(_Fragment, { children: [_jsx(Text, { dimColor: true, children: " \u2502 " }), _jsxs(Text, { color: "magenta", bold: true, children: ["\uD83E\uDD16 ", activeAgentName] })] })), model && (_jsxs(_Fragment, { children: [_jsx(Text, { dimColor: true, children: " \u2502 " }), _jsx(Text, { color: "cyan", children: model })] })), tokenCount !== undefined && tokenCount > 0 && (_jsxs(_Fragment, { children: [_jsx(Text, { dimColor: true, children: " \u2502 " }), _jsx(Text, { dimColor: true, children: "Tokens: " }), _jsx(Text, { children: formatTokenCount(tokenCount) })] }))] })), pasteInfo && (_jsxs(Box, { marginBottom: 1, children: [_jsxs(Text, { color: "green", children: ["Pasted +", pasteInfo.count, " lines"] }), _jsxs(Text, { dimColor: true, children: [" \u2022 Ctrl+O to ", showFullInput ? 'collapse' : 'expand'] })] })), showCompletions && completions.length > 0 && (_jsx(CompletionList, { completions: completions, selectedCompletion: selectedCompletion, currentModel: model })), _jsx(Box, { flexDirection: "column", children: disabled ? (_jsxs(Box, { children: [_jsxs(Text, { color: symbolColor, bold: true, children: [promptSymbol, " "] }), _jsx(Text, { dimColor: true, children: "Processing..." })] })) : !value && suggestionOffer ? (_jsxs(Box, { children: [_jsxs(Text, { color: symbolColor, bold: true, children: [promptSymbol, " "] }), _jsx(Text, { dimColor: true, italic: true, children: suggestionOffer }), _jsx(Text, { inverse: true, children: " " }), _jsx(Text, { dimColor: true, children: " (Tab to accept)" })] })) : !value ? (_jsxs(Box, { children: [_jsxs(Text, { color: symbolColor, bold: true, children: [promptSymbol, " "] }), _jsx(Text, { dimColor: true, children: placeholder }), _jsx(Text, { inverse: true, children: " " }), _jsx(Text, { color: "blue", children: " (/ for commands)" })] })) : !isMultiline ? (
+                /* Single-line input - simple Box structure matching empty state */
+                _jsxs(Box, { children: [_jsxs(Text, { color: symbolColor, bold: true, children: [promptSymbol, " "] }), _jsxs(Text, { children: [value.slice(0, cursorPosition), _jsx(Text, { inverse: true, children: value[cursorPosition] || ' ' }), value.slice(cursorPosition + 1)] })] })) : (
+                /* Multi-line input */
+                _jsxs(_Fragment, { children: [displayStartLine > 0 && (_jsxs(Text, { dimColor: true, italic: true, children: ["... ", displayStartLine, " lines above"] })), displayLines.map((line, idx) => {
+                            const isCursorLine = idx === adjustedCursorLine;
+                            return (_jsxs(Box, { children: [idx === 0 && _jsxs(Text, { color: symbolColor, bold: true, children: [promptSymbol, " "] }), idx > 0 && _jsx(Text, { children: "  " }), _jsx(Text, { children: isCursorLine ? (_jsxs(_Fragment, { children: [line.slice(0, cursorCol), _jsx(Text, { inverse: true, children: line[cursorCol] || ' ' }), line.slice(cursorCol + 1)] })) : (line || ' ') })] }, idx));
+                        }), truncatedCount > 0 && displayStartLine + displayLines.length < totalLines && (_jsxs(Text, { dimColor: true, italic: true, children: ["... +", totalLines - displayStartLine - displayLines.length, " more lines"] }))] })) }), isMultiline && (_jsx(Box, { marginTop: 1, children: _jsxs(Text, { dimColor: true, children: [totalLines, " lines | ", charCount.toLocaleString(), " chars | Shit+Enter: new line | Enter: submit | Esc: clear"] }) })), _jsx(Box, { children: _jsx(Text, { dimColor: true, children: horizontalLine }) })] }));
+};
+// Memoize to prevent re-renders when parent re-renders but props haven't changed
+// This is critical for preventing flicker during typing
+export const Prompt = React.memo(PromptComponent);
+export default Prompt;
+//# sourceMappingURL=Prompt.js.map