byterover-cli 0.4.1 → 1.0.0

package/dist/tui/utils/log.js

@@ -0,0 +1,114 @@
+/**
+ * Log utility functions for height calculations
+ */
+/**
+ * Calculate the actual rendered height of a log item.
+ * This reflects the real space the item takes up when rendered.
+ *
+ * @param log - The activity log to analyze
+ * @param baseHeights - Base height configuration from breakpoint (maxContentLines is optional)
+ * @returns Total height in lines that this log item will occupy
+ */
+export function calculateActualLogHeight(log, baseHeights) {
+    let totalLines = 0;
+    // Header: always 1 line
+    totalLines += baseHeights.header;
+    // Input: always present
+    totalLines += baseHeights.input;
+    // Progress: only if there are progress items
+    const actualProgress = log.progress?.length ?? 0;
+    if (actualProgress > 0) {
+        totalLines += Math.min(actualProgress, baseHeights.maxProgressItems);
+    }
+    // Status: always 1 line (from ExecutionStatus)
+    totalLines += 1;
+    // Content: only for completed/failed
+    if (log.status === 'completed' || log.status === 'failed') {
+        const contentText = log.content ?? '';
+        const contentLineCount = contentText.split('\n').length;
+        totalLines += Math.min(contentLineCount, baseHeights.maxContentLines ?? 10);
+        totalLines += baseHeights.contentBottomMargin;
+    }
+    // Changes: only for completed
+    if (log.status === 'completed') {
+        const actualCreated = log.changes.created.length;
+        const actualUpdated = log.changes.updated.length;
+        // Created section
+        if (actualCreated > 0) {
+            const createdOverflow = actualCreated > baseHeights.maxChanges.created;
+            const createdItemsMax = createdOverflow ? baseHeights.maxChanges.created - 1 : baseHeights.maxChanges.created;
+            const displayedCreated = Math.min(actualCreated, createdItemsMax);
+            totalLines += displayedCreated + (createdOverflow ? 1 : 0);
+        }
+        // Updated section
+        if (actualUpdated > 0) {
+            const updatedOverflow = actualUpdated > baseHeights.maxChanges.updated;
+            const updatedItemsMax = updatedOverflow ? baseHeights.maxChanges.updated - 1 : baseHeights.maxChanges.updated;
+            const displayedUpdated = Math.min(actualUpdated, updatedItemsMax);
+            totalLines += displayedUpdated + (updatedOverflow ? 1 : 0);
+        }
+    }
+    // Bottom margin
+    totalLines += baseHeights.bottomMargin;
+    return totalLines;
+}
+/**
+ * Calculate dynamic space usage for each part of a log
+ * Returns array showing how many lines each field uses
+ *
+ * @param log - The activity log to analyze
+ * @param scrollableHeight - Total available height for content area
+ * @param baseHeights - Base height configuration from breakpoint
+ * @returns Array of { field, lines } showing space breakdown, including calculated content lines
+ */
+export function calculateLogContentLimit(log, scrollableHeight, baseHeights) {
+    const parts = [];
+    parts.push({ field: 'header', lines: baseHeights.header }, { field: 'input', lines: baseHeights.input });
+    // Progress - based on actual items
+    const actualProgress = log.progress?.length ?? 0;
+    const progressLines = Math.min(actualProgress, baseHeights.maxProgressItems);
+    if (progressLines > 0) {
+        parts.push({ field: 'progress', lines: progressLines });
+    }
+    // Content bottom margin - only if has content (completed/failed)
+    if (log.status === 'completed' || log.status === 'failed') {
+        parts.push({ field: 'contentBottomMargin', lines: baseHeights.contentBottomMargin });
+    }
+    // Changes - only if completed
+    if (log.status === 'completed') {
+        const actualCreated = log.changes.created.length;
+        const actualUpdated = log.changes.updated.length;
+        // Created section
+        if (actualCreated > 0) {
+            const createdOverflow = actualCreated > baseHeights.maxChanges.created;
+            const createdItemsMax = createdOverflow ? baseHeights.maxChanges.created - 1 : baseHeights.maxChanges.created;
+            const displayedCreated = Math.min(actualCreated, createdItemsMax);
+            const createdLines = displayedCreated + (createdOverflow ? 1 : 0);
+            parts.push({ field: 'created', lines: createdLines });
+        }
+        // Updated section
+        if (actualUpdated > 0) {
+            const updatedOverflow = actualUpdated > baseHeights.maxChanges.updated;
+            const updatedItemsMax = updatedOverflow ? baseHeights.maxChanges.updated - 1 : baseHeights.maxChanges.updated;
+            const displayedUpdated = Math.min(actualUpdated, updatedItemsMax);
+            const updatedLines = displayedUpdated + (updatedOverflow ? 1 : 0);
+            parts.push({ field: 'updated', lines: updatedLines });
+        }
+    }
+    // Bottom margin - always present
+    parts.push({ field: 'bottomMargin', lines: baseHeights.bottomMargin });
+    // Calculate content lines: scrollableHeight minus all other parts
+    const otherPartsTotal = parts.reduce((sum, part) => sum + part.lines, 0);
+    const contentLines = Math.max(0, scrollableHeight - otherPartsTotal);
+    // Insert content field (after progress/spinner, before contentBottomMargin)
+    const contentBottomMarginIndex = parts.findIndex((p) => p.field === 'contentBottomMargin');
+    if (contentBottomMarginIndex === -1) {
+        // If no contentBottomMargin, add before bottomMargin
+        const bottomMarginIndex = parts.findIndex((p) => p.field === 'bottomMargin');
+        parts.splice(bottomMarginIndex, 0, { field: 'content', lines: contentLines });
+    }
+    else {
+        parts.splice(contentBottomMarginIndex, 0, { field: 'content', lines: contentLines });
+    }
+    return parts;
+}

