byterover-cli 0.3.5 → 0.4.0

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

@@ -0,0 +1,43 @@
+/**
+ * Adaptive Logo Component
+ *
+ * Renders ASCII logo or text logo based on terminal dimensions.
+ * - Large terminals (>= 60w, >= 20h): Full ASCII logo
+ * - Minimal terminals: Text-only logo
+ */
+import React from 'react';
+interface PaddedLine {
+    content: string;
+    padEnd: string;
+    padStart: string;
+}
+type LogoVariant = 'full' | 'text';
+/**
+ * Select the best logo variant based on terminal size
+ */
+declare function selectLogoVariant(width: number, height: number): LogoVariant;
+/**
+ * Get logo lines for variant
+ */
+declare function getLogoLines(variant: LogoVariant, terminalWidth: number): PaddedLine[];
+interface LogoProps {
+    /**
+     * Compact mode, only show text logo
+     */
+    compact?: boolean;
+    /**
+     * Optional version to display
+     */
+    version?: string;
+}
+/**
+ * Adaptive Logo Component
+ *
+ * Automatically selects the best logo variant based on terminal dimensions.
+ */
+export declare const Logo: React.FC<LogoProps>;
+/**
+ * Export utilities for external use
+ */
+export { getLogoLines, selectLogoVariant };
+export type { LogoVariant };

package/dist/tui/components/logo.js

