byterover-cli 1.6.0 → 1.7.0

package/dist/tui/components/command-input.js

@@ -0,0 +1,282 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * CommandInput Component
+ *
+ * Handles command input with suggestions and executes slash commands.
+ */
+import { Box, Text, useInput } from 'ink';
+import TextInput from 'ink-text-input';
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
+import { useCommands } from '../contexts/commands-context.js';
+import { useAuth, useTasks, useTransport } from '../contexts/index.js';
+import { useMode, useOnboarding, useTheme } from '../hooks/index.js';
+import { Suggestions } from './suggestions.js';
+/**
+ * Get onboarding instruction based on current step
+ */
+function getInstructionText(currentStep, highlightColor) {
+    switch (currentStep) {
+        case 'curate': {
+            return (_jsxs(Text, { children: ["Create your first memory with ", _jsx(Text, { color: highlightColor, children: "/curate" })] }));
+        }
+        case 'explore': {
+            return (_jsxs(Text, { children: ["Next, type ", _jsx(Text, { color: highlightColor, children: "/" }), " to explore more commands"] }));
+        }
+        case 'query': {
+            return (_jsxs(Text, { children: ["Now retrieve your memory by using ", _jsx(Text, { color: highlightColor, children: "/query" })] }));
+        }
+        default: {
+            return null;
+        }
+    }
+}
+/**
+ * Get instruction for pressing Enter to run
+ */
+function getInstruction({ currentStep, highlightBgColor, highlightTextColor, textColor, }) {
+    if (currentStep === 'explore' || currentStep === 'curating' || currentStep === 'querying')
+        return null;
+    return (_jsxs(Text, { color: textColor, children: [" ", "\u00B7 Press ", _jsx(Text, { backgroundColor: highlightBgColor, color: highlightTextColor, children: " Enter " }), " to run (Esc to skip the instruction)"] }));
+}
+export const CommandInput = () => {
+    const { reloadAuth, reloadBrvConfig } = useAuth();
+    const { client } = useTransport();
+    const { clearTasks } = useTasks();
+    const { theme: { colors } } = useTheme();
+    const { mode } = useMode();
+    const { activePrompt, handleSlashCommand, isStreaming, setActivePrompt, setIsStreaming, setMessages, setStreamingMessages, } = useCommands();
+    const [inputValue, setInputValue] = useState('');
+    const [inputKey, setInputKey] = useState(0);
+    const ctrlOPressedRef = useRef(false);
+    const previousInputRef = useRef('');
+    const { completeOnboarding, currentStep, removeHighlightedCommand, shouldShowOnboarding } = useOnboarding();
+    // Check if in prefilled onboarding steps (curate or query)
+    const isInCurate = shouldShowOnboarding && currentStep === 'curate';
+    const isInQuery = shouldShowOnboarding && currentStep === 'query';
+    const isInCurating = shouldShowOnboarding && currentStep === 'curating';
+    const isInQuerying = shouldShowOnboarding && currentStep === 'querying';
+    const isInExplore = shouldShowOnboarding && currentStep === 'explore';
+    // Fixed input value for curate/query onboarding steps
+    const displayInputValue = useMemo(() => {
+        if (isInCurate)
+            return '/curate Curate the folder structure of this repository.';
+        if (isInCurating)
+            return '';
+        if (isInQuery)
+            return '/query Tell me what you know about the folder structure of this repository?';
+        if (isInQuerying)
+            return '';
+        return inputValue;
+    }, [shouldShowOnboarding, currentStep, inputValue]);
+    // Placeholder based on onboarding step
+    const placeholder = useMemo(() => {
+        if (isStreaming || isInCurating || isInQuerying)
+            return 'Processing...';
+        if (isInExplore)
+            return 'Type /';
+        return 'Type a command...';
+    }, [isStreaming, shouldShowOnboarding, currentStep]);
+    // Filter out "o" character when Ctrl+O is pressed
+    useEffect(() => {
+        if (ctrlOPressedRef.current) {
+            // Check if "o" was just added to the end
+            if (inputValue === previousInputRef.current + 'o') {
+                setInputValue(previousInputRef.current);
+            }
+            ctrlOPressedRef.current = false;
+        }
+    }, [inputValue]);
+    // Detect Ctrl+O to prevent "o" from being inserted
+    useInput((input, key) => {
+        if (key.ctrl && input === 'o') {
+            previousInputRef.current = inputValue;
+            ctrlOPressedRef.current = true;
+        }
+    });
+    // Skip onboarding with Esc
+    useInput((_input, key) => {
+        if (key.escape) {
+            completeOnboarding(true);
+        }
+    }, { isActive: shouldShowOnboarding && (currentStep === 'curate' || currentStep === 'query') });
+    // Cancel streaming command with Esc (only for commands that add to messages, not /curate or /query)
+    useInput((_input, key) => {
+        if (key.escape) {
+            // Add cancellation message to the latest command's output
+            setMessages((prev) => {
+                const updated = [...prev];
+                const lastIndex = updated.length - 1;
+                // Only cancel if there's a command message
+                if (lastIndex >= 0 && updated[lastIndex].type === 'command') {
+                    const cancelMsg = {
+                        content: 'Command cancelled.',
+                        id: `cancel-${Date.now()}`,
+                        type: 'output',
+                    };
+                    const existingOutput = updated[lastIndex].output ?? [];
+                    updated[lastIndex] = { ...updated[lastIndex], output: [...existingOutput, cancelMsg], timestamp: new Date() };
+                }
+                return updated;
+            });
+            // Reset streaming state
+            setStreamingMessages([]);
+            setIsStreaming(false);
+            setActivePrompt(null);
+        }
+    }, { isActive: isStreaming && !shouldShowOnboarding });
+    /* eslint-disable complexity -- Command execution requires handling multiple command types and states */
+    const executeCommand = useCallback(async (value) => {
+        const trimmed = value.trim();
+        if (!trimmed)
+            return;
+        // During query onboarding step, only allow /query commands
+        if (shouldShowOnboarding && currentStep === 'query' && !trimmed.startsWith('/query '))
+            return;
+        // Clear command input immediately
+        setInputValue('');
+        // Remove from highlighted commands if it's a slash command
+        if (trimmed.startsWith('/')) {
+            const commandName = trimmed.slice(1).split(' ')[0];
+            removeHighlightedCommand(commandName);
+        }
+        // Skip adding to messages for commands that are rendered via useActivityLogs
+        const isRenderedByActivityLogs = trimmed.startsWith('/curate') || trimmed.startsWith('/query') || trimmed.startsWith('/q ');
+        if (!isRenderedByActivityLogs) {
+            setMessages((prev) => [
+                ...prev,
+                {
+                    content: '',
+                    fromCommand: trimmed.startsWith('/') ? trimmed.slice(1) : trimmed,
+                    type: 'command',
+                },
+            ]);
+        }
+        const result = await handleSlashCommand(trimmed);
+        if (result && result.type === 'message') {
+            setMessages((prev) => {
+                const last = prev.at(-1);
+                return [
+                    ...(last?.type === 'command' ? prev.slice(0, -1) : [...prev]),
+                    {
+                        content: result.content,
+                        fromCommand: trimmed.startsWith('/') ? trimmed.slice(1) : trimmed,
+                        timestamp: new Date(),
+                        type: result.messageType === 'error' ? 'error' : 'info',
+                    },
+                ];
+            });
+        }
+        if (result && result.type === 'streaming') {
+            setIsStreaming(true);
+            setStreamingMessages([]);
+            const collectedMessages = [];
+            const onMessage = (msg) => {
+                collectedMessages.push(msg);
+                if (!isRenderedByActivityLogs) {
+                    setStreamingMessages((prev) => [...prev, msg]);
+                }
+            };
+            const onPrompt = (prompt) => {
+                if (!isRenderedByActivityLogs) {
+                    setActivePrompt(prompt);
+                }
+            };
+            try {
+                await result.execute(onMessage, onPrompt);
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                const errorMsg = {
+                    content: `Error: ${errorMessage}`,
+                    id: `error-${Date.now()}`,
+                    type: 'error',
+                };
+                collectedMessages.push(errorMsg);
+                setStreamingMessages((prev) => [...prev, errorMsg]);
+            }
+            finally {
+                // Store output with the command message
+                if (!isRenderedByActivityLogs) {
+                    setMessages((prev) => {
+                        const updated = [...prev];
+                        const lastIndex = updated.length - 1;
+                        if (lastIndex >= 0 && updated[lastIndex].type === 'command') {
+                            updated[lastIndex] = { ...updated[lastIndex], output: collectedMessages, timestamp: new Date() };
+                        }
+                        return updated;
+                    });
+                }
+                setStreamingMessages([]);
+                setIsStreaming(false);
+                setActivePrompt(null);
+                const needReloadAuth = trimmed.startsWith('/login') || trimmed.startsWith('/logout');
+                const needReloadBrvConfig = trimmed.startsWith('/space switch') || trimmed.startsWith('/init');
+                const needNewSession = trimmed.startsWith('/new');
+                // Handle /new command - create new session and clear messages
+                if (needNewSession && client) {
+                    try {
+                        const response = await client.requestWithAck('agent:newSession', { reason: 'User requested new session' });
+                        /* eslint-disable max-depth -- UI state handling requires this nesting level */
+                        if (response.success) {
+                            // Clear the messages to start fresh
+                            setMessages([]);
+                            clearTasks();
+                        }
+                    }
+                    catch {
+                        // Error handling - the command already showed feedback
+                    }
+                    /* eslint-enable max-depth */
+                }
+                // Refresh state after commands that change auth or project state
+                if (needReloadAuth || needReloadBrvConfig) {
+                    clearTasks();
+                    if (needReloadAuth)
+                        await reloadAuth();
+                    if (needReloadBrvConfig)
+                        await reloadBrvConfig();
+                    // Restart agent with appropriate reason
+                    if (client) {
+                        const reasonMap = {
+                            '/init': 'Project initialized',
+                            '/login': 'User logged in',
+                            '/logout': 'User logged out',
+                            '/space switch': 'Space switched',
+                        };
+                        const reason = Object.entries(reasonMap).find(([cmd]) => trimmed.startsWith(cmd))?.[1] ?? 'Command executed';
+                        await client.requestWithAck('agent:restart', { reason });
+                    }
+                }
+            }
+        }
+    }, [clearTasks, client, currentStep, handleSlashCommand, reloadAuth, reloadBrvConfig, removeHighlightedCommand, setActivePrompt, setIsStreaming, setMessages, setStreamingMessages, shouldShowOnboarding]);
+    /* eslint-enable complexity */
+    const handleSubmit = useCallback(async (value) => {
+        if (mode === 'main' && !isStreaming) {
+            await executeCommand(value);
+        }
+    }, [executeCommand, isStreaming, mode]);
+    const handleSelect = useCallback(async (value) => {
+        if (!isStreaming)
+            await executeCommand(value);
+    }, [executeCommand, isStreaming]);
+    const handleInsert = useCallback((value) => {
+        const suffix = value.endsWith('/') ? '' : ' ';
+        setInputValue(value + suffix);
+        setInputKey((prev) => prev + 1);
+    }, []);
+    // Hide suggestions during onboarding curate/query steps to focus user on the task
+    const shouldShowSuggestions = !isStreaming && !(shouldShowOnboarding && (currentStep === 'curate' || currentStep === 'query'));
+    return (_jsxs(Box, { flexDirection: "column", flexShrink: 0, children: [shouldShowSuggestions && (_jsx(Suggestions, { input: inputValue, onInsert: handleInsert, onSelect: handleSelect })), shouldShowOnboarding && (_jsxs(Box, { children: [getInstructionText(currentStep, colors.warning), getInstruction({
+                        currentStep,
+                        highlightBgColor: colors.primary,
+                        highlightTextColor: colors.bg1,
+                        textColor: colors.dimText,
+                    })] })), _jsxs(Box, { borderColor: colors.border, borderLeft: false, borderRight: false, borderStyle: "single", paddingX: 2, children: [_jsx(Text, { color: colors.primary, children: '> ' }), _jsx(TextInput, { focus: !activePrompt && (mode === 'main' || mode === 'suggestions'), onChange: (value) => {
+                            if (!(isInCurate || isInCurating || isInQuery || isInQuerying))
+                                setInputValue(value);
+                            if (isInExplore && value.startsWith('/')) {
+                                completeOnboarding();
+                            }
+                        }, onSubmit: handleSubmit, placeholder: placeholder, showCursor: !(isInCurate || isInQuery), value: displayInputValue }, inputKey)] })] }));
+};

