byterover-cli 0.4.1 → 1.0.0

package/dist/resources/tools/list_directory.txt

@@ -0,0 +1,16 @@
+Lists files and directories in a given path with a tree structure.
+
+- The path parameter must be absolute; omit it to use the current workspace directory
+- Automatically ignores common build artifacts: node_modules, dist, .git, __pycache__, etc.
+- You can provide additional ignore patterns via the `ignore` parameter
+- Returns up to 100 files by default (adjustable via `maxResults`)
+- You should generally prefer the glob_files and grep_content tools if you know which directories to search
+- Use this tool to get an overview of a directory structure
+
+Default ignored patterns:
+- node_modules/, dist/, build/, target/, vendor/
+- .git/, .idea/, .vscode/
+- __pycache__/, .venv/, venv/, env/
+- coverage/, .cache/, cache/, logs/, tmp/, temp/
+
+If results are truncated, consider using glob_files with a specific pattern instead.

package/dist/resources/tools/list_memories.txt

@@ -0,0 +1 @@
+List and filter memories from the scratch pad. Returns memories sorted by most recent first. Use this to discover what context has been stored.

package/dist/resources/tools/read_file.txt

@@ -0,0 +1,31 @@
+Reads a file from the local filesystem.
+
+Usage:
+- Accepts both absolute and relative paths (relative paths resolved against working directory)
+- By default, reads up to 2000 lines starting from the beginning of the file
+- You can specify offset (1-based line number) and limit to read specific sections
+- Any lines longer than 2000 characters will be truncated with "..."
+- Results include line numbers in "00001| content" format wrapped in <file> tags
+- If the file is not found, similar filenames will be suggested
+
+Special file handling:
+- Image files (PNG, JPG, GIF, WebP, BMP, ICO): Returned as base64 attachment for multimodal processing
+- PDF files: Returned as base64 attachment
+- Binary files: Rejected with clear error message
+- .env files: Blocked for security (except .env.sample, .env.example, .env.template)
+
+Output:
+- content: File content with line numbers (00001| format) wrapped in <file> tags
+- lines: Number of lines returned
+- totalLines: Total lines in the file
+- truncated: Whether more content is available
+- message: Human-readable status with guidance on how to read more
+- preview: First 20 lines of content (for UI display)
+- attachment: Base64 data for images/PDFs (with mimeType and fileName)
+
+For large files, use offset and limit parameters:
+- First read: offset=1, limit=2000 (default)
+- Continue: offset=2001, limit=2000
+- Read specific section: offset=500, limit=100
+
+If results are truncated, the message will tell you which offset to use next.

package/dist/resources/tools/read_memory.txt

@@ -0,0 +1 @@
+Read a specific memory by ID. Use this to retrieve previously stored context, findings, or intermediate results from the scratch pad.

package/dist/resources/tools/read_todos.txt

@@ -0,0 +1,17 @@
+Read the current todo list for this session.
+
+This tool should be used proactively and frequently to ensure that you are aware of
+the status of the current task list
+
+## Output
+
+- **title**: Count of incomplete todos (e.g., "3 todos")
+- **content**: JSON formatted list of all todos
+- **metadata**: Structured todo data for programmatic access
+
+## Each todo item contains
+
+- **id**: Unique identifier
+- **content**: Task description (imperative form, e.g., "Run tests")
+- **activeForm**: Present continuous form for display (e.g., "Running tests")
+- **status**: pending, in_progress, completed, or cancelled

package/dist/resources/tools/search_history.txt

@@ -0,0 +1 @@
+Search conversation history. Supports searching messages or sessions. Can filter by role and session.

package/dist/resources/tools/task.txt

@@ -0,0 +1,23 @@
+Delegates work to a specialized subagent for complex tasks.
+
+Available Subagents:
+- explore: Fast codebase exploration. Searches files, reads code, finds patterns.
+  Use for: finding implementations, understanding code structure, locating files
+- curate: Creates/updates knowledge topics in the context tree.
+  Use for: storing knowledge after gathering information
+
+Parameters:
+- subagent_type: "explore" or "curate"
+- description: Short task description (3-5 words)
+- prompt: Detailed instructions for the subagent
+- contextTreeOnly: (Optional) If true, restricts to .brv/context-tree/ only
+- session_id: (Optional) Continue existing session
+
+Workflow:
+1. Use explore to find/understand code
+2. Use curate to store findings in context tree
+
+Rules:
+- Provide clear, detailed prompts
+- Subagents cannot call task (no recursion)
+- For context tree queries, use contextTreeOnly=true