@@ -0,0 +1,103 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * Adaptive Logo Component
+ *
+ * Renders ASCII logo or text logo based on terminal dimensions.
+ * - Large terminals (>= 60w, >= 20h): Full ASCII logo
+ * - Minimal terminals: Text-only logo
+ */
+import { Box, Text, useStdout } from 'ink';
+import { useMemo } from 'react';
+import { useTheme } from '../hooks/index.js';
+/**
+ * Full ASCII logo "ByteRover" for large terminals
+ */
+const LOGO_FULL = [
+    '░█▀▄░█░█░▀█▀░█▀▀░█▀▄░█▀█░█░█░█▀▀░█▀▄',
+    '░█▀▄░░█░░░█░░█▀▀░█▀▄░█░█░▀▄▀░█▀▀░█▀▄',
+    '░▀▀░░░▀░░░▀░░▀▀▀░▀░▀░▀▀▀░░▀░░▀▀▀░▀░▀',
+];
+const MINI_LOGO = 'brv';
+const PAD_START = '///// ';
+/**
+ * Calculate padding end string to fill remaining width
+ */
+function calculatePadEnd(contentLength, terminalWidth) {
+    const availableWidth = terminalWidth;
+    const padEndLength = availableWidth - PAD_START.length - contentLength - 1;
+    return padEndLength > 0 ? ' ' + '/'.repeat(padEndLength) : '';
+}
+/**
+ * Get header line with BRV and version
+ */
+function getHeaderLine(logoLine, version, terminalWidth) {
+    const logoLength = [...logoLine].length;
+    const brv = '';
+    const versionText = version ? `v${version}` : '';
+    // Spaces between BRV and version to match logo width
+    const spacesLength = logoLength - brv.length - versionText.length;
+    const spaces = spacesLength > 0 ? ' '.repeat(spacesLength) : ' ';
+    const contentLength = brv.length + spaces.length + versionText.length;
+    const padEnd = calculatePadEnd(contentLength, terminalWidth);
+    return { brv, padEnd, padStart: PAD_START, spaces, version: versionText };
+}
+/**
+ * Get padded logo lines with '/' - 5 at start, fill rest to terminal width
+ */
+function getPaddedLogoLines(lines, terminalWidth) {
+    return lines.map((line) => {
+        const lineLength = [...line].length; // Handle unicode characters
+        const padEnd = calculatePadEnd(lineLength, terminalWidth);
+        return { content: line, padEnd, padStart: PAD_START };
+    });
+}
+/**
+ * Select the best logo variant based on terminal size
+ */
+function selectLogoVariant(width, height) {
+    // Full logo needs >= 60 width, >= 20 height
+    if (width >= 60 && height >= 20) {
+        return 'full';
+    }
+    // Fall back to text-only
+    return 'text';
+}
+/**
+ * Get logo lines for variant
+ */
+function getLogoLines(variant, terminalWidth) {
+    switch (variant) {
+        case 'full': {
+            return getPaddedLogoLines(LOGO_FULL, terminalWidth);
+        }
+        default: {
+            return [];
+        }
+    }
+}
+/**
+ * Adaptive Logo Component
+ *
+ * Automatically selects the best logo variant based on terminal dimensions.
+ */
+export const Logo = ({ compact, version }) => {
+    const { stdout } = useStdout();
+    const { theme: { colors }, } = useTheme();
+    const terminalWidth = stdout?.columns ?? 80;
+    const terminalHeight = stdout?.rows ?? 24;
+    const variant = useMemo(() => (compact ? 'text' : selectLogoVariant(terminalWidth, terminalHeight)), [compact, terminalWidth, terminalHeight]);
+    const logoLines = useMemo(() => getLogoLines(variant, terminalWidth), [variant, terminalWidth]);
+    const headerLine = useMemo(() => (variant === 'full' && LOGO_FULL[0] ? getHeaderLine(LOGO_FULL[0], version ?? '', terminalWidth) : null), [variant, version, terminalWidth]);
+    // Text-only logo for minimal terminals
+    if (variant === 'text') {
+        const textContent = MINI_LOGO + (version ? ` v${version}` : '');
+        const padEnd = calculatePadEnd(textContent.length, terminalWidth);
+        return (_jsxs(Box, { children: [_jsx(Text, { color: colors.logoDecor, children: PAD_START }), _jsxs(Text, { children: [_jsx(Text, { bold: true, color: colors.logoBold, children: MINI_LOGO }), version && _jsxs(Text, { color: colors.logoVersion, children: [" v", version] })] }), _jsx(Text, { color: colors.logoDecor, children: padEnd })] }));
+    }
+    // ASCII logo with header line and version
+    return (_jsxs(Box, { flexDirection: "column", children: [headerLine && (_jsxs(Box, { children: [_jsx(Text, { color: colors.logoDecor, children: headerLine.padStart }), _jsxs(Text, { children: [_jsx(Text, { children: headerLine.brv }), _jsx(Text, { children: headerLine.spaces }), _jsx(Text, { color: colors.logoVersion, children: headerLine.version })] }), _jsx(Text, { color: colors.logoDecor, children: headerLine.padEnd })] })), logoLines.map((line, index) => (_jsxs(Box, { children: [_jsx(Text, { color: colors.logoDecor, children: line.padStart }), _jsx(Text, { color: colors.logoBold, children: line.content }), _jsx(Text, { color: colors.logoDecor, children: line.padEnd })] }, index)))] }));
+};
+/**
+ * Export utilities for external use
+ */
+export { getLogoLines, selectLogoVariant };

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

@@ -0,0 +1,12 @@
+/**
+ * MessageItem Component
+ *
+ * Displays a single command message with the command name and result
+ */
+import React from 'react';
+import type { CommandMessage } from '../types.js';
+interface MessageItemProps {
+    message: CommandMessage;
+}
+export declare const MessageItem: React.FC<MessageItemProps>;
+export {};

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

@@ -0,0 +1,12 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * MessageItem Component
+ *
+ * Displays a single command message with the command name and result
+ */
+import { Box, Text } from 'ink';
+import { useTheme } from '../hooks/index.js';
+export const MessageItem = ({ message }) => {
+    const { theme: { colors } } = useTheme();
+    return (_jsxs(Box, { alignItems: "flex-start", flexDirection: "column", marginBottom: 1, children: [_jsxs(Box, { flexDirection: "row", gap: 1, children: [_jsx(Box, { borderBottom: false, borderLeftColor: colors.primary, borderRight: false, borderStyle: "bold", borderTop: false }), _jsx(Text, { children: message.fromCommand })] }), _jsx(Box, { borderColor: colors.border, borderStyle: "single", width: "100%", children: _jsx(Text, { children: message.content }) })] }));
+};