package/dist/tui/components/command-item.d.ts

@@ -0,0 +1,14 @@
+/**
+ * CommandMessageItem Component
+ *
+ * Renders a command message with its output directly, without converting to BaseListItem.
+ */
+import React from 'react';
+import type { CommandMessage } from '../types.js';
+export interface CommandItemProps {
+    isLastMessage: boolean;
+    isSelected?: boolean;
+    message: CommandMessage;
+    terminalWidth: number;
+}
+export declare const CommandItem: React.FC<CommandItemProps>;

package/dist/tui/components/command-item.js

@@ -0,0 +1,22 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * CommandMessageItem Component
+ *
+ * Renders a command message with its output directly, without converting to BaseListItem.
+ */
+import { Box, Spacer, Text } from 'ink';
+import { useCommands } from '../contexts/commands-context.js';
+import { useTheme } from '../hooks/index.js';
+import { formatTime } from '../utils/index.js';
+import { CommandOutput, LiveStreamingOutput } from './command/index.js';
+import { MessageItem } from './message-item.js';
+export const CommandItem = ({ isLastMessage, isSelected, message, terminalWidth, }) => {
+    const { activePrompt, isStreaming, streamingMessages } = useCommands();
+    const { theme: { colors } } = useTheme();
+    const hasCompletedOutput = message.output && message.output.length > 0;
+    const showLiveOutput = isLastMessage && (isStreaming || activePrompt) && (streamingMessages.length > 0 || activePrompt);
+    if (message.type === 'error') {
+        return _jsx(MessageItem, { isSelected: isSelected, message: message });
+    }
+    return (_jsxs(Box, { flexDirection: "column", marginBottom: 1, width: "100%", children: [_jsxs(Box, { gap: 1, children: [_jsxs(Text, { color: colors.primary, children: ["\u2022 ", message.fromCommand] }), _jsx(Spacer, {}), _jsx(Text, { color: colors.dimText, children: message.timestamp ? formatTime(message.timestamp) : "" })] }), _jsxs(Box, { gap: 1, children: [_jsx(Box, { borderBottom: false, borderColor: isSelected ? colors.primary : undefined, borderLeft: isSelected, borderRight: false, borderStyle: "bold", borderTop: false, height: "100%", width: 1 }), _jsxs(Box, { borderTop: false, flexDirection: "column", flexGrow: 1, children: [!hasCompletedOutput && showLiveOutput && (_jsx(LiveStreamingOutput, { activePrompt: activePrompt, isStreaming: isStreaming, streamingMessages: streamingMessages, terminalWidth: terminalWidth })), hasCompletedOutput && (_jsx(CommandOutput, { output: message.output, terminalWidth: terminalWidth })), isSelected ? (_jsx(Text, { color: colors.dimText, children: "Show remaining output \u2022 [ctrl+o] to expand" })) : (_jsx(Text, { children: " " }))] })] })] }));
+};