package/dist/tui/views/command-view.d.ts

@@ -5,6 +5,13 @@
  * Uses ScrollableList for message history with dynamic height calculation.
  */
 import React from 'react';
+/**
+ * Props for CommandView component
+ *
+ * Calculated as: `Math.max(1, terminalHeight - header - tab - footer)`
+ * This represents the remaining terminal space after accounting for all UI chrome
+ * (header, tab bar, and footer), ensuring at least 1 line is always available.
+ */
 interface CommandViewProps {
     availableHeight: number;
 }

package/dist/tui/views/command-view.js

@@ -9,81 +9,95 @@ import { Box, Spacer, Text, useApp } from 'ink';
 import Spinner from 'ink-spinner';
 import TextInput from 'ink-text-input';
 import { useCallback, useEffect, useMemo, useState } from 'react';
-import { stopConsumer } from '../../infra/cipher/consumer/execution-consumer.js';
 import { stopQueuePollingService } from '../../infra/cipher/consumer/queue-polling-service.js';
 import { MessageItem, ScrollableList, Suggestions } from '../components/index.js';
 import { InlineConfirm, InlineFileSelector, InlineInput, InlineSearch, InlineSelect, } from '../components/inline-prompts/index.js';
-import { useAuth } from '../contexts/auth-context.js';
-import { useConsumer } from '../contexts/index.js';
-import { useCommands, useMode, useTheme } from '../hooks/index.js';
-/** Fixed height for bottom area (suggestions + input) */
-const BOTTOM_AREA_HEIGHT = 4;
+import { useAuth, useTasks, useTransport } from '../contexts/index.js';
+import { useCommands, useMode, useTerminalBreakpoint, useTheme, useUIHeights } from '../hooks/index.js';
+import { getVisualLineCount } from '../utils/line.js';
 /** Max visible items in InlineSearch */
 const INLINE_SEARCH_MAX_ITEMS = 7;
-/** Minimum output lines to show before truncation */
-const MIN_OUTPUT_LINES = 5;
-/** Reserved lines for output box (command header + borders + hint line + margin) */
-const OUTPUT_BOX_OVERHEAD = 5;
 /**
- * Count the total number of lines in streaming messages
- * Each message can contain multiple lines (newlines in content)
+ * Calculate visual line count for a message
  */