package/dist/tui/components/onboarding/copyable-prompt.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Copyable Prompt Component
+ *
+ * Displays a bordered prompt with keyboard shortcut to copy to clipboard.
+ * Shows visual feedback when copied.
+ */
+import React from 'react';
+interface CopyablePromptProps {
+    /** Whether keyboard input is active for this component */
+    isActive?: boolean;
+    /** The prompt text to display and copy */
+    prompt: string;
+}
+export declare const CopyablePrompt: React.FC<CopyablePromptProps>;
+export {};

package/dist/tui/components/onboarding/copyable-prompt.js

@@ -0,0 +1,65 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * Copyable Prompt Component
+ *
+ * Displays a bordered prompt with keyboard shortcut to copy to clipboard.
+ * Shows visual feedback when copied.
+ */
+import { Box, Text, useInput } from 'ink';
+import { execSync } from 'node:child_process';
+import { platform } from 'node:os';
+import { useCallback, useEffect, useState } from 'react';
+import { useTheme } from '../../hooks/index.js';
+/**
+ * Copy text to clipboard using platform-specific commands
+ */
+function copyToClipboard(text) {
+    try {
+        const os = platform();
+        if (os === 'darwin') {
+            execSync('pbcopy', { input: text });
+        }
+        else if (os === 'win32') {
+            execSync('clip', { input: text });
+        }
+        else {
+            // Linux - try xclip first, then xsel
+            try {
+                execSync('xclip -selection clipboard', { input: text });
+            }
+            catch {
+                execSync('xsel --clipboard --input', { input: text });
+            }
+        }
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export const CopyablePrompt = ({ isActive = true, prompt }) => {
+    const { theme: { colors }, } = useTheme();
+    const [copied, setCopied] = useState(false);
+    // Reset copied state after 2 seconds
+    useEffect(() => {
+        if (copied) {
+            const timer = setTimeout(() => {
+                setCopied(false);
+            }, 2000);
+            return () => clearTimeout(timer);
+        }
+    }, [copied]);
+    const handleCopy = useCallback(() => {
+        const success = copyToClipboard(prompt);
+        if (success) {
+            setCopied(true);
+        }
+    }, [prompt]);
+    useInput((input, key) => {
+        // ctrl+y to copy
+        if (key.ctrl && input === 'y') {
+            handleCopy();
+        }
+    }, { isActive });
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { borderColor: colors.border, borderStyle: "round", paddingX: 1, children: _jsx(Text, { children: prompt }) }), _jsxs(Box, { marginTop: 1, children: [_jsxs(Text, { color: colors.dimText, children: ["Press", ' ', _jsx(Text, { backgroundColor: colors.primary, color: "black", children: ' ctrl+y ' }), ' ', "to copy"] }), copied && _jsx(Text, { color: colors.secondary, children: " Copied!" })] })] }));
+};

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

@@ -0,0 +1,7 @@
+/**
+ * Onboarding Components
+ */
+export { CopyablePrompt } from './copyable-prompt.js';
+export { OnboardingFlow } from './onboarding-flow.js';
+export { OnboardingStep } from './onboarding-step.js';
+export type { OnboardingStepType } from './onboarding-step.js';

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

@@ -0,0 +1,6 @@
+/**
+ * Onboarding Components
+ */
+export { CopyablePrompt } from './copyable-prompt.js';
+export { OnboardingFlow } from './onboarding-flow.js';
+export { OnboardingStep } from './onboarding-step.js';

package/dist/tui/components/onboarding/onboarding-flow.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Onboarding Flow Component
+ *
+ * Main container for the onboarding flow.
+ * Handles step transitions and init command execution.
+ */
+import React from 'react';
+interface OnboardingFlowProps {
+    /** Available height for the onboarding flow */
+    availableHeight: number;
+}
+export declare const OnboardingFlow: React.FC<OnboardingFlowProps>;
+export {};