package/dist/tui/components/enter-prompt.js

@@ -5,11 +5,13 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
  * Displays "Press Enter to {action}" prompt
  */
 import { Text, useInput } from 'ink';
+import { useTheme } from '../hooks/index.js';
 export const EnterPrompt = ({ action, active = true, onEnter }) => {
+    const { theme: { colors } } = useTheme();
     useInput((_input, key) => {
         if (key.return && active) {
             onEnter?.();
         }
     }, { isActive: active });
-    return (_jsxs(Text, { color: "gray", children: ["Press", ' ', _jsx(Text, { backgroundColor: "cyan", color: "black", children: ' Enter ' }), ' ', "to ", action] }));
+    return (_jsxs(Text, { color: colors.dimText, children: ["Press", ' ', _jsx(Text, { backgroundColor: colors.primary, color: colors.text, children: ' Enter ' }), ' ', "to ", action] }));
 };

package/dist/tui/components/execution/execution-input.d.ts

@@ -5,6 +5,10 @@
  */
 import React from 'react';
 interface ExecutionInputProps {
+    /** File references from @filepath syntax */
+    files?: string[];
+    /** Folder references from @folderpath syntax */
+    folders?: string[];
     /** The input text to display */
     input: string;
     /** Whether content should be fully expanded (no truncation) */

package/dist/tui/components/execution/execution-input.js

@@ -8,11 +8,23 @@ import { Box, useStdout } from 'ink';
 import { useTheme } from '../../hooks/index.js';
 import { Markdown } from '../markdown.js';
 import { truncateContent } from './execution-content.js';
-export const ExecutionInput = ({ input, isExpand = false }) => {
+export const ExecutionInput = ({ files, folders, input, isExpand = false }) => {
     const { theme: { colors }, } = useTheme();
     const { stdout } = useStdout();
     const contentWidth = (stdout?.columns ?? 80) - 8; // 8 is for padding
-    // In expand mode, render full input without truncation
-    const displayInput = isExpand ? input : truncateContent(input, 1, contentWidth).truncatedContent;
-    return (_jsx(Box, { borderColor: colors.border, borderStyle: "single", flexDirection: "column", paddingX: 1, children: _jsx(Markdown, { children: displayInput }) }));
+    // Build display content: combine input with file/folder references
+    let displayContent = input;
+    // Add folder references first (if any)
+    if (folders && folders.length > 0) {
+        const folderList = folders.map((f) => `@${f}`).join(' ');
+        displayContent = input ? `${input}\n\n**Folders:** ${folderList}` : `**Folders:** ${folderList}`;
+    }
+    // Add file references (if any)
+    if (files && files.length > 0) {
+        const fileList = files.map((f) => `@${f}`).join(' ');
+        displayContent = displayContent ? `${displayContent}\n\n**Files:** ${fileList}` : `**Files:** ${fileList}`;
+    }
+    // In expand mode, render full content without truncation
+    const finalDisplay = isExpand ? displayContent : truncateContent(displayContent, 1, contentWidth).truncatedContent;
+    return (_jsx(Box, { borderColor: colors.border, borderStyle: "single", flexDirection: "column", paddingX: 1, children: _jsx(Markdown, { children: finalDisplay }) }));
 };

package/dist/tui/components/execution/execution-progress.js

@@ -34,21 +34,22 @@ export const ExecutionProgress = ({ isExpanded = false, maxItems = DEFAULT_MAX_I
                 });
             }
         }