-function countOutputLines(messages) {
-    let total = 0;
-    for (const msg of messages) {
-        total += msg.content.split('\n').length;
+function getMessageVisualLineCount(message, terminalWidth) {
+    return message.content
+        .split('\n')
+        .reduce((total, line) => total + getVisualLineCount(line, terminalWidth), 0);
+}
+/**
+ * Count total visual lines across all messages
+ */
+function countOutputLines(messages, terminalWidth) {
+    return messages.reduce((total, msg) => total + getMessageVisualLineCount(msg, terminalWidth), 0);
+}
+/**
+ * Truncate message content from the end to fit within available visual lines
+ */
+function truncateMessageFromEnd(message, availableLines, terminalWidth) {
+    const lines = message.content.split('\n');
+    const truncatedLines = [];
+    let usedLines = 0;
+    // Build from end, taking lines that fit
+    for (let i = lines.length - 1; i >= 0; i--) {
+        const line = lines[i];
+        const lineVisualCount = getVisualLineCount(line, terminalWidth);
+        if (usedLines + lineVisualCount <= availableLines) {
+            truncatedLines.unshift(line);
+            usedLines += lineVisualCount;
+        }
+        else if (usedLines < availableLines) {
+            // Partial line - take last chars that fit
+            const remainingLines = availableLines - usedLines;
+            const maxChars = remainingLines * terminalWidth;
+            truncatedLines.unshift(line.slice(-maxChars));
+            usedLines = availableLines;
+            break;
+        }
+        else {
+            break;
+        }
     }
-    return total;
+    return { content: truncatedLines.join('\n'), usedLines };
 }
 /**
- * Get messages from the end that fit within maxLines, truncating from the beginning (shows newest first)
- * Used for both completed and live streaming output to always show the latest messages
+ * Get messages from end that fit within maxLines (shows newest first)
  */
-function getMessagesFromEnd(messages, maxLines) {
-    const totalLines = countOutputLines(messages);
+function getMessagesFromEnd(messages, maxLines, terminalWidth) {
+    const totalLines = countOutputLines(messages, terminalWidth);
     if (totalLines <= maxLines) {
         return { displayMessages: messages, skippedLines: 0, totalLines };
     }
     const displayMessages = [];
-    let lineCount = 0;
-    // Iterate from the end (newest messages first)
-    for (let i = messages.length - 1; i >= 0; i--) {
+    let usedLines = 0;
+    // Iterate from end (newest first)
+    for (let i = messages.length - 1; i >= 0 && usedLines < maxLines; i--) {
         const msg = messages[i];
-        const msgLineArray = msg.content.split('\n');
-        const msgLineCount = msgLineArray.length;
-        if (lineCount + msgLineCount <= maxLines) {
-            // Message fits completely - prepend to maintain order
+        const msgLineCount = getMessageVisualLineCount(msg, terminalWidth);
+        const availableLines = maxLines - usedLines;
+        if (msgLineCount <= availableLines) {
+            // Whole message fits
             displayMessages.unshift(msg);
-            lineCount += msgLineCount;
+            usedLines += msgLineCount;
         }
-        else {
-            // Message needs to be truncated - show partial lines from the end
-            const remainingSpace = maxLines - lineCount;
-            if (remainingSpace > 0) {
-                // Take only the last lines that fit
-                const truncatedContent = msgLineArray.slice(-remainingSpace).join('\n');
-                displayMessages.unshift({
-                    ...msg,
-                    content: truncatedContent,
-                });
-                lineCount += remainingSpace;
-            }
+        else if (availableLines > 0) {
+            // Truncate message to fit
+            const { content, usedLines: truncatedLines } = truncateMessageFromEnd(msg, availableLines, terminalWidth);
+            displayMessages.unshift({ ...msg, content });
+            usedLines += truncatedLines;
             break;
         }
     }
-    // Ensure we show at least one line
+    // Fallback: show at least last line of last message
     if (displayMessages.length === 0 && messages.length > 0) {
         const lastMsg = messages.at(-1);
-        const lastLines = lastMsg.content.split('\n');
-        displayMessages.push({
-            ...lastMsg,
-            content: lastLines.at(-1) ?? '',
-        });
-        lineCount = 1;
+        const lastLine = lastMsg.content.split('\n').at(-1) ?? '';
+        displayMessages.push({ ...lastMsg, content: lastLine });
+        usedLines = getVisualLineCount(lastLine, terminalWidth);
     }
     return {
         displayMessages,
-        skippedLines: totalLines - lineCount,
+        skippedLines: totalLines - usedLines,
         totalLines,
     };
 }
@@ -163,7 +177,7 @@ function estimatePromptHeight(prompt) {
  * Estimate the line height of a command message
  */
 function estimateMessageHeight(msg, options) {
-    const { isLast = false, maxOutputLines, promptHeight = 0, streamingLines = 0 } = options;
+    const { isLast = false, maxOutputLines, promptHeight = 0, streamingLines = 0, terminalWidth } = options;
     let lines = 0;
     if (msg.type === 'command') {
         // Command header with left border
@@ -171,7 +185,7 @@ function estimateMessageHeight(msg, options) {
         // Output box if present (completed output)
         if (msg.output && msg.output.length > 0) {
             // Count actual lines in the output (each message can have multiple lines)
-            const totalOutputLines = countOutputLines(msg.output);
+            const totalOutputLines = countOutputLines(msg.output, terminalWidth);
             // Account for truncation: show max lines + 1 for hint
             const displayedLines = totalOutputLines <= maxOutputLines ? totalOutputLines : maxOutputLines + 1;
             // Border top + content + border bottom
@@ -194,7 +208,8 @@ function estimateMessageHeight(msg, options) {
 export const CommandView = ({ availableHeight }) => {
     const { exit } = useApp();
     const { reloadAuth, reloadBrvConfig } = useAuth();
-    const { restart } = useConsumer();
+    const { client } = useTransport();
+    const { clearTasks } = useTasks();
     const [command, setCommand] = useState('');
     const [inputKey, setInputKey] = useState(0);
     const [messages, setMessages] = useState([]);
@@ -202,6 +217,8 @@ export const CommandView = ({ availableHeight }) => {
     const [activePrompt, setActivePrompt] = useState(null);
     const [isStreaming, setIsStreaming] = useState(false);
     const { theme: { colors }, } = useTheme();
+    const { commandInput } = useUIHeights();
+    const { breakpoint, columns: terminalWidth } = useTerminalBreakpoint();
     // Process streaming messages to handle action_start/action_stop pairs
     const processedStreamingMessages = useMemo(() => processMessagesForActions(streamingMessages), [streamingMessages]);
     const { handleSlashCommand } = useCommands();
@@ -288,24 +305,30 @@ export const CommandView = ({ availableHeight }) => {
                 const needReloadBrvConfig = trimmed.startsWith('/space switch') || trimmed.startsWith('/init');
                 // Refresh state after commands that change auth or project state
                 if (needReloadAuth || needReloadBrvConfig) {
-                    // Stop queue polling and consumer
-                    stopQueuePollingService();
-                    stopConsumer();
-                    // Wait for consumer to stop
-                    setTimeout(async () => {
-                        if (needReloadAuth)
-                            await reloadAuth();
-                        if (needReloadBrvConfig)
-                            await reloadBrvConfig();
-                        await restart();
-                    }, 1000);
+                    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.request('agent:restart', { reason });
+                    }
                 }
             }
         }
-    }, [exit, handleSlashCommand, reloadAuth, restart]);
+    }, [clearTasks, client, exit, handleSlashCommand, reloadAuth, reloadBrvConfig]);
     const handleSubmit = useCallback(async (value) => {
-        if (mode === 'console' && !isStreaming)
+        if (mode === 'console' && !isStreaming) {
             await executeCommand(value);
+        }
     }, [executeCommand, isStreaming, mode]);
     const handleSelect = useCallback(async (value) => {
         if (!isStreaming)
@@ -350,11 +373,9 @@ export const CommandView = ({ availableHeight }) => {
         }
     }, [activePrompt]);
     // Calculate available height for scrollable content
-    // Subtract bottom area (suggestions + input)
-    const scrollableHeight = Math.max(1, availableHeight - BOTTOM_AREA_HEIGHT);
-    // Calculate max output lines based on available height
-    // Reserve space for command header, borders, hint line, and margin
-    const maxOutputLines = Math.max(MIN_OUTPUT_LINES, scrollableHeight - OUTPUT_BOX_OVERHEAD);
+    const scrollableHeight = Math.max(1, availableHeight - commandInput);
+    // Subtract input + border + indicator lines + indicator page (1 + 2 + 1 + 2)
+    const maxOutputLines = scrollableHeight - 6;
     // Render streaming message (handles ProcessedMessage for action types)
     const renderStreamingMessage = useCallback((msg) => {
         // Handle action messages with spinner
@@ -383,7 +404,9 @@ export const CommandView = ({ availableHeight }) => {
                 return (_jsx(InlineConfirm, { default: activePrompt.default, message: activePrompt.message, onConfirm: handleConfirmResponse }));
             }
             case 'file_selector': {
-                return (_jsx(InlineFileSelector, { allowCancel: activePrompt.allowCancel, basePath: activePrompt.basePath, filter: activePrompt.filter, message: activePrompt.message, mode: activePrompt.mode, onSelect: handleFileSelectorResponse, pageSize: activePrompt.pageSize }));
+                // availableHeight - more above indicator - input - selector title - selector footer - command input
+                const pageSize = availableHeight - 1 - 1 - 4 - 4 - commandInput;
+                return (_jsx(InlineFileSelector, { allowCancel: activePrompt.allowCancel, basePath: activePrompt.basePath, filter: activePrompt.filter, message: activePrompt.message, mode: activePrompt.mode, onSelect: handleFileSelectorResponse, pageSize: breakpoint === 'normal' ? pageSize : 2 }));
             }
             case 'input': {
                 return (_jsx(InlineInput, { message: activePrompt.message, onSubmit: handleInputResponse, placeholder: activePrompt.placeholder, validate: activePrompt.validate }));
@@ -406,22 +429,21 @@ export const CommandView = ({ availableHeight }) => {
         handleSearchResponse,
         handleSelectResponse,
     ]);
-    // Render a single message item
-    // For the last command message during streaming, show live streaming output
     const renderMessageItem = useCallback((msg, index) => {
         if (msg.type === 'command') {
             const hasOutput = msg.output && msg.output.length > 0;
             const isLastMessage = index === messages.length - 1;
             const showLiveOutput = isLastMessage && (isStreaming || activePrompt) && (streamingMessages.length > 0 || activePrompt);
-            return (_jsxs(Box, { flexDirection: "column", marginTop: index === 0 ? 0 : 1, width: "100%", children: [_jsx(Box, { borderBottom: false, borderLeftColor: colors.primary, borderRight: false, borderStyle: "bold", borderTop: false, paddingLeft: 1, children: _jsxs(Text, { color: colors.text, dimColor: true, children: [msg.fromCommand, " ", _jsx(Text, { wrap: "truncate-end", children: msg.content })] }) }), hasOutput &&
+            const contentWidth = terminalWidth - 12;
+            return (_jsxs(Box, { flexDirection: "column", marginBottom: 1, width: "100%", children: [_jsx(Box, { borderBottom: false, borderLeftColor: colors.primary, borderRight: false, borderStyle: "bold", borderTop: false, paddingLeft: 1, children: _jsxs(Text, { color: colors.text, dimColor: true, children: [msg.fromCommand, " ", _jsx(Text, { wrap: "truncate-end", children: msg.content })] }) }), hasOutput &&
                         (() => {
                             const processedOutput = processMessagesForActions(msg.output);
-                            const { displayMessages, skippedLines } = getMessagesFromEnd(processedOutput, maxOutputLines);
-                            return (_jsxs(Box, { borderColor: colors.border, borderStyle: "round", flexDirection: "column", marginTop: 0, paddingX: 1, width: "100%", children: [skippedLines > 0 && (_jsxs(Text, { color: colors.secondary, dimColor: true, children: ["\u2191 ", skippedLines, " more lines above"] })), displayMessages.map((streamMsg) => renderStreamingMessage(streamMsg))] }));
+                            const { displayMessages, skippedLines } = getMessagesFromEnd(processedOutput, maxOutputLines, contentWidth);
+                            return (_jsxs(Box, { borderColor: colors.border, borderStyle: "round", flexDirection: "column", paddingX: 1, width: "100%", children: [skippedLines > 0 && (_jsxs(Text, { color: colors.secondary, dimColor: true, children: ["\u2191 ", skippedLines, " more lines above"] })), displayMessages.map((streamMsg) => renderStreamingMessage(streamMsg))] }));
                         })(), showLiveOutput &&
                         (() => {
-                            const { displayMessages: liveMessages, skippedLines } = getMessagesFromEnd(processedStreamingMessages, maxOutputLines);
-                            return (_jsxs(Box, { borderColor: colors.border, borderStyle: "round", flexDirection: "column", paddingX: 1, paddingY: 0, width: "100%", children: [skippedLines > 0 && (_jsxs(Text, { color: colors.secondary, dimColor: true, children: ["\u2191 ", skippedLines, " more lines above"] })), liveMessages.map((streamMsg) => renderStreamingMessage(streamMsg)), isStreaming && !activePrompt && msg.fromCommand.startsWith('/query') && (_jsxs(Text, { color: colors.dimText, children: [_jsx(Spinner, { type: "dots" }), " Processing..."] })), renderActivePrompt()] }));
+                            const { displayMessages: liveMessages, skippedLines } = getMessagesFromEnd(processedStreamingMessages, maxOutputLines, contentWidth);
+                            return (_jsxs(Box, { borderColor: colors.border, borderStyle: "round", flexDirection: "column", paddingX: 1, paddingY: 0, width: "100%", children: [skippedLines > 0 && (_jsxs(Text, { color: colors.secondary, dimColor: true, children: ["\u2191 ", skippedLines, " more lines above"] })), liveMessages.map((streamMsg) => renderStreamingMessage(streamMsg)), isStreaming && !activePrompt && liveMessages.length === 0 && (_jsxs(Text, { color: colors.dimText, children: [_jsx(Spinner, { type: "dots" }), " Processing..."] })), renderActivePrompt()] }));
                         })()] }));
         }
         return _jsx(MessageItem, { message: msg });
@@ -445,7 +467,8 @@ export const CommandView = ({ availableHeight }) => {
             maxOutputLines,
             promptHeight: isLive ? estimatePromptHeight(activePrompt) : 0,
             streamingLines: isLive ? streamingMessages.length : 0,
+            terminalWidth,
         });
-    }, [activePrompt, isStreaming, maxOutputLines, messages.length, streamingMessages.length]);
-    return (_jsxs(Box, { flexDirection: "column", height: "100%", width: "100%", children: [messages.length > 0 ? (_jsx(Box, { flexDirection: "column", flexGrow: 1, paddingX: 2, children: _jsx(ScrollableList, { autoScrollToBottom: true, availableHeight: scrollableHeight, estimateItemHeight: heightEstimator, isActive: mode === 'console' && !activePrompt && !isStreaming, items: messages, keyExtractor: keyExtractor, renderItem: renderMessageItem }) })) : (_jsx(Spacer, {})), _jsxs(Box, { flexDirection: "column", flexShrink: 0, children: [!isStreaming && !activePrompt && (_jsx(Suggestions, { input: command, onInsert: handleInsert, onSelect: handleSelect })), _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 === 'console' || mode === 'suggestions'), onChange: setCommand, onSubmit: handleSubmit, placeholder: isStreaming ? 'Command running...' : 'Use / to view commands', value: command }, inputKey)] })] })] }));
+    }, [activePrompt, isStreaming, maxOutputLines, messages.length, streamingMessages.length, terminalWidth]);
+    return (_jsxs(Box, { flexDirection: "column", height: "100%", width: "100%", children: [messages.length > 0 ? (_jsx(Box, { flexDirection: "column", flexGrow: 1, paddingX: 2, children: _jsx(ScrollableList, { autoScrollToBottom: true, availableHeight: scrollableHeight, estimateItemHeight: heightEstimator, isActive: mode === 'console' && !activePrompt && !isStreaming, items: messages, keyExtractor: keyExtractor, renderItem: renderMessageItem }) })) : (_jsx(Spacer, {})), _jsxs(Box, { flexDirection: "column", flexShrink: 0, children: [!isStreaming && !activePrompt && (_jsx(Suggestions, { input: command, onInsert: handleInsert, onSelect: handleSelect })), _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 === 'console' || mode === 'suggestions'), onChange: setCommand, onSubmit: handleSubmit, placeholder: isStreaming ? 'Processing...' : 'Use / to view commands', value: command }, inputKey)] })] })] }));
 };