package/dist/tui/components/onboarding/onboarding-flow.js

@@ -0,0 +1,304 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * Onboarding Flow Component
+ *
+ * Main container for the onboarding flow.
+ * Handles step transitions and init command execution.
+ */
+import { Box, Text, useInput } from 'ink';
+import Spinner from 'ink-spinner';
+import { useCallback, useMemo, useState } from 'react';
+import { useAuth } from '../../contexts/auth-context.js';
+import { useConsumer } from '../../contexts/index.js';
+import { useActivityLogs, useCommands, useMode, useTheme } from '../../hooks/index.js';
+import { useOnboarding } from '../../hooks/use-onboarding.js';
+import { EnterPrompt } from '../enter-prompt.js';
+import { LogItem } from '../execution/index.js';
+import { InlineConfirm, InlineInput, InlineSearch, InlineSelect } from '../inline-prompts/index.js';
+import { CopyablePrompt } from './copyable-prompt.js';
+import { OnboardingStep } from './onboarding-step.js';
+/** Example prompts for curate and query steps */
+const CURATE_PROMPT = 'brv curate "Auth uses JWT with 24h expiry. Tokens stored in httpOnly cookies"';
+const QUERY_PROMPT = 'brv query "How is authentication implemented?"';
+/** Minimum output lines to show before truncation */
+const MIN_OUTPUT_LINES = 3;
+/** Reserved lines for onboarding step (title + description + borders + margins + onboard title + onboard description + content margin top) */
+const ONBOARDING_STEP_OVERHEAD = 8;
+/** Reserved lines for onboarding curate/query (content margin bottom + 1 line + prompt 'enter' to continue) */
+const ONBOARDING_CURATE_QUERY_OVER_BOTTOM = 3;
+/** Reserved lines for inline search (message + input + margins) */
+const INLINE_SEARCH_OVERHEAD = 3;
+/** Minimum visible items for inline search */
+const MIN_SEARCH_ITEMS = 3;
+/**
+ * Count the total number of lines in streaming messages
+ */
+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
+ */
+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) {
+            displayMessages.unshift(msg);
+            lineCount += msgLineCount;
+        }
+        else {
+            const remainingSpace = maxLines - lineCount;
+            if (remainingSpace > 0) {
+                const truncatedContent = msgLineArray.slice(-remainingSpace).join('\n');
+                displayMessages.unshift({
+                    ...msg,
+                    content: truncatedContent,
+                });
+                lineCount += remainingSpace;
+            }
+            break;
+        }
+    }
+    return {
+        displayMessages,
+        skippedLines: totalLines - lineCount,
+        totalLines,
+    };
+}
+/**
+ * Process streaming messages to handle action_start/action_stop pairs
+ */
+function processMessagesForActions(messages) {
+    const stopMessages = new Map();
+    for (const msg of messages) {
+        if (msg.type === 'action_stop' && msg.actionId) {
+            stopMessages.set(msg.actionId, msg.content);
+        }
+    }
+    const result = [];
+    for (const msg of messages) {
+        if (msg.type === 'action_stop') {
+            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;
+}
+/** Get step number for display */
+function getStepNumber(step) {
+    switch (step) {
+        case 'curate': {
+            return 2;
+        }
+        case 'init': {
+            return 1;
+        }
+        case 'query': {
+            return 3;
+        }
+        default: {
+            return 3;
+        }
+    }
+}
+export const OnboardingFlow = ({ availableHeight }) => {
+    const { theme: { colors }, } = useTheme();
+    const { mode } = useMode();
+    const { reloadAuth } = useAuth();
+    const { restart } = useConsumer();
+    const { handleSlashCommand } = useCommands();
+    const { completeOnboarding, curateAcknowledged, currentStep, hasCurated, hasQueried, queryAcknowledged, setCurateAcknowledged, setQueryAcknowledged, totalSteps, } = useOnboarding();
+    const { logs } = useActivityLogs();
+    // Calculate max output lines based on available height
+    // Reserve space for onboarding step title, description, borders, and margins
+    const maxOutputLines = Math.max(MIN_OUTPUT_LINES, availableHeight - ONBOARDING_STEP_OVERHEAD - ONBOARDING_CURATE_QUERY_OVER_BOTTOM);
+    // Calculate max visible items for inline search based on available height
+    const maxSearchItems = Math.max(MIN_SEARCH_ITEMS, maxOutputLines - INLINE_SEARCH_OVERHEAD);
+    // Find running or queued curate/query logs
+    const curateLog = useMemo(() => logs.find((log) => log.type === 'curate'), [logs]);
+    const queryLog = useMemo(() => logs.find((log) => log.type === 'query'), [logs]);
+    // Streaming state for init command
+    const [isRunningInit, setIsRunningInit] = useState(false);
+    const [streamingMessages, setStreamingMessages] = useState([]);
+    const [activePrompt, setActivePrompt] = useState(null);
+    const [initError, setInitError] = useState(null);
+    // Determine if we're in a skippable waiting state (curate/query without active log)
+    const isInWaitingState = mode === 'activity' && ((currentStep === 'curate' && !curateLog) || (currentStep === 'query' && !queryLog));
+    // Handle escape key to skip onboarding
+    useInput((_input, key) => {
+        if (key.escape) {
+            completeOnboarding(true); // Pass true to indicate skipped
+        }
+    }, { isActive: isInWaitingState });
+    // Handle init command execution
+    const runInit = useCallback(async () => {
+        if (isRunningInit)
+            return;
+        setIsRunningInit(true);
+        setStreamingMessages([]);
+        setInitError(null);
+        const result = await handleSlashCommand('/init');
+        if (result && result.type === 'streaming') {
+            const onMessage = (msg) => {
+                setStreamingMessages((prev) => [...prev, msg]);
+                setInitError(msg.type === 'error' ? msg.content : null);
+            };
+            const onPrompt = (prompt) => {
+                setActivePrompt(prompt);
+            };
+            try {
+                await result.execute(onMessage, onPrompt);
+                // Reload auth to detect config change
+                await reloadAuth();
+                // Restart consumer to pick up new project state
+                await restart();
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                setInitError(errorMessage);
+            }
+            finally {
+                setIsRunningInit(false);
+                setActivePrompt(null);
+            }
+        }
+        else if (result && result.type === 'message') {
+            setInitError(result.content);
+            setIsRunningInit(false);
+        }
+    }, [handleSlashCommand, isRunningInit, reloadAuth, restart]);
+    // Process streaming messages to handle action_start/action_stop pairs
+    const processedStreamingMessages = useMemo(() => processMessagesForActions(streamingMessages), [streamingMessages]);
+    // Render streaming message with proper styling
+    const renderStreamingMessage = useCallback((msg) => {
+        // Handle action messages with spinner
+        if (msg.type === 'action_start') {
+            if (msg.isActionRunning) {
+                return (_jsxs(Text, { color: colors.text, children: [_jsx(Spinner, { type: "dots" }), " ", msg.content] }, msg.id));
+            }
+            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]);
+    // Prompt response handlers
+    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]);
+    // Render active prompt
+    const renderActivePrompt = useCallback(() => {
+        if (!activePrompt)
+            return null;
+        switch (activePrompt.type) {
+            case 'confirm': {
+                return (_jsx(InlineConfirm, { default: activePrompt.default, message: activePrompt.message, onConfirm: handleConfirmResponse }));
+            }
+            case 'input': {
+                return (_jsx(InlineInput, { message: activePrompt.message, onSubmit: handleInputResponse, placeholder: activePrompt.placeholder, validate: activePrompt.validate }));
+            }
+            case 'search': {
+                return (_jsx(InlineSearch, { maxVisibleItems: maxSearchItems, 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 init step content
+    const renderInitContent = () => {
+        if (isRunningInit) {
+            const { displayMessages: liveMessages, skippedLines } = getMessagesFromEnd(processedStreamingMessages, maxOutputLines);
+            return (_jsx(Box, { flexDirection: "column", width: "100%", children: _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)), renderActivePrompt()] }) }));
+        }
+        if (initError) {
+            return (_jsxs(Box, { flexDirection: "column", rowGap: 1, children: [_jsxs(Text, { color: colors.errorText, children: ["Error: ", initError] }), _jsx(EnterPrompt, { action: "try again", active: mode === 'activity' && currentStep === 'init' && !isRunningInit && !activePrompt, onEnter: runInit })] }));
+        }
+        return (_jsx(EnterPrompt, { action: "initialize your project", active: mode === 'activity' && currentStep === 'init' && !isRunningInit && !activePrompt, onEnter: runInit }));
+    };
+    // Render curate step content
+    const renderCurateContent = () => {
+        // Show execution progress if curate is running
+        if (curateLog) {
+            return (_jsxs(Box, { flexDirection: "column", width: "100%", children: [_jsx(LogItem, { log: curateLog, maxContentLines: maxOutputLines }), hasCurated && !curateAcknowledged && (_jsx(EnterPrompt, { action: "continue", active: mode === 'activity' && currentStep === 'curate', onEnter: () => setCurateAcknowledged(true) }))] }));
+        }
+        // Show copyable prompt when waiting
+        return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { color: colors.dimText, wrap: "wrap", children: "Copy this command and paste it to your AI agent:" }), _jsx(CopyablePrompt, { isActive: mode === 'activity' && currentStep === 'curate', prompt: CURATE_PROMPT }), _jsxs(Box, { marginTop: 1, children: [_jsxs(Text, { color: colors.dimText, children: [_jsx(Spinner, { type: "dots" }), " Waiting for curate..."] }), _jsx(Text, { color: colors.dimText, children: " (Press Esc to skip)" })] })] }));
+    };
+    // Render query step content
+    const renderQueryContent = () => {
+        // Show execution progress if query is running
+        if (queryLog) {
+            return (_jsxs(Box, { flexDirection: "column", width: "100%", children: [_jsx(LogItem, { log: queryLog, maxContentLines: maxOutputLines }), hasQueried && !queryAcknowledged && (_jsx(EnterPrompt, { action: "continue", active: mode === 'activity' && currentStep === 'query', onEnter: () => setQueryAcknowledged(true) }))] }));
+        }
+        // Show copyable prompt when waiting
+        return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { color: colors.dimText, wrap: "wrap", children: "Copy this command and paste it to your AI agent:" }), _jsx(CopyablePrompt, { isActive: mode === 'activity' && currentStep === 'query', prompt: QUERY_PROMPT }), _jsxs(Box, { marginTop: 1, children: [_jsxs(Text, { color: colors.dimText, children: [_jsx(Spinner, { type: "dots" }), " Waiting for query..."] }), _jsx(Text, { color: colors.dimText, children: " (Press Esc to skip)" })] })] }));
+    };
+    // Render complete step content
+    const renderCompleteContent = () => (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { color: colors.dimText, wrap: "wrap", children: "Activity logs will appear here as you use brv curate and brv query." }), _jsxs(Box, { flexDirection: "column", marginY: 1, children: [_jsx(Text, { color: colors.dimText, children: "Tips:" }), _jsx(Text, { color: colors.dimText, children: "- Press [Tab] to switch to commands view" }), _jsx(Text, { color: colors.dimText, children: "- Use /push to sync your context to the cloud" }), _jsx(Text, { color: colors.dimText, children: "- Use /gen-rules to generate agent rules" }), _jsx(Text, { color: colors.dimText, children: "- Type / for available commands" })] }), _jsx(EnterPrompt, { action: "finish onboarding", active: mode === 'activity' && currentStep === 'complete', onEnter: () => completeOnboarding() })] }));
+    return (_jsx(Box, { borderColor: colors.border, borderLeft: false, borderRight: false, borderStyle: "single", borderTop: false, flexDirection: "column", height: availableHeight, width: "100%", children: _jsxs(Box, { flexDirection: "column", paddingX: 1, children: [currentStep === 'init' && (_jsx(OnboardingStep, { description: "Let's get your project set up with ByteRover.", stepNumber: getStepNumber('init'), title: "Welcome to ByteRover!", totalSteps: totalSteps, children: renderInitContent() })), currentStep === 'curate' && (_jsx(OnboardingStep, { description: "Great! Now let's add some context to your knowledge base.", stepNumber: getStepNumber('curate'), title: "Add Your First Context", totalSteps: totalSteps, children: renderCurateContent() })), currentStep === 'query' && (_jsx(OnboardingStep, { description: "Excellent! Your context is saved. Let's query it.", stepNumber: getStepNumber('query'), title: "Query Your Knowledge", totalSteps: totalSteps, children: renderQueryContent() })), currentStep === 'complete' && (_jsx(OnboardingStep, { description: "Your ByteRover workspace is ready!", showStepIndicator: false, stepNumber: totalSteps, title: "You're All Set!", totalSteps: totalSteps, children: renderCompleteContent() }))] }) }));
+};

