byterover-cli 0.3.5 → 0.4.1

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

@@ -0,0 +1,451 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * Command View
+ *
+ * Main view with slash command input and streaming output support.
+ * Uses ScrollableList for message history with dynamic height calculation.
+ */
+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;
+/** 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)
+ */
+function countOutputLines(messages) {
+    let total = 0;
+    for (const msg of messages) {
+        total += msg.content.split('\n').length;
+    }
+    return total;
+}
+/**
+ * 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
+ */
+function getMessagesFromEnd(messages, maxLines) {
+    const totalLines = countOutputLines(messages);
+    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--) {
+        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
+            displayMessages.unshift(msg);
+            lineCount += 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;
+            }
+            break;
+        }
+    }
+    // Ensure we show at least one line
+    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;
+    }
+    return {
+        displayMessages,
+        skippedLines: totalLines - lineCount,
+        totalLines,
+    };
+}
+/**
+ * Process streaming messages to handle action_start/action_stop pairs
+ * - action_start with matching action_stop: mark as completed with stop message
+ * - action_start without matching action_stop: mark as running (show spinner)
+ * - action_stop messages are filtered out (consumed by their action_start)
+ */
+function processMessagesForActions(messages) {
+    // Build a map of actionId -> action_stop message
+    const stopMessages = new Map();
+    for (const msg of messages) {
+        if (msg.type === 'action_stop' && msg.actionId) {
+            stopMessages.set(msg.actionId, msg.content);
+        }
+    }
+    // Process messages, transforming action_start and filtering action_stop
+    const result = [];
+    for (const msg of messages) {
+        if (msg.type === 'action_stop') {
+            // Skip action_stop messages - they're consumed by action_start
+            continue;
+        }
+        if (msg.type === 'action_start' && msg.actionId) {
+            const stopMessage = stopMessages.get(msg.actionId);
+            result.push({
+                ...msg,
+                isActionRunning: stopMessage === undefined,
+                stopMessage,
+            });
+        }
+        else {
+            result.push(msg);
+        }
+    }
+    return result;
+}
+/** Default page size for file selector */
+const INLINE_FILE_SELECTOR_PAGE_SIZE = 7;
+/**
+ * Estimate height of an active prompt
+ */
+function estimatePromptHeight(prompt) {
+    if (!prompt)
+        return 0;
+    switch (prompt.type) {
+        case 'confirm': {
+            // Single line: "? message (Y/n) [input]"
+            return 3;
+        }
+        case 'file_selector': {
+            // Message + path + separator + items + scroll indicator + hint
+            const pageSize = prompt.pageSize ?? INLINE_FILE_SELECTOR_PAGE_SIZE;
+            return 5 + pageSize;
+        }
+        case 'input': {
+            // Message line + optional error line
+            return 3;
+        }
+        case 'search': {
+            // Message line + up to 7 visible choices (or 1 for "No results")
+            // We estimate 7 since we don't know actual results
+            return 3 + INLINE_SEARCH_MAX_ITEMS;
+        }
+        case 'select': {
+            // Message line + choices + optional description (with margin)
+            const hasDescription = prompt.choices.some((c) => c.description);
+            return 1 + prompt.choices.length + (hasDescription ? 2 : 0);
+        }
+        default: {
+            return 4;
+        }
+    }
+}
+/**
+ * Estimate the line height of a command message
+ */
+function estimateMessageHeight(msg, options) {
+    const { isLast = false, maxOutputLines, promptHeight = 0, streamingLines = 0 } = options;
+    let lines = 0;
+    if (msg.type === 'command') {
+        // Command header with left border
+        lines += 1;
+        // 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);
+            // Account for truncation: show max lines + 1 for hint
+            const displayedLines = totalOutputLines <= maxOutputLines ? totalOutputLines : maxOutputLines + 1;
+            // Border top + content + border bottom
+            lines += 2 + displayedLines;
+        }
+        // Live streaming output box (for last message while streaming)
+        if (isLast && (streamingLines > 0 || promptHeight > 0)) {
+            // Border top + streaming content + prompt + border bottom
+            lines += 2 + streamingLines + promptHeight;
+        }
+        // Top margin for non-first items
+        lines += 1;
+    }
+    else {
+        // Other message types (info, error, etc)
+        lines += 2;
+    }
+    return lines;
+}
+export const CommandView = ({ availableHeight }) => {
+    const { exit } = useApp();
+    const { reloadAuth, reloadBrvConfig } = useAuth();
+    const { restart } = useConsumer();
+    const [command, setCommand] = useState('');
+    const [inputKey, setInputKey] = useState(0);
+    const [messages, setMessages] = useState([]);
+    const [streamingMessages, setStreamingMessages] = useState([]);
+    const [activePrompt, setActivePrompt] = useState(null);
+    const [isStreaming, setIsStreaming] = useState(false);
+    const { theme: { colors }, } = useTheme();
+    // Process streaming messages to handle action_start/action_stop pairs
+    const processedStreamingMessages = useMemo(() => processMessagesForActions(streamingMessages), [streamingMessages]);
+    const { handleSlashCommand } = useCommands();
+    const { appendShortcuts, mode, removeShortcuts } = useMode();
+    // Append shortcuts for prompts
+    useEffect(() => {
+        if (activePrompt?.type === 'search' || activePrompt?.type === 'select') {
+            appendShortcuts([{ description: 'select', key: 'enter' }]);
+            return () => {
+                removeShortcuts(['enter']);
+            };
+        }
+    }, [activePrompt?.type, appendShortcuts, removeShortcuts]);
+    const executeCommand = useCallback(async (value) => {
+        const trimmed = value.trim();
+        if (!trimmed)
+            return;
+        // Clear command input immediately
+        setCommand('');
+        setMessages((prev) => [
+            ...prev,
+            {
+                content: '',
+                fromCommand: 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,
+                        type: result.messageType === 'error' ? 'error' : 'info',
+                    },
+                ];
+            });
+        }
+        if (result && result.type === 'quit') {
+            stopQueuePollingService();
+            exit();
+        }
+        if (result && result.type === 'streaming') {
+            setIsStreaming(true);
+            setStreamingMessages([]);
+            const collectedMessages = [];
+            const onMessage = (msg) => {
+                collectedMessages.push(msg);
+                setStreamingMessages((prev) => [...prev, msg]);
+            };
+            const onPrompt = (prompt) => {
+                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
+                setMessages((prev) => {
+                    const updated = [...prev];
+                    const lastIndex = updated.length - 1;
+                    if (lastIndex >= 0 && updated[lastIndex].type === 'command') {
+                        updated[lastIndex] = { ...updated[lastIndex], output: collectedMessages };
+                    }
+                    return updated;
+                });
+                setStreamingMessages([]);
+                setIsStreaming(false);
+                setActivePrompt(null);
+                const needReloadAuth = trimmed.startsWith('/login') || trimmed.startsWith('/logout');
+                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);
+                }
+            }
+        }
+    }, [exit, handleSlashCommand, reloadAuth, restart]);
+    const handleSubmit = useCallback(async (value) => {
+        if (mode === 'console' && !isStreaming)
+            await executeCommand(value);
+    }, [executeCommand, isStreaming, mode]);
+    const handleSelect = useCallback(async (value) => {
+        if (!isStreaming)
+            await executeCommand(value);
+    }, [executeCommand, isStreaming]);
+    const handleInsert = useCallback((value) => {
+        // Don't add space after directories (ends with /) to allow continued navigation
+        const suffix = value.endsWith('/') ? '' : ' ';
+        setCommand(value + suffix);
+        // TRICK: Force TextInput to remount with cursor at the end
+        setInputKey((prev) => prev + 1);
+    }, []);
+    // Handle prompt response
+    const handleSearchResponse = useCallback((value) => {
+        if (activePrompt?.type === 'search') {
+            activePrompt.onResponse(value);
+            setActivePrompt(null);
+        }
+    }, [activePrompt]);
+    const handleConfirmResponse = useCallback((value) => {
+        if (activePrompt?.type === 'confirm') {
+            activePrompt.onResponse(value);
+            setActivePrompt(null);
+        }
+    }, [activePrompt]);
+    const handleSelectResponse = useCallback((value) => {
+        if (activePrompt?.type === 'select') {
+            activePrompt.onResponse(value);
+            setActivePrompt(null);
+        }
+    }, [activePrompt]);
+    const handleInputResponse = useCallback((value) => {
+        if (activePrompt?.type === 'input') {
+            activePrompt.onResponse(value);
+            setActivePrompt(null);
+        }
+    }, [activePrompt]);
+    const handleFileSelectorResponse = useCallback((value) => {
+        if (activePrompt?.type === 'file_selector') {
+            activePrompt.onResponse(value);
+            setActivePrompt(null);
+        }
+    }, [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);
+    // Render streaming message (handles ProcessedMessage for action types)
+    const renderStreamingMessage = useCallback((msg) => {
+        // Handle action messages with spinner
+        if (msg.type === 'action_start') {
+            if (msg.isActionRunning) {
+                // Action is still running - show spinner
+                return (_jsxs(Text, { color: colors.text, children: [_jsx(Spinner, { type: "dots" }), " ", msg.content] }, msg.id));
+            }
+            // Action completed - show with completion message
+            return (_jsxs(Text, { color: colors.text, children: [msg.content, msg.stopMessage ? `... ${msg.stopMessage}` : ''] }, msg.id));
+        }
+        // Regular messages
+        let color = colors.text;
+        if (msg.type === 'error')
+            color = colors.errorText;
+        if (msg.type === 'warning')
+            color = colors.warning;
+        return (_jsx(Text, { color: color, children: msg.content }, msg.id));
+    }, [colors]);
+    // Render active prompt component based on type
+    const renderActivePrompt = useCallback(() => {
+        if (!activePrompt)
+            return null;
+        switch (activePrompt.type) {
+            case 'confirm': {
+                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 }));
+            }
+            case 'input': {
+                return (_jsx(InlineInput, { message: activePrompt.message, onSubmit: handleInputResponse, placeholder: activePrompt.placeholder, validate: activePrompt.validate }));
+            }
+            case 'search': {
+                return (_jsx(InlineSearch, { message: activePrompt.message, onSelect: handleSearchResponse, source: activePrompt.source }));
+            }
+            case 'select': {
+                return (_jsx(InlineSelect, { choices: activePrompt.choices, message: activePrompt.message, onSelect: handleSelectResponse }));
+            }
+            default: {
+                return null;
+            }
+        }
+    }, [
+        activePrompt,
+        handleConfirmResponse,
+        handleFileSelectorResponse,
+        handleInputResponse,
+        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 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))] }));
+                        })(), 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()] }));
+                        })()] }));
+        }
+        return _jsx(MessageItem, { message: msg });
+    }, [
+        activePrompt,
+        colors,
+        isStreaming,
+        maxOutputLines,
+        messages.length,
+        processedStreamingMessages,
+        renderActivePrompt,
+        renderStreamingMessage,
+    ]);
+    const keyExtractor = useCallback((_msg, index) => `msg-${index}`, []);
+    // Height estimator that accounts for live streaming output and prompts
+    const heightEstimator = useCallback((msg, index) => {
+        const isLast = index === messages.length - 1;
+        const isLive = isLast && (isStreaming || activePrompt);
+        return estimateMessageHeight(msg, {
+            isLast,
+            maxOutputLines,
+            promptHeight: isLive ? estimatePromptHeight(activePrompt) : 0,
+            streamingLines: isLive ? streamingMessages.length : 0,
+        });
+    }, [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)] })] })] }));
+};