package/dist/tui/views/login-view.js

@@ -11,12 +11,12 @@ import { Box, Text } from 'ink';
 import Spinner from 'ink-spinner';
 import { useState } from 'react';
 import { EnterPrompt, OutputLog } from '../components/index.js';
-import { useAuth, useConsumer } from '../contexts/index.js';
-import { useTheme } from '../contexts/use-theme.js';
+import { useAuth, useTasks, useTheme, useTransport } from '../contexts/index.js';
 export const LoginView = () => {
     const { theme } = useTheme();
     const { isLoggingIn, login, loginOutput, reloadAuth } = useAuth();
-    const { restart } = useConsumer();
+    const { client } = useTransport();
+    const { clearTasks } = useTasks();
     const [hasStartedLogin, setHasStartedLogin] = useState(false);
     // Derive state from props and local state
     const state = isLoggingIn ? 'loading' : hasStartedLogin ? 'completed' : 'idle';
@@ -24,7 +24,10 @@ export const LoginView = () => {
                     login();
                     setHasStartedLogin(true);
                 } })), state === 'completed' && _jsx(EnterPrompt, { action: "continue", onEnter: async () => {
+                    clearTasks();
                     await reloadAuth();
-                    await restart();
+                    if (client) {
+                        await client.request('agent:restart', { reason: 'User logged in' });
+                    }
                 } })] }));
 };