-        // Sort by: 1) timestamp ascending, 2) running status last
-        // Running items at the end so they appear when slicing last N items
+        // Sort by timestamp only when expanded, or by timestamp + running status last when collapsed
         return items.sort((a, b) => {
-            // Check if item is running (tool with status 'running' or reasoning with isThinking)
-            const aIsRunning = a.type === 'tool' ? a.data.status === 'running' : a.data.isThinking;
-            const bIsRunning = b.type === 'tool' ? b.data.status === 'running' : b.data.isThinking;
-            // Running items come last (to appear in slice(-maxItems))
-            if (aIsRunning && !bIsRunning)
-                return 1;
-            if (!aIsRunning && bIsRunning)
-                return -1;
-            // Within same status, sort by timestamp ascending
+            if (!isExpanded) {
+                // Check if item is running (tool with status 'running' or reasoning with isThinking)
+                const aIsRunning = a.type === 'tool' ? a.data.status === 'running' : a.data.isThinking;
+                const bIsRunning = b.type === 'tool' ? b.data.status === 'running' : b.data.isThinking;
+                // Running items come last (to appear in slice(-maxItems))
+                if (aIsRunning && !bIsRunning)
+                    return 1;
+                if (!aIsRunning && bIsRunning)
+                    return -1;
+            }
+            // Sort by timestamp ascending
             return a.timestamp - b.timestamp;
         });