package/dist/tui/views/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * TUI Views
+ */
+export { CommandView } from './command-view.js';
+export { LoginView } from './login-view.js';
+export { LogsView } from './logs-view.js';

package/dist/tui/views/index.js

@@ -0,0 +1,6 @@
+/**
+ * TUI Views
+ */
+export { CommandView } from './command-view.js';
+export { LoginView } from './login-view.js';
+export { LogsView } from './logs-view.js';

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

@@ -0,0 +1,10 @@
+/**
+ * Login View
+ *
+ * Three states:
+ * 1. Idle: Prompt user to login
+ * 2. Loading: Show spinner and output
+ * 3. Completed: Show output and prompt to continue
+ */
+import React from 'react';
+export declare const LoginView: React.FC;

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

@@ -0,0 +1,30 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * Login View
+ *
+ * Three states:
+ * 1. Idle: Prompt user to login
+ * 2. Loading: Show spinner and output
+ * 3. Completed: Show output and prompt to continue
+ */
+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';
+export const LoginView = () => {
+    const { theme } = useTheme();
+    const { isLoggingIn, login, loginOutput, reloadAuth } = useAuth();
+    const { restart } = useConsumer();
+    const [hasStartedLogin, setHasStartedLogin] = useState(false);
+    // Derive state from props and local state
+    const state = isLoggingIn ? 'loading' : hasStartedLogin ? 'completed' : 'idle';
+    return (_jsxs(Box, { flexDirection: "column", gap: 1, paddingTop: 1, children: [state === 'idle' && _jsx(Text, { children: "You are not logged in." }), state === 'loading' && (_jsxs(Box, { gap: 1, children: [_jsx(Text, { color: "cyan", children: _jsx(Spinner, { type: "dots" }) }), _jsx(Text, { children: "Logging in..." })] })), loginOutput.length > 0 && _jsx(OutputLog, { lines: loginOutput, logColor: theme.colors.text }), state === 'idle' && (_jsx(EnterPrompt, { action: "login", onEnter: () => {
+                    login();
+                    setHasStartedLogin(true);
+                } })), state === 'completed' && _jsx(EnterPrompt, { action: "continue", onEnter: async () => {
+                    await reloadAuth();
+                    await restart();
+                } })] }));
+};

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