package/dist/tui/views/logs-view.d.ts

@@ -5,6 +5,19 @@
  */
 import React from 'react';
 interface LogsViewProps {
+    /**
+     * Available height for the logs view content area (in terminal rows)
+     *
+     * Calculated as: `terminalHeight - header - tab - footer`
+     *
+     * This represents the vertical space allocated for scrollable log content
+     * after accounting for fixed UI elements (header, tab bar, footer).
+     * Internally adjusted to `availableHeight - 1` for border spacing.
+     *
+     * @example
+     * // Terminal: 30 rows, header: 2, tab: 3, footer: 1
+     * // availableHeight = 30 - 2 - 3 - 1 = 24 rows for content
+     */
     availableHeight: number;
 }
 export declare const LogsView: React.FC<LogsViewProps>;

package/dist/tui/views/logs-view.js

@@ -7,67 +7,42 @@ import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-run
 import { Box, Text } from 'ink';
 import { useCallback } from 'react';
 import { LogItem, OnboardingFlow, ScrollableList } from '../components/index.js';
-import { useActivityLogs, useMode, useTheme } from '../hooks/index.js';
+import { useActivityLogs, useMode, useTheme, useUIHeights } from '../hooks/index.js';
 import { useOnboarding } from '../hooks/use-onboarding.js';