-    }, [toolCalls, reasoningContents]);
+    }, [toolCalls, reasoningContents, isExpanded]);
     if (sortedItems.length === 0) {
         return null;
     }

package/dist/tui/components/execution/execution-status.d.ts

@@ -4,7 +4,7 @@
  * Displays the execution status with appropriate spinner and message.
  */
 import React from 'react';
-import type { ExecutionStatus as ExecutionStatusType } from '../../../core/domain/cipher/queue/types.js';
+import type { ExecutionStatus as ExecutionStatusType } from '../../../agent/core/domain/queue/types.js';
 interface ExecutionStatusProps {
     /** The execution status */
     status: ExecutionStatusType;

package/dist/tui/components/execution/execution-tool.d.ts

@@ -5,7 +5,7 @@
  * Following OpenCode's pattern: shows tool parameters inline.
  */
 import React from 'react';
-import type { ToolCallStatus } from '../../../core/domain/cipher/queue/types.js';
+import { ToolCallStatus } from '../../../agent/core/domain/queue/types.js';
 interface ToolCallItem {
     /** Tool call arguments/parameters */
     args?: Record<string, unknown>;

package/dist/tui/components/execution/execution-tool.js

@@ -21,6 +21,65 @@ const BlinkingCircle = ({ color }) => {
     }, []);
     return _jsx(Text, { color: color, children: visible ? '● ' : '  ' });
 };