@@ -0,0 +1,11 @@
+/**
+ * Logs View
+ *
+ * Activity log display using ScrollableList with dynamic height calculation
+ */
+import React from 'react';
+interface LogsViewProps {
+    availableHeight: number;
+}
+export declare const LogsView: React.FC<LogsViewProps>;
+export {};

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

@@ -0,0 +1,73 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * Logs View
+ *
+ * Activity log display using ScrollableList with dynamic height calculation
+ */
+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 { 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;
+}
+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 keyExtractor = useCallback((log) => log.id, []);
+    // Height estimator that accounts for content truncation
+    const heightEstimator = useCallback((log) => estimateLogHeight(log, maxContentLines), [maxContentLines]);
+    // Show onboarding when project is not initialized
+    if (shouldShowOnboarding) {
+        return _jsx(OnboardingFlow, { availableHeight: scrollableHeight });
+    }
+    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/file-validator.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Validate file for --files flag in brv curate command
+ * Checks:
+ * 1. File exists
+ * 2. File is within project directory (where .brv exists)
+ * 3. File is text/code file (not binary)
+ *
+ * @param filePath - The file path to validate (can be relative, absolute, or tilde)
+ * @param projectRoot - The project root directory (current working directory)
+ * @returns Validation result with normalized path or error message
+ */
+export declare function validateFileForCurate(filePath: string, projectRoot: string): {
+    error?: string;
+    normalizedPath?: string;
+    valid: boolean;
+};