-const MAX_PROGRESS_ITEMS = 3;
-/** Minimum content lines to show before truncation */
-const MIN_CONTENT_LINES = 5;
-/** Reserved lines for log item (header + input box + progress + margins) */
-const LOG_ITEM_OVERHEAD = 6;
-/**
- * Estimate the line height of a log item
- */
-function estimateLogHeight(log, maxContentLines) {
-    let lines = 0;
-    // Header line: [type] @source [timestamp]
-    lines += 1;
-    // Input box with border (top border + content + bottom border)
-    lines += 3;
-    // Progress items (max MAX_PROGRESS_ITEMS shown + optional "more" line)
-    const progressCount = Math.min(log.progress?.length ?? 0, MAX_PROGRESS_ITEMS);
-    lines += progressCount;
-    if ((log.progress?.length ?? 0) > MAX_PROGRESS_ITEMS) {
-        lines += 1; // "... and X more" line
-    }
-    // Processing spinner (if running)
-    if (log.status === 'running') {
-        lines += 1;
-    }
-    // Content (if completed or failed)
-    if (log.status === 'completed' || log.status === 'failed') {
-        const contentLineCount = log.content?.split('\n').length ?? 0;
-        // Account for truncation: show max lines + 1 for hint if truncated
-        const displayedLines = contentLineCount <= maxContentLines ? contentLineCount : maxContentLines + 1;
-        lines += displayedLines;
-    }
-    // Changes sections
-    if (log.status === 'completed') {
-        if (log.changes.created.length > 0) {
-            lines += 1 + log.changes.created.length;
-        }
-        if (log.changes.updated.length > 0) {
-            lines += 1 + log.changes.updated.length;
-        }
-    }
-    // Bottom margin
-    lines += 1;
-    return lines;
-}
+import { calculateActualLogHeight, calculateLogContentLimit } from '../utils/log.js';
 export const LogsView = ({ availableHeight }) => {
     const { theme: { colors }, } = useTheme();
     const { mode } = useMode();
     const { logs } = useActivityLogs();
     const { shouldShowOnboarding } = useOnboarding();
-    // Calculate max content lines based on available height
-    const scrollableHeight = Math.max(1, availableHeight - 1);
-    const maxContentLines = Math.max(MIN_CONTENT_LINES, scrollableHeight - LOG_ITEM_OVERHEAD);
-    const renderLogItem = useCallback((log) => _jsx(LogItem, { log: log, maxContentLines: maxContentLines, maxProgressItems: MAX_PROGRESS_ITEMS }), [maxContentLines]);
+    const { messageItem } = useUIHeights();
+    // Calculate scrollable height for dynamic per-log calculations
+    const scrollableHeight = Math.max(1, availableHeight);
+    const renderLogItem = useCallback((log) => {
+        // Calculate dynamic content limit for this specific log
+        const parts = calculateLogContentLimit(log, scrollableHeight, messageItem);
+        const contentPart = parts.find((p) => p.field === 'content');
+        const maxContentLine = contentPart?.lines ?? 0;
+        return (_jsx(LogItem, { heights: {
+                ...messageItem,
+                maxContentLines: maxContentLine,
+            }, log: log }));
+    }, [messageItem, scrollableHeight]);
     const keyExtractor = useCallback((log) => log.id, []);
-    // Height estimator that accounts for content truncation
-    const heightEstimator = useCallback((log) => estimateLogHeight(log, maxContentLines), [maxContentLines]);
+    // Height calculator that returns the actual rendered height of each log item
+    const heightEstimator = useCallback((log) => {
+        // Calculate dynamic content limit for height estimation
+        const parts = calculateLogContentLimit(log, scrollableHeight, messageItem);
+        const contentPart = parts.find((p) => p.field === 'content');
+        const maxContentLine = contentPart?.lines ?? 0;
+        return calculateActualLogHeight(log, {
+            ...messageItem,
+            maxContentLines: maxContentLine,
+        });
+    }, [messageItem, scrollableHeight]);
     // Show onboarding when project is not initialized
     if (shouldShowOnboarding) {
-        return _jsx(OnboardingFlow, { availableHeight: scrollableHeight });
+        return _jsx(OnboardingFlow, { availableHeight: availableHeight });
     }
     return (_jsx(Box, { borderColor: colors.border, borderLeft: false, borderRight: false, borderStyle: "single", borderTop: false, flexDirection: "column", height: "100%", width: "100%", children: logs.length > 0 ? (_jsx(Box, { flexDirection: "column", height: "100%", paddingX: 2, children: _jsx(ScrollableList, { autoScrollToBottom: true, availableHeight: scrollableHeight, estimateItemHeight: heightEstimator, isActive: mode === 'activity', items: logs, keyExtractor: keyExtractor, renderItem: renderLogItem }) })) : (_jsxs(_Fragment, { children: [_jsx(Text, { color: colors.primary, children: "Welcome to ByteRover!" }), _jsx(Text, { color: colors.text, children: "Start by telling your AI Agent what to save or retrieve." }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { color: colors.text, dimColor: true, children: "Press [Tab] to switch to commands view" }) })] })) }));
 };