package/dist/tui/components/onboarding/onboarding-step.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Onboarding Step Component
+ *
+ * Displays an individual onboarding step with title, description, and content.
+ */
+import React from 'react';
+export type OnboardingStepType = 'complete' | 'curate' | 'init' | 'query';
+interface OnboardingStepProps {
+    /** Child content to render */
+    children?: React.ReactNode;
+    /** Step description */
+    description: string;
+    /** Whether to show step indicator (default: true) */
+    showStepIndicator?: boolean;
+    /** Current step number (1-indexed) */
+    stepNumber: number;
+    /** Step title */
+    title: string;
+    /** Total number of steps */
+    totalSteps: number;
+}
+export declare const OnboardingStep: React.FC<OnboardingStepProps>;
+export {};

package/dist/tui/components/onboarding/onboarding-step.js

@@ -0,0 +1,12 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+/**
+ * Onboarding Step Component
+ *
+ * Displays an individual onboarding step with title, description, and content.
+ */
+import { Box, Text } from 'ink';
+import { useTheme } from '../../hooks/index.js';
+export const OnboardingStep = ({ children, description, showStepIndicator = true, stepNumber, title, totalSteps, }) => {
+    const { theme: { colors }, } = useTheme();
+    return (_jsxs(Box, { flexDirection: "column", paddingX: 2, children: [_jsxs(Text, { bold: true, color: colors.primary, children: [title, ' ', showStepIndicator && (_jsxs(Text, { color: colors.dimText, children: ["(", stepNumber, "/", totalSteps, ")"] }))] }), _jsx(Text, { children: description }), children && _jsx(Box, { marginTop: 1, children: children })] }));
+};

package/dist/tui/components/output-log.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Output Log Component
+ *
+ * Displays command output lines without causing flickering.
+ * Uses a simple Box instead of Static to avoid re-render issues.
+ */
+import React from 'react';
+interface OutputLogProps {
+    lines: string[];
+    logColor?: string;
+    maxLines?: number;
+}
+export declare const OutputLog: React.FC<OutputLogProps>;
+export {};

package/dist/tui/components/output-log.js

@@ -0,0 +1,13 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/**
+ * Output Log Component
+ *
+ * Displays command output lines without causing flickering.
+ * Uses a simple Box instead of Static to avoid re-render issues.
+ */
+import { Box, Text } from 'ink';
+export const OutputLog = ({ lines, logColor, maxLines = 10 }) => {
+    // Show only the last N lines to prevent overflow
+    const visibleLines = lines.slice(-maxLines);
+    return (_jsx(Box, { flexDirection: "column", children: visibleLines.map((line, index) => (_jsx(Text, { color: logColor, children: line }, `${lines.length - maxLines + index}-${line.slice(0, 20)}`))) }));
+};