package/dist/resources/tools/write_file.txt

@@ -0,0 +1 @@
+Write content to a file. Overwrites existing files. Can optionally create parent directories.

package/dist/resources/tools/write_memory.txt

@@ -0,0 +1 @@
+Write content to agent memory as a scratch pad. Use this to store intermediate results, findings, or context that should persist across tool calls. Memories can be tagged and pinned for easy retrieval.

package/dist/resources/tools/write_todos.txt

@@ -0,0 +1,29 @@
+Use this tool to create and manage a structured task list for the current session. This helps track progress, organize complex tasks, and demonstrate thoroughness to the user.
+
+## When to Use This Tool
+Always use this tool proactively when curating the context tree:
+1. Based on the context that needs to be queried, create a plan
+2. Start with the `glob_files` and `grep_content` tools to examine the current tree structure located at `.brv/context-tree/ related to the context that needs to be curated, such as domains, topics, and subtopics
+3. Read to understand important context if necessary using the `read_file` tool
+4. Run the `curator` tool to determine the necessary operations
+5. Curate using the tools: `write_file` to add, `edit_file` to update or merge, and `bash_exec` to remove context (delete operations) 
+
+## Task States
+- **pending**: Task not yet started
+- **in_progress**: Currently working on (limit to ONE task at a time)
+- **completed**: Task finished successfully
+- **cancelled**: Task no longer needed
+
+## Important Rules
+- ONLY ONE task can be "in_progress" at any time
+- Mark tasks complete IMMEDIATELY after finishing (don't batch completions)
+- Each todo must have a unique **id** for tracking
+- Task descriptions need both forms:
+  - content: Imperative form (e.g., "Run tests")
+  - activeForm: Present continuous form (e.g., "Running tests")
+
+## Todo Item Fields
+- **id**: Unique identifier for the todo item (required)
+- **content**: Imperative description (e.g., "Run tests")
+- **activeForm**: Present continuous form (e.g., "Running tests")
+- **status**: pending, in_progress, completed, or cancelled

package/dist/tui/app.js

@@ -6,21 +6,17 @@ import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-run
  * - Unauthorized: Show login prompt
  * - Authorized: Show main app with tabs
  */
-import { Box, useStdout } from 'ink';
+import { Box } from 'ink';
 import { Footer, Header, TabBar } from './components/index.js';
-import { LAYOUT } from './constants.js';
-import { useAuth, useConsumer } from './contexts/index.js';
-import { useTabNavigation } from './hooks/index.js';
+import { useAuth, useTasks } from './contexts/index.js';
+import { useTabNavigation, useTerminalBreakpoint, useUIHeights } from './hooks/index.js';
 import { CommandView, LoginView, LogsView } from './views/index.js';
 export const App = () => {
-    const { stdout } = useStdout();
-    const terminalHeight = stdout?.rows ?? 24;
-    const terminalWidth = stdout?.columns ?? 80;
-    // Get auth state from context
+    const { columns: terminalWidth, rows: terminalHeight } = useTerminalBreakpoint();
+    const { appBottomPadding, footer, header, tab } = useUIHeights();
     const { isAuthorized } = useAuth();
-    // Tab navigation and queue hooks
-    const { activeTab } = useTabNavigation();
-    const { stats } = useConsumer();
-    const contentHeight = Math.max(1, terminalHeight - LAYOUT.headerHeight - LAYOUT.tabBarHeight - LAYOUT.footerHeight);
-    return (_jsxs(Box, { flexDirection: "column", height: terminalHeight, paddingBottom: 1, width: terminalWidth, children: [_jsx(Box, { flexShrink: 0, children: _jsx(Header, { compact: isAuthorized, queueStats: stats ? { pending: stats.queued, processing: stats.running } : undefined, showQueueStats: isAuthorized }) }), isAuthorized ? (_jsxs(_Fragment, { children: [_jsx(Box, { flexShrink: 0, children: _jsx(TabBar, { activeTab: activeTab }) }), _jsxs(Box, { flexGrow: 1, height: contentHeight, paddingX: 1, children: [_jsx(Box, { display: activeTab === 'activity' ? 'flex' : 'none', height: "100%", width: "100%", children: _jsx(LogsView, { availableHeight: contentHeight }) }), _jsx(Box, { display: activeTab === 'console' ? 'flex' : 'none', height: "100%", width: "100%", children: _jsx(CommandView, { availableHeight: contentHeight }) })] }), _jsx(Box, { flexShrink: 0, children: _jsx(Footer, {}) })] })) : (_jsx(Box, { flexGrow: 1, paddingX: 1, children: _jsx(LoginView, {}) }))] }));
+    const { activeTab, tabs } = useTabNavigation();
+    const { stats: taskStats } = useTasks();
+    const contentHeight = Math.max(1, terminalHeight - header - tab - footer);
+    return (_jsxs(Box, { flexDirection: "column", height: terminalHeight, paddingBottom: appBottomPadding, width: terminalWidth, children: [_jsx(Box, { flexShrink: 0, children: _jsx(Header, { compact: isAuthorized, showTransportStats: isAuthorized, taskStats: taskStats }) }), isAuthorized ? (_jsxs(_Fragment, { children: [_jsx(Box, { flexShrink: 0, children: _jsx(TabBar, { activeTab: activeTab, tabs: tabs }) }), _jsxs(Box, { flexGrow: 1, paddingX: 1, children: [_jsx(Box, { display: activeTab === 'activity' ? 'flex' : 'none', height: "100%", width: "100%", children: _jsx(LogsView, { availableHeight: contentHeight }) }), _jsx(Box, { display: activeTab === 'console' ? 'flex' : 'none', height: "100%", width: "100%", children: _jsx(CommandView, { availableHeight: contentHeight }) })] }), _jsx(Box, { flexShrink: 0, children: _jsx(Footer, {}) })] })) : (_jsx(Box, { flexGrow: 1, paddingX: 1, children: _jsx(LoginView, {}) }))] }));
 };

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

@@ -0,0 +1,14 @@
+/**
+ * Command Details Component
+ *
+ * Displays detailed information about a selected command suggestion,
+ * including description, usage, subcommands, arguments, and flags.
+ */
+import React from 'react';
+import type { CommandSuggestion } from '../types.js';
+interface CommandDetailsProps {
+    labelWidth: number;
+    selectedSuggestion: CommandSuggestion | null;
+}
+export declare const CommandDetails: React.FC<CommandDetailsProps>;
+export {};

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

@@ -0,0 +1,35 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+/**
+ * Command Details Component
+ *
+ * Displays detailed information about a selected command suggestion,
+ * including description, usage, subcommands, arguments, and flags.
+ */
+import { Box, Text } from 'ink';
+import { useTheme } from '../contexts/theme-context.js';
+/**
+ * Format usage string from args, flags, and subcommands
+ */
+function formatUsage(label, args, flags, subCommands) {
+    let usage = label;
+    if (subCommands?.length) {
+        usage += ' <subcommand>';
+    }
+    if (args?.length) {
+        const argsStr = args.map((a) => (a.required ? `<${a.name}>` : `[${a.name}]`)).join(' ');
+        usage += ` ${argsStr}`;
+    }
+    if (flags?.length) {
+        const flagsStr = flags.map((f) => `[--${f.name}]`).join(' ');
+        usage += ` ${flagsStr}`;
+    }
+    return usage;
+}
+export const CommandDetails = ({ labelWidth, selectedSuggestion }) => {
+    const { theme: { colors }, } = useTheme();
+    const hasDetails = selectedSuggestion &&
+        (selectedSuggestion.args?.length || selectedSuggestion.flags?.length || selectedSuggestion.subCommands?.length);
+    return (_jsxs(Box, { borderBottom: false, borderColor: colors.border, borderRight: false, borderStyle: "single", borderTop: false, flexDirection: "column", paddingLeft: 1, children: [_jsx(Text, { color: colors.dimText, children: selectedSuggestion?.description || '' }), hasDetails && (_jsxs(_Fragment, { children: [_jsxs(Text, { color: colors.text, children: ["Usage:", ' ', formatUsage(selectedSuggestion.label, selectedSuggestion.args, selectedSuggestion.flags, selectedSuggestion.subCommands)] }), selectedSuggestion.subCommands?.map((sub) => (_jsxs(Text, { color: colors.dimText, children: ['  ', _jsx(Text, { color: colors.text, children: sub.name.padEnd(labelWidth + 2) }), '  ', sub.description] }, sub.name))), selectedSuggestion.args?.map((arg) => (_jsxs(Text, { color: colors.dimText, children: ['  ', _jsx(Text, { color: colors.text, children: (arg.required ? `<${arg.name}>` : `[${arg.name}]`).padEnd(labelWidth + 2) }), '  ', arg.description] }, arg.name))), selectedSuggestion.flags?.map((flag) => (_jsxs(Text, { color: colors.dimText, children: ['  ', _jsx(Text, { color: colors.text, children: (flag.type === 'file'
+                                    ? `${flag.char || '@'}file`
+                                    : (flag.char ? `-${flag.char}, ` : '') + `--${flag.name}`).padEnd(labelWidth + 2) }), '  ', flag.description, flag.default !== undefined && _jsxs(Text, { children: [" (default: ", String(flag.default), ")"] })] }, flag.name)))] }))] }));
+};

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

@@ -7,6 +7,11 @@ import React from 'react';
 interface ExecutionChangesProps {
     /** List of created file paths */
     created: string[];
+    /** Maximum changes configuration */
+    maxChanges?: {
+        created: number;
+        updated: number;
+    };
     /** List of updated file paths */
     updated: string[];
 }

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

@@ -1,4 +1,4 @@
-import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 /**
  * Execution Changes Component
  *
@@ -6,10 +6,25 @@ import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-run
  */
 import { Box, Text } from 'ink';
 import { useTheme } from '../../hooks/index.js';
-export const ExecutionChanges = ({ created, updated }) => {
+export const ExecutionChanges = ({ created, updated, maxChanges = { created: Infinity, updated: Infinity }, }) => {
     const { theme: { colors }, } = useTheme();
-    if (created.length === 0 && updated.length === 0) {
+    const totalChanges = created.length + updated.length;
+    if (totalChanges === 0) {
         return null;
     }
-    return (_jsxs(_Fragment, { children: [created.length > 0 && (_jsxs(Box, { columnGap: 1, children: [_jsx(Text, { color: colors.secondary, children: "created at:" }), _jsx(Box, { flexDirection: "column", children: created.map((path) => (_jsx(Text, { children: path }, path))) })] })), updated.length > 0 && (_jsxs(Box, { columnGap: 1, children: [_jsx(Text, { color: colors.secondary, children: "updated at:" }), _jsx(Box, { flexDirection: "column", children: updated.map((path) => (_jsx(Text, { children: path }, path))) })] }))] }));
+    const hasCreated = created.length > 0;
+    const hasUpdated = updated.length > 0;
+    // Calculate overflow for each section
+    // maxChanges represents total lines (items + indicator if overflow)
+    const createdOverflow = created.length > maxChanges.created;
+    const updatedOverflow = updated.length > maxChanges.updated;
+    // Calculate visible items per section
+    // If overflow, reserve 1 line for indicator, show (maxChanges - 1) items
+    const createdItemsMax = createdOverflow ? maxChanges.created - 1 : maxChanges.created;
+    const updatedItemsMax = updatedOverflow ? maxChanges.updated - 1 : maxChanges.updated;
+    const visibleCreated = created.slice(0, Math.max(0, createdItemsMax));
+    const visibleUpdated = updated.slice(0, Math.max(0, updatedItemsMax));
+    const createdRemaining = created.length - visibleCreated.length;
+    const updatedRemaining = updated.length - visibleUpdated.length;
+    return (_jsxs(Box, { flexDirection: "column", children: [hasCreated && (_jsxs(Box, { columnGap: 1, children: [_jsx(Text, { color: colors.secondary, children: "created at:" }), _jsxs(Box, { flexDirection: "column", children: [visibleCreated.map((path) => (_jsx(Text, { children: path }, path))), createdRemaining > 0 && _jsxs(Text, { color: colors.dimText, children: ["... and ", createdRemaining, " more created"] })] })] })), hasUpdated && (_jsxs(Box, { columnGap: 1, children: [_jsx(Text, { color: colors.secondary, children: "updated at:" }), _jsxs(Box, { flexDirection: "column", children: [visibleUpdated.map((path) => (_jsx(Text, { children: path }, path))), updatedRemaining > 0 && _jsxs(Text, { color: colors.dimText, children: ["... and ", updatedRemaining, " more updated"] })] })] }))] }));
 };

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

@@ -14,12 +14,14 @@ export declare function truncateContent(content: string, maxLines: number, maxCh
     truncatedContent: string;
 };
 interface ExecutionContentProps {
+    /** Bottom margin for this content section */
+    bottomMargin?: number;
     /** The content to display */
     content: string;
     /** Whether this is error content */
     isError?: boolean;
-    /** Maximum number of lines before truncation */
-    maxLines: number;
+    /** Maximum number of lines (rows) this component can use, including the "more lines" indicator */
+    maxLines?: number;
 }
 export declare const ExecutionContent: React.FC<ExecutionContentProps>;
 export {};

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

@@ -6,15 +6,8 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
  */
 import { Box, Text, useStdout } from 'ink';
 import { useTheme } from '../../hooks/index.js';
-/**
- * Calculate visual line count for a single line, accounting for wrapping
- */
-function getVisualLineCount(line, maxCharsPerLine) {
-    if (maxCharsPerLine <= 0 || line.length === 0) {
-        return 1;
-    }
-    return Math.ceil(line.length / maxCharsPerLine) || 1;
-}
+import { getVisualLineCount } from '../../utils/line.js';
+const DEFAULT_MAX_LINES = 5;
 /**
  * Truncate content string to maxLines, returning truncated content and remaining line count.
  * Accounts for line wrapping when maxCharsPerLine is provided.
@@ -49,19 +42,39 @@ export function truncateContent(content, maxLines, maxCharsPerLine) {
             break;
         }
     }
+    // Replace last 3 characters of last line with "..." if truncated
+    let finalContent = truncatedLines.join('\n');
+    if (truncatedLines.length > 0 && totalVisualLines > visualLineCount) {
+        const lastLineIndex = truncatedLines.length - 1;
+        const lastLine = truncatedLines[lastLineIndex];
+        if (lastLine.length >= 3) {
+            truncatedLines[lastLineIndex] = lastLine.slice(0, -3) + '...';
+            finalContent = truncatedLines.join('\n');
+        }
+        else if (lastLine.length > 0) {
+            // If last line is shorter than 3 chars, just replace entirely with "..."
+            truncatedLines[lastLineIndex] = '...';
+            finalContent = truncatedLines.join('\n');
+        }
+    }
     return {
         remainingLines: totalVisualLines - visualLineCount,
         totalLines: totalVisualLines,
-        truncatedContent: truncatedLines.join('\n'),
+        truncatedContent: finalContent,
     };
 }
-export const ExecutionContent = ({ content, isError = false, maxLines }) => {
+export const ExecutionContent = ({ bottomMargin = 1, content, isError = false, maxLines = DEFAULT_MAX_LINES, }) => {
     const { theme: { colors }, } = useTheme();
     const { stdout } = useStdout();
     const contentWidth = (stdout?.columns ?? 80) - 4; // 4 is for padding
     if (!content) {
         return null;
     }
-    const { remainingLines, truncatedContent } = truncateContent(content, maxLines, contentWidth);
-    return (_jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [_jsx(Text, { color: isError ? colors.errorText : colors.text, children: truncatedContent }), remainingLines > 0 && _jsxs(Text, { color: colors.dimText, children: ["\u2195 ", remainingLines, " more lines"] })] }));
+    // First check if content would overflow
+    const { totalLines } = truncateContent(content, maxLines, contentWidth);
+    const hasOverflow = totalLines > maxLines;
+    // If overflow, reserve 1 line for indicator, show (maxLines - 1) lines of content
+    const effectiveMaxLines = hasOverflow ? maxLines - 1 : maxLines;
+    const { remainingLines, truncatedContent } = truncateContent(content, effectiveMaxLines, contentWidth);
+    return (_jsxs(Box, { flexDirection: "column", marginBottom: bottomMargin, children: [_jsx(Text, { color: isError ? colors.errorText : colors.text, children: truncatedContent }), remainingLines > 0 && _jsxs(Text, { color: colors.dimText, children: ["\u2195 ", remainingLines, " more lines"] })] }));
 };

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

@@ -1,4 +1,4 @@
-import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { jsx as _jsx } from "react/jsx-runtime";
 /**
  * Execution Input Component
  *
@@ -11,6 +11,6 @@ export const ExecutionInput = ({ input }) => {
     const { theme: { colors }, } = useTheme();
     const { stdout } = useStdout();
     const contentWidth = (stdout?.columns ?? 80) - 8; // 8 is for padding
-    const { remainingLines, truncatedContent } = truncateContent(input, 1, contentWidth);
-    return (_jsx(Box, { borderColor: colors.border, borderStyle: "single", flexDirection: "column", children: _jsxs(Text, { children: [truncatedContent, remainingLines > 1 ? '...' : ''] }) }));
+    const { truncatedContent } = truncateContent(input, 1, contentWidth);
+    return (_jsx(Box, { borderColor: colors.border, borderStyle: "single", flexDirection: "column", children: _jsx(Text, { children: truncatedContent }) }));
 };

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

@@ -12,8 +12,8 @@ interface ProgressItem {
     toolCallName: string;
 }
 interface ExecutionProgressProps {
-    /** Maximum number of items to show (default: 3) */
-    maxItems?: number;
+    /** Maximum number of lines (rows) this component can use, including hint line (default: 3) */
+    maxLines?: number;
     /** Array of progress items */
     progress: ProgressItem[];
 }

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

@@ -8,14 +8,16 @@ import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
 import { Box, Text } from 'ink';
 import Spinner from 'ink-spinner';
 import { useTheme } from '../../hooks/index.js';
-/** Default maximum number of visible progress items */
-const DEFAULT_MAX_ITEMS = 3;
-export const ExecutionProgress = ({ maxItems = DEFAULT_MAX_ITEMS, progress }) => {
+/** Default maximum number of lines (rows) for progress display */
+const DEFAULT_MAX_LINES = 3;
+export const ExecutionProgress = ({ maxLines = DEFAULT_MAX_LINES, progress }) => {
     const { theme: { colors }, } = useTheme();
     if (!progress || progress.length === 0) {
         return null;
     }
-    const hasMore = progress.length > maxItems;
-    const visibleItems = progress.slice(-maxItems).reverse();
-    return (_jsxs(Box, { flexDirection: "column", children: [hasMore && _jsxs(Text, { color: colors.dimText, children: ["... and ", progress.length - maxItems, " more"] }), visibleItems.map((item) => (_jsxs(Box, { children: [item.status === 'completed' && _jsx(Text, { color: colors.primary, children: "\u2713 " }), item.status === 'running' && (_jsxs(Text, { color: colors.dimText, children: [_jsx(Spinner, { type: "dots" }), ' '] })), item.status === 'failed' && _jsx(Text, { color: colors.errorText, children: "\u2717 " }), _jsx(Text, { color: colors.dimText, children: item.toolCallName })] }, item.id)))] }));
+    const hasMore = progress.length > maxLines;
+    // If there's overflow, reserve 1 line for hint, show (maxLines - 1) items
+    const visibleCount = hasMore ? maxLines - 1 : maxLines;
+    const visibleItems = progress.slice(-visibleCount);
+    return (_jsxs(Box, { flexDirection: "column", children: [hasMore && _jsxs(Text, { color: colors.dimText, children: ["... and ", progress.length - visibleCount, " more tools used"] }), visibleItems.map((item) => (_jsxs(Box, { children: [item.status === 'completed' && _jsx(Text, { color: colors.primary, children: "\u2713 " }), item.status === 'running' && (_jsxs(Text, { color: colors.dimText, children: [_jsx(Spinner, { type: "dots" }), ' '] })), item.status === 'failed' && _jsx(Text, { color: colors.errorText, children: "\u2717 " }), _jsx(Text, { color: colors.dimText, children: item.toolCallName })] }, item.id)))] }));
 };

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

@@ -4,14 +4,13 @@
  * Displays a single activity log entry with header, input, progress, content, and changes.
  */
 import React from 'react';
+import type { MessageItemHeights } from '../../hooks/index.js';
 import type { ActivityLog } from '../../types.js';
 interface LogItemProps {
+    /** Dynamic heights based on terminal breakpoint */
+    heights: MessageItemHeights;
     /** The activity log to display */
     log: ActivityLog;
-    /** Maximum number of content lines before truncation */
-    maxContentLines: number;
-    /** Maximum number of progress items to show (default: 3) */
-    maxProgressItems?: number;
 }
 export declare const LogItem: React.FC<LogItemProps>;
 export {};

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

@@ -11,15 +11,12 @@ import { ExecutionContent } from './execution-content.js';
 import { ExecutionInput } from './execution-input.js';
 import { ExecutionProgress } from './execution-progress.js';
 import { ExecutionStatus } from './execution-status.js';
-/** Default maximum number of visible progress items */
-const DEFAULT_MAX_PROGRESS_ITEMS = 3;
-export const LogItem = ({ log, maxContentLines, maxProgressItems = DEFAULT_MAX_PROGRESS_ITEMS, }) => {
+export const LogItem = ({ heights, log }) => {
     const { theme: { colors }, } = useTheme();
     // Format timestamp as local time HH:MM:SS
     const hours = log.timestamp.getHours().toString().padStart(2, '0');
     const minutes = log.timestamp.getMinutes().toString().padStart(2, '0');
     const seconds = log.timestamp.getSeconds().toString().padStart(2, '0');
     const displayTime = `${hours}:${minutes}:${seconds}`;
-    const displayTools = Math.min(log.progress?.length ?? 0, maxProgressItems) + 1;
-    return (_jsxs(Box, { flexDirection: "column", marginBottom: 1, width: "100%", children: [_jsxs(Box, { children: [_jsxs(Text, { color: log.type === 'curate' ? colors.curateCommand : colors.queryCommand, children: ["[", log.type, "] "] }), _jsxs(Text, { color: colors.dimText, children: ["@", log.source ?? 'system'] }), _jsx(Spacer, {}), _jsxs(Text, { color: colors.dimText, children: ["[", displayTime, "]"] })] }), _jsx(ExecutionInput, { input: log.input }), _jsxs(Box, { flexDirection: "column", children: [log.progress && _jsx(ExecutionProgress, { maxItems: maxProgressItems, progress: log.progress }), _jsx(ExecutionStatus, { status: log.status })] }), (log.status === 'failed' || log.status === 'completed') && (_jsx(ExecutionContent, { content: log.content ?? '', isError: log.status === 'failed', maxLines: maxContentLines - displayTools })), log.status === 'completed' && _jsx(ExecutionChanges, { created: log.changes.created, updated: log.changes.updated })] }));
+    return (_jsxs(Box, { flexDirection: "column", marginBottom: 1, width: "100%", children: [_jsxs(Box, { children: [_jsxs(Text, { color: log.type === 'curate' ? colors.curateCommand : colors.queryCommand, children: ["[", log.type, "] "] }), _jsxs(Text, { color: colors.dimText, children: ["@", log.source ?? 'system'] }), _jsx(Spacer, {}), _jsxs(Text, { color: colors.dimText, children: ["[", displayTime, "]"] })] }), _jsx(ExecutionInput, { input: log.input }), _jsxs(Box, { flexDirection: "column", children: [log.progress && _jsx(ExecutionProgress, { maxLines: heights.maxProgressItems, progress: log.progress }), _jsx(ExecutionStatus, { status: log.status })] }), (log.status === 'failed' || log.status === 'completed') && (_jsx(ExecutionContent, { bottomMargin: heights.contentBottomMargin, content: log.content ?? '', isError: log.status === 'failed', maxLines: heights.maxContentLines })), log.status === 'completed' && (_jsx(ExecutionChanges, { created: log.changes.created, maxChanges: heights.maxChanges, updated: log.changes.updated }))] }));
 };

package/dist/tui/components/footer.js

@@ -3,10 +3,15 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
  * Footer Component - Dynamic based on active tab
  */
 import { Box, Text } from 'ink';
-import { useMode } from '../contexts/use-mode.js';
-import { useTheme } from '../contexts/use-theme.js';
+import { useMemo } from 'react';
+import { useMode } from '../contexts/mode-context.js';
+import { useOnboarding } from '../contexts/onboarding-context.js';
+import { useTheme } from '../contexts/theme-context.js';
 export const Footer = () => {
     const { shortcuts } = useMode();
-    const { theme: { colors } } = useTheme();
-    return (_jsx(Box, { gap: 1, paddingX: 1, width: "100%", children: shortcuts.map((shortcut, index) => (_jsxs(Box, { children: [index > 0 && _jsx(Text, { color: colors.dimText, children: " \u2022  " }), _jsx(Text, { color: colors.text, children: shortcut.key }), _jsxs(Text, { color: colors.dimText, children: [" ", shortcut.description] })] }, shortcut.key))) }));
+    const { shouldShowOnboarding } = useOnboarding();
+    const { theme: { colors }, } = useTheme();
+    // Filter out 'tab' shortcut during onboarding (tab switching is disabled)
+    const visibleShortcuts = useMemo(() => (shouldShowOnboarding ? shortcuts.filter((s) => s.key !== 'tab') : shortcuts), [shortcuts, shouldShowOnboarding]);
+    return (_jsx(Box, { gap: 1, paddingX: 1, width: "100%", children: visibleShortcuts.map((shortcut, index) => (_jsxs(Box, { children: [index > 0 && _jsx(Text, { color: colors.dimText, children: " \u2022 " }), _jsx(Text, { color: colors.text, children: shortcut.key }), _jsxs(Text, { color: colors.dimText, children: [" ", shortcut.description] })] }, shortcut.key))) }));
 };

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

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

package/dist/tui/components/header.js

@@ -9,10 +9,12 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
  */
 import { Box, Spacer, Text } from 'ink';
 import { useServices } from '../contexts/index.js';
-import { useTheme } from '../contexts/use-theme.js';
+import { useTheme } from '../contexts/theme-context.js';
+import { useTerminalBreakpoint } from '../hooks/use-terminal-breakpoint.js';
 import { Logo } from './logo.js';
-export const Header = ({ compact, connectedAgent, queueStats, showQueueStats }) => {
+export const Header = ({ compact, connectedAgent, showTransportStats, taskStats: transportStats }) => {
     const { version } = useServices();
     const { theme } = useTheme();
-    return (_jsxs(Box, { flexDirection: "column", width: "100%", children: [_jsx(Logo, { compact: compact, version: version }), _jsxs(Box, { justifyContent: "space-between", children: [_jsx(Box, { gap: 2, children: connectedAgent && (_jsxs(Box, { children: [_jsx(Text, { color: "green", children: "\u25CF " }), _jsx(Text, { color: "gray", children: connectedAgent })] })) }), showQueueStats && (_jsxs(Box, { paddingRight: 1, children: [_jsx(Spacer, {}), _jsx(Text, { children: "~ in queue: " }), _jsx(Text, { color: theme.colors.warning, children: queueStats?.pending ?? 0 }), _jsx(Text, { children: " | running: " }), _jsx(Text, { color: theme.colors.primary, children: queueStats?.processing ?? 0 })] }))] })] }));
+    const { breakpoint } = useTerminalBreakpoint();
+    return (_jsxs(Box, { flexDirection: "column", width: "100%", children: [_jsx(Logo, { compact: compact, version: version }), _jsxs(Box, { justifyContent: "space-between", children: [_jsxs(Box, { gap: 2, children: [connectedAgent && (_jsxs(Box, { children: [_jsx(Text, { color: "green", children: "\u25CF " }), _jsx(Text, { color: "gray", children: connectedAgent })] })), breakpoint === "compact" && (_jsx(Text, { color: theme.colors.warning, children: "Terminal too small - expand for better experience" }))] }), showTransportStats && (_jsxs(Box, { paddingRight: 1, children: [_jsx(Spacer, {}), _jsx(Text, { children: "~ in queue: " }), _jsx(Text, { color: theme.colors.warning, children: transportStats?.created ?? 0 }), _jsx(Text, { children: " | running: " }), _jsx(Text, { color: theme.colors.primary, children: transportStats?.started ?? 0 })] }))] })] }));
 };

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

@@ -1,6 +1,7 @@
 /**
  * TUI Components
  */
+export { CommandDetails } from './command-details.js';
 export { EnterPrompt } from './enter-prompt.js';
 export { ExecutionChanges, ExecutionContent, ExecutionInput, ExecutionProgress, ExecutionStatus, LogItem, truncateContent, } from './execution/index.js';
 export { Footer } from './footer.js';

package/dist/tui/components/index.js

@@ -1,6 +1,7 @@
 /**
  * TUI Components
  */
+export { CommandDetails } from './command-details.js';
 export { EnterPrompt } from './enter-prompt.js';
 export { ExecutionChanges, ExecutionContent, ExecutionInput, ExecutionProgress, ExecutionStatus, LogItem, truncateContent, } from './execution/index.js';
 export { Footer } from './footer.js';

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

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

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

@@ -1,11 +1,11 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { jsx as _jsx } from "react/jsx-runtime";
 /**
  * Copyable Prompt Component
  *
- * Displays a bordered prompt with keyboard shortcut to copy to clipboard.
+ * Renders a customizable button that copies text to clipboard on ctrl+y.
  * Shows visual feedback when copied.
  */
-import { Box, Text, useInput } from 'ink';
+import { Text, useInput } from 'ink';
 import { execSync } from 'node:child_process';
 import { platform } from 'node:os';
 import { useCallback, useEffect, useState } from 'react';
@@ -37,10 +37,9 @@ function copyToClipboard(text) {
         return false;
     }
 }
-export const CopyablePrompt = ({ isActive = true, prompt }) => {
+export const CopyablePrompt = ({ buttonLabel = 'Press ctrl+y to copy', isActive = true, textToCopy, }) => {
     const { theme: { colors }, } = useTheme();
     const [copied, setCopied] = useState(false);
-    // Reset copied state after 2 seconds
     useEffect(() => {
         if (copied) {
             const timer = setTimeout(() => {
@@ -50,16 +49,16 @@ export const CopyablePrompt = ({ isActive = true, prompt }) => {
         }
     }, [copied]);
     const handleCopy = useCallback(() => {
-        const success = copyToClipboard(prompt);
+        const success = copyToClipboard(textToCopy);
         if (success) {
             setCopied(true);
         }
-    }, [prompt]);
+    }, [textToCopy]);
     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!" })] })] }));
+    return (_jsx(Text, { color: copied ? colors.primary : colors.dimText, children: copied ? "Copied!" : buttonLabel }));
 };