+/**
+ * Extract key context from code (file paths, search terms, etc.)
+ * Used as fallback when comments are missing or generic.
+ */
+function extractCodeContext(code) {
+    // Try to extract file paths from tools.readFile() calls
+    const readFileMatch = code.match(/tools\.readFile\s*\(\s*['"]([^'"]+)['"]\s*\)/);
+    if (readFileMatch) {
+        return `Read ${readFileMatch[1]}`;
+    }
+    // Try to extract search terms from tools.searchKnowledge() calls
+    const searchMatch = code.match(/tools\.searchKnowledge\s*\(\s*['"]([^'"]+)['"]\s*\)/);
+    if (searchMatch) {
+        return `Search: ${searchMatch[1]}`;
+    }
+    // Try to extract grep patterns
+    const grepMatch = code.match(/tools\.grep\s*\(\s*['"]([^'"]+)['"]\s*\)/);
+    if (grepMatch) {
+        return `Grep: ${grepMatch[1]}`;
+    }
+    // Try to extract curate path/title from tools.curate() calls
+    const curatePathMatch = code.match(/path:\s*['"]([^'"]+)['"]/);
+    const curateTitleMatch = code.match(/title:\s*['"]([^'"]+)['"]/);
+    if (curatePathMatch && curateTitleMatch) {
+        return `Curate ${curateTitleMatch[1]} to ${curatePathMatch[1]}`;
+    }
+    if (curatePathMatch) {
+        return `Curate to ${curatePathMatch[1]}`;
+    }
+    return undefined;
+}
+/**
+ * Extract the first meaningful comment from JavaScript/TypeScript code.
+ * Falls back to extracting context from the code itself.
+ */
+function extractCodeDescription(code) {
+    // Match single-line comments: // comment
+    const singleLineMatch = code.match(/\/\/\s*(.+?)(?:\n|$)/);
+    if (singleLineMatch) {
+        const comment = singleLineMatch[1].trim();
+        // If comment is too generic, try to extract more context
+        if (comment.length < 20 || /^(read|curate|search|get|fetch)\s+(the\s+)?(file|data|content)/i.test(comment)) {
+            const context = extractCodeContext(code);
+            if (context)
+                return context;
+        }
+        return comment;
+    }
+    // Match multi-line comments: /* comment */ or /** comment */
+    const multiLineMatch = code.match(/\/\*\*?\s*([\s\S]*?)\s*\*\//);
+    if (multiLineMatch) {
+        // Get first line of multi-line comment
+        const firstLine = multiLineMatch[1].split('\n')[0].replace(/^\s*\*?\s*/, '').trim();
+        if (firstLine)
+            return firstLine;
+    }
+    // No comment found - try to extract context from code
+    return extractCodeContext(code);
+}
 /**
  * Format tool display with parameters based on tool type.
  * Returns separate parts for tool name and arguments for independent styling.
@@ -41,6 +100,19 @@ function formatToolDisplay(toolName, args, isExpanded = false) {
             }
             break;
         }
+        case 'code_exec':
+        case 'CodeExec': {
+            const { code } = args;
+            if (code && typeof code === 'string') {
+                const description = extractCodeDescription(code);
+                if (description) {
+                    // Truncate description unless expanded
+                    const display = isExpanded || description.length <= 60 ? description : description.slice(0, 57) + '...';
+                    return { toolArguments: display, toolName: 'CodeExec' };
+                }
+            }
+            break;
+        }
         case 'edit':
         case 'Edit': {
             const filePath = args.file_path ?? args.filePath;

package/dist/tui/components/execution/expanded-log-view.js

@@ -44,7 +44,7 @@ export const ExpandedLogView = ({ availableHeight, isActive, log, onClose, }) =>
     useInput((input, key) => {
         if (!scrollViewRef.current)
             return;
-        if ((key.ctrl && input === 'o') || key.escape) {
+        if (key.ctrl && input === 'o') {
             onClose();
         }
         if (key.upArrow || input === 'k') {
@@ -68,7 +68,7 @@ export const ExpandedLogView = ({ availableHeight, isActive, log, onClose, }) =>
         }
     }, { isActive });
     const displayTime = formatTime(log.timestamp);
-    return (_jsxs(Box, { flexDirection: "column", height: "100%", paddingBottom: 1, paddingX: 2, width: "100%", children: [_jsxs(Box, { gap: 1, children: [_jsxs(Text, { color: colors.primary, children: ["\u2022 ", log.type] }), _jsx(Spacer, {}), _jsx(Text, { color: colors.dimText, children: displayTime })] }), _jsxs(Box, { borderColor: colors.border, borderStyle: "single", flexDirection: "column", height: availableHeight - 1, children: [_jsxs(ScrollView, { height: availableHeight - 4, ref: scrollViewRef, children: [_jsx(Box, { marginBottom: 1, paddingX: 1, children: _jsx(Text, { children: log.input }) }), (log.toolCalls || log.reasoningContents) && (_jsx(Box, { paddingX: 1, children: _jsx(ExecutionProgress, { isExpanded: true, reasoningContents: log.reasoningContents, toolCalls: log.toolCalls }) })), log.streamingContent && log.status === 'running' && (_jsx(Box, { paddingX: 1, children: _jsx(StreamingText, { content: log.streamingContent, isStreaming: Boolean(log.isStreaming), maxLines: 0, showCursor: Boolean(log.isStreaming) }) })), (log.status === 'failed' || log.status === 'completed') && (_jsx(Box, { paddingX: 1, children: _jsx(ExecutionContent, { bottomMargin: 0, content: log.content ?? '', isError: log.status === 'failed', isExpanded: true, maxLines: Number.MAX_SAFE_INTEGER }) })), log.status === 'completed' && (_jsx(Box, { paddingX: 1, children: _jsx(ExecutionChanges, { created: log.changes.created, isExpanded: true, maxChanges: {
+    return (_jsxs(Box, { flexDirection: "column", height: "100%", paddingBottom: 1, width: "100%", children: [_jsxs(Box, { gap: 1, children: [_jsxs(Text, { color: colors.primary, children: ["\u2022 ", log.type] }), _jsx(Spacer, {}), _jsx(Text, { color: colors.dimText, children: displayTime })] }), _jsxs(Box, { borderColor: colors.border, borderStyle: "single", flexDirection: "column", height: availableHeight - 1, children: [_jsxs(ScrollView, { height: availableHeight - 4, ref: scrollViewRef, children: [_jsxs(Box, { flexDirection: "column", marginBottom: 1, paddingX: 1, children: [_jsx(Text, { children: log.input }), log.files && log.files.length > 0 && (_jsxs(Text, { color: colors.dimText, children: [_jsx(Text, { bold: true, children: "Files:" }), " ", log.files.map((f) => `@${f}`).join(' ')] }))] }), (log.toolCalls || log.reasoningContents) && (_jsx(Box, { paddingX: 1, children: _jsx(ExecutionProgress, { isExpanded: true, reasoningContents: log.reasoningContents, toolCalls: log.toolCalls }) })), log.streamingContent && log.status === 'running' && (_jsx(Box, { paddingX: 1, children: _jsx(StreamingText, { content: log.streamingContent, isStreaming: Boolean(log.isStreaming), maxLines: 0, showCursor: Boolean(log.isStreaming) }) })), (log.status === 'failed' || log.status === 'completed') && (_jsx(Box, { paddingX: 1, children: _jsx(ExecutionContent, { bottomMargin: 0, content: log.content ?? '', isError: log.status === 'failed', isExpanded: true, maxLines: Number.MAX_SAFE_INTEGER }) })), log.status === 'completed' && (_jsx(Box, { paddingX: 1, children: _jsx(ExecutionChanges, { created: log.changes.created, isExpanded: true, maxChanges: {
                                         created: Number.MAX_SAFE_INTEGER,
                                         updated: Number.MAX_SAFE_INTEGER,
                                     }, updated: log.changes.updated }) }))] }), _jsx(Box, { justifyContent: "center", children: _jsx(Text, { color: colors.dimText, children: hasMoreBelow ? '↓' : ' ' }) })] }), _jsx(Box, { children: _jsx(Text, { color: colors.dimText, children: "[ctrl+o] to collapse" }) })] }));

package/dist/tui/components/execution/index.d.ts

@@ -9,5 +9,4 @@ export { ExecutionInput } from './execution-input.js';
 export { ExecutionProgress } from './execution-progress.js';
 export { ExecutionStatus } from './execution-status.js';
 export { ExpandedLogView } from './expanded-log-view.js';
-export { ExpandedMessageView } from './expanded-message-view.js';
 export { LogItem } from './log-item.js';

package/dist/tui/components/execution/index.js

@@ -9,5 +9,4 @@ export { ExecutionInput } from './execution-input.js';
 export { ExecutionProgress } from './execution-progress.js';
 export { ExecutionStatus } from './execution-status.js';
 export { ExpandedLogView } from './expanded-log-view.js';
-export { ExpandedMessageView } from './expanded-message-view.js';
 export { LogItem } from './log-item.js';

package/dist/tui/components/execution/log-item.d.ts

@@ -10,7 +10,7 @@ interface LogItemProps {
     /** Dynamic heights based on terminal breakpoint */
     heights: MessageItemHeights;
     /** Whether content should be fully expanded (no truncation) */
-    isExpand?: boolean;
+    isExpanded?: boolean;
     /** Whether this log item is currently selected */
     isSelected?: boolean;
     /** The activity log to display */

package/dist/tui/components/execution/log-item.js

@@ -13,9 +13,8 @@ import { ExecutionChanges } from './execution-changes.js';
 import { ExecutionContent } from './execution-content.js';
 import { ExecutionInput } from './execution-input.js';
 import { ExecutionProgress } from './execution-progress.js';
-export const LogItem = memo(({ heights, isExpand, isSelected, log, shouldShowExpand = true }) => {
+export const LogItem = memo(({ heights, isExpanded, isSelected, log }) => {
     const { theme: { colors }, } = useTheme();
     const displayTime = formatTime(log.timestamp);
-    return (_jsxs(Box, { flexDirection: "column", marginBottom: 1, width: "100%", children: [_jsxs(Box, { gap: 1, children: [_jsxs(Text, { color: colors.primary, children: ["\u2022 ", log.type] }), _jsx(Spacer, {}), _jsx(Text, { color: colors.dimText, children: displayTime })] }), _jsxs(Box, { gap: 1, children: [_jsx(Box, { borderBottom: false, borderColor: isSelected ? colors.primary : undefined, borderLeft: isSelected, borderRight: false, borderStyle: "bold", borderTop: false, height: "100%", width: 1 }), _jsxs(Box, { borderTop: false, flexDirection: "column", flexGrow: 1, children: [_jsx(ExecutionInput, { input: log.input }), (log.toolCalls || log.reasoningContents) && log.status === 'running' && (_jsx(ExecutionProgress, { reasoningContents: log.reasoningContents, toolCalls: log.toolCalls })), log.streamingContent && log.status === 'running' && (_jsx(StreamingText, { content: log.streamingContent, isStreaming: Boolean(log.isStreaming), maxLines: isExpand ? 0 : heights.maxContentLines, showCursor: Boolean(log.isStreaming) })), (log.status === 'failed' || log.status === 'completed') && (_jsx(ExecutionContent, { bottomMargin: 0, content: log.content ?? '', isError: log.status === 'failed', maxLines: 3 })), log.status === 'completed' && (_jsx(ExecutionChanges, { created: log.changes.created, marginTop: 1, maxChanges: heights.maxChanges, updated: log.changes.updated })), isSelected && shouldShowExpand ? (_jsx(Text, { color: colors.dimText, children: "Show remaining output \u2022 [ctrl+o] to expand" })) : (_jsx(Text, { children: " " }))] })] })] }));
+    return (_jsxs(Box, { flexDirection: "column", marginBottom: 1, width: "100%", children: [_jsxs(Box, { gap: 1, children: [_jsxs(Text, { color: colors.primary, children: ["\u2022 ", log.type] }), _jsx(Spacer, {}), _jsx(Text, { color: colors.dimText, children: displayTime })] }), _jsxs(Box, { gap: 1, children: [_jsx(Box, { borderBottom: false, borderColor: isSelected ? colors.primary : undefined, borderLeft: isSelected, borderRight: false, borderStyle: "bold", borderTop: false, height: "100%", width: 1 }), _jsxs(Box, { borderTop: false, flexDirection: "column", flexGrow: 1, children: [_jsx(ExecutionInput, { files: log.files, folders: log.folders, input: log.input }), (log.toolCalls || log.reasoningContents) && log.status === 'running' && (_jsx(ExecutionProgress, { reasoningContents: log.reasoningContents, toolCalls: log.toolCalls })), log.streamingContent && log.status === 'running' && (_jsx(StreamingText, { content: log.streamingContent, isStreaming: Boolean(log.isStreaming), maxLines: isExpanded ? 0 : heights.maxContentLines, showCursor: Boolean(log.isStreaming) })), (log.status === 'failed' || log.status === 'completed') && (_jsx(ExecutionContent, { bottomMargin: 0, content: log.content ?? '', isError: log.status === 'failed', maxLines: 3 })), log.status === 'completed' && (_jsx(ExecutionChanges, { created: log.changes.created, isExpanded: isExpanded, marginTop: 1, maxChanges: heights.maxChanges, updated: log.changes.updated })), isSelected ? (_jsx(Text, { color: colors.dimText, children: "Show remaining output \u2022 [ctrl+o] to expand" })) : (_jsx(Text, { children: " " }))] })] })] }));
 });
-LogItem.displayName = 'LogItem';

package/dist/tui/components/footer.js

@@ -2,16 +2,15 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 /**
  * Footer Component - Dynamic based on active tab
  */
-import { Box, Text } from 'ink';
-import { useMemo } from 'react';
-import { useMode } from '../contexts/mode-context.js';
-import { useOnboarding } from '../contexts/onboarding-context.js';
-import { useTheme } from '../contexts/theme-context.js';
+import { Box, Spacer, Text } from 'ink';
+import { useMode, useOnboarding, useTasks, useTheme } from '../contexts/index.js';
 export const Footer = () => {
     const { shortcuts } = useMode();
-    const { shouldShowOnboarding } = useOnboarding();
+    const { isLoadingOnboardingCheck, shouldShowOnboarding } = useOnboarding();
     const { theme: { colors }, } = useTheme();
-    // Filter out 'tab' shortcut during onboarding (tab switching is disabled)
-    const visibleShortcuts = useMemo(() => (shouldShowOnboarding ? shortcuts.filter((s) => s.key !== 'tab') : shortcuts), [shortcuts, shouldShowOnboarding]);
-    return (_jsx(Box, { paddingX: 1, width: "100%", children: visibleShortcuts.map((shortcut, index) => (_jsxs(Box, { children: [index > 0 && _jsx(Text, { color: colors.dimText, children: " \u2022 " }), _jsx(Text, { color: colors.text, children: shortcut.key }), _jsxs(Text, { color: colors.dimText, children: [" ", shortcut.description] })] }, shortcut.key))) }));
+    const { stats: taskStats } = useTasks();
+    if (shouldShowOnboarding || isLoadingOnboardingCheck) {
+        return _jsx(Box, { height: 1, paddingX: 1, width: "100%" });
+    }
+    return (_jsxs(Box, { paddingX: 1, width: "100%", children: [_jsxs(Box, { flexShrink: 0, children: [_jsx(Text, { color: colors.dimText, children: "~ in queue: " }), _jsx(Text, { color: colors.warning, children: taskStats?.created ?? 0 }), _jsx(Text, { color: colors.dimText, children: " | running: " }), _jsx(Text, { color: colors.primary, children: taskStats?.started ?? 0 })] }), _jsx(Spacer, {}), shortcuts.map((shortcut, index) => (_jsxs(Box, { children: [index > 0 && _jsx(Text, { color: colors.dimText, children: " \u2022 " }), _jsx(Text, { color: colors.text, children: shortcut.key }), _jsxs(Text, { color: colors.dimText, children: [" ", shortcut.description] })] }, shortcut.key)))] }));
 };

package/dist/tui/components/header.d.ts

@@ -7,12 +7,8 @@
  * - Queue stats (pending/processing)
  */
 import React from 'react';
-import { TaskStats } from '../types/ui.js';
 interface HeaderProps {
     compact?: boolean;
-    connectedAgent?: string;
-    showStatusLine?: boolean;
-    taskStats?: TaskStats;
 }
 export declare const Header: React.FC<HeaderProps>;
 export {};