package/dist/utils/connection-error-handler.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Error handler callback type for oclif commands.
+ * @param message - Error message to display
+ * @param options - Options for the error (exit code, etc.)
+ */
+type ErrorCallback = (message: string, options: {
+    exit: number;
+}) => never;
+/**
+ * Format and handle connection-related errors with user-friendly messages.
+ *
+ * @param error - The error to handle
+ * @param errorCallback - The oclif command's error() method
+ */
+export declare function handleConnectionError(error: unknown, errorCallback: ErrorCallback): never;
+export {};

package/dist/utils/connection-error-handler.js

@@ -0,0 +1,49 @@
+/**
+ * Shared utility for handling connection errors in CLI commands.
+ * Extracted from query.ts and curate.ts to avoid code duplication.
+ */
+import { ConnectionError, ConnectionFailedError, InstanceCrashedError, NoInstanceRunningError, } from '../core/domain/errors/connection-error.js';
+import { getSandboxEnvironmentName, isSandboxEnvironment, isSandboxNetworkError } from './sandbox-detector.js';
+/**
+ * Format and handle connection-related errors with user-friendly messages.
+ *
+ * @param error - The error to handle
+ * @param errorCallback - The oclif command's error() method
+ */
+export function handleConnectionError(error, errorCallback) {
+    if (error instanceof NoInstanceRunningError) {
+        if (isSandboxEnvironment()) {
+            const sandboxName = getSandboxEnvironmentName();
+            errorCallback(`Error: No ByteRover instance is running.\n` +
+                `⚠️  Sandbox environment detected (${sandboxName}).\n\n` +
+                `Please run 'brv' command in a separate terminal window/tab outside the sandbox first.`, { exit: 1 });
+        }
+        else {
+            errorCallback('No ByteRover instance is running.\n\n' +
+                'Start a ByteRover instance by running "brv" in a separate terminal window/tab.\n' +
+                'The instance will keep running and handle your commands.', { exit: 1 });
+        }
+    }
+    if (error instanceof InstanceCrashedError) {
+        errorCallback('ByteRover instance has crashed.\n\nPlease restart with: brv', { exit: 1 });
+    }
+    if (error instanceof ConnectionFailedError) {
+        const isSandboxError = isSandboxNetworkError(error.originalError ?? error);
+        if (isSandboxError) {
+            const sandboxName = getSandboxEnvironmentName();
+            errorCallback(`Error: Failed to connect to ByteRover instance.\n` +
+                `Port: ${error.port ?? 'unknown'}\n` +
+                `⚠️  Sandbox network restriction detected (${sandboxName}).\n\n` +
+                `Please allow network access in the sandbox and retry the command.`, { exit: 1 });
+        }
+        else {
+            errorCallback(`Failed to connect to ByteRover instance: ${error.message}`, { exit: 1 });
+        }
+    }
+    if (error instanceof ConnectionError) {
+        errorCallback(`Connection error: ${error.message}`, { exit: 1 });
+    }
+    // Unknown error
+    const message = error instanceof Error ? error.message : String(error);
+    errorCallback(`Unexpected error: ${message}`, { exit: 1 });
+}