byterover-cli 0.3.4 → 0.4.0

package/dist/infra/usecase/status-use-case.d.ts

@@ -0,0 +1,27 @@
+import type { IContextTreeService } from '../../core/interfaces/i-context-tree-service.js';
+import type { IContextTreeSnapshotService } from '../../core/interfaces/i-context-tree-snapshot-service.js';
+import type { IProjectConfigStore } from '../../core/interfaces/i-project-config-store.js';
+import type { ITerminal } from '../../core/interfaces/i-terminal.js';
+import type { ITokenStore } from '../../core/interfaces/i-token-store.js';
+import type { ITrackingService } from '../../core/interfaces/i-tracking-service.js';
+import type { IStatusUseCase } from '../../core/interfaces/usecase/i-status-use-case.js';
+export interface StatusUseCaseOptions {
+    contextTreeService: IContextTreeService;
+    contextTreeSnapshotService: IContextTreeSnapshotService;
+    projectConfigStore: IProjectConfigStore;
+    terminal: ITerminal;
+    tokenStore: ITokenStore;
+    trackingService: ITrackingService;
+}
+export declare class StatusUseCase implements IStatusUseCase {
+    private readonly contextTreeService;
+    private readonly contextTreeSnapshotService;
+    private readonly projectConfigStore;
+    private readonly terminal;
+    private readonly tokenStore;
+    private readonly trackingService;
+    constructor(options: StatusUseCaseOptions);
+    run(options: {
+        cliVersion: string;
+    }): Promise<void>;
+}

package/dist/infra/usecase/status-use-case.js

@@ -0,0 +1,97 @@
+import chalk from 'chalk';
+import { join } from 'node:path';
+import { BRV_DIR, CONTEXT_TREE_DIR } from '../../constants.js';
+import { getErrorMessage } from '../../utils/error-helpers.js';
+export class StatusUseCase {
+    contextTreeService;
+    contextTreeSnapshotService;
+    projectConfigStore;
+    terminal;
+    tokenStore;
+    trackingService;
+    constructor(options) {
+        this.contextTreeService = options.contextTreeService;
+        this.contextTreeSnapshotService = options.contextTreeSnapshotService;
+        this.projectConfigStore = options.projectConfigStore;
+        this.terminal = options.terminal;
+        this.tokenStore = options.tokenStore;
+        this.trackingService = options.trackingService;
+    }
+    async run(options) {
+        this.terminal.log(`CLI Version: ${options.cliVersion}`);
+        try {
+            const token = await this.tokenStore.load();
+            if (token !== undefined && token.isValid()) {
+                this.terminal.log(`Status: Logged in as ${token.userEmail}`);
+            }
+            else if (token === undefined) {
+                this.terminal.log('Status: Not logged in');
+            }
+            else {
+                this.terminal.log('Status: Session expired (login required)');
+            }
+        }
+        catch (error) {
+            this.terminal.log('Status: Unable to check authentication status');
+            this.terminal.warn(`Warning: ${getErrorMessage(error)}`);
+        }
+        const cwd = process.cwd();
+        this.terminal.log(`Current Directory: ${cwd}`);
+        try {
+            const isInitialized = await this.projectConfigStore.exists();
+            if (isInitialized) {
+                const config = await this.projectConfigStore.read();
+                if (config) {
+                    this.terminal.log(`Project Status: Connected to ${config.teamName}/${config.spaceName}`);
+                }
+                else {
+                    this.terminal.log('Project Status: Configuration file exists but is invalid');
+                }
+            }
+            else {
+                this.terminal.log('Project Status: Not initialized');
+            }
+        }
+        catch (error) {
+            this.terminal.log('Project Status: Unable to read project configuration');
+            this.terminal.warn(`Warning: ${getErrorMessage(error)}`);
+        }
+        // Context tree status
+        try {
+            const contextTreeExists = await this.contextTreeService.exists();
+            if (!contextTreeExists) {
+                this.terminal.log('Context Tree: Not initialized');
+                return;
+            }
+            const hasSnapshot = await this.contextTreeSnapshotService.hasSnapshot();
+            // Auto-create empty snapshot if none exists (all files will show as "added")
+            if (!hasSnapshot) {
+                await this.contextTreeSnapshotService.initEmptySnapshot();
+            }
+            const changes = await this.contextTreeSnapshotService.getChanges();
+            const hasChanges = changes.added.length > 0 || changes.modified.length > 0 || changes.deleted.length > 0;
+            if (!hasChanges) {
+                this.terminal.log('Context Tree: No changes');
+                return;
+            }
+            const contextTreeRelPath = join(BRV_DIR, CONTEXT_TREE_DIR);
+            const formatPath = (file) => join(contextTreeRelPath, file);
+            // Build unified list with status, sort by path ascending
+            const allChanges = [
+                ...changes.modified.map((f) => ({ color: chalk.red, path: f, status: 'modified:' })),
+                ...changes.added.map((f) => ({ color: chalk.red, path: f, status: 'new file:' })),
+                ...changes.deleted.map((f) => ({ color: chalk.red, path: f, status: 'deleted:' })),
+            ].sort((a, b) => a.path.localeCompare(b.path));
+            this.terminal.log('Context Tree Changes:');
+            for (const change of allChanges) {
+                this.terminal.log(`\t${change.color(`${change.status.padEnd(10)} ${formatPath(change.path)}`)}`);
+            }
+            // Track status
+            await this.trackingService.track('mem:status');
+        }
+        catch (error) {
+            this.terminal.log('Context Tree: Unable to check status');
+            this.terminal.warn(`Warning: ${error instanceof Error ? error.message : 'Context Tree unable to check status'}`);
+        }
+    }
+}

package/dist/infra/workspace/workspace-detector-service.d.ts

@@ -1,13 +1,10 @@
-import { Agent } from '../../core/domain/entities/agent.js';
-export type WorkspaceInfo = {
-    chatLogPath: string;
-    cwd: string;
-};
+import type { Agent } from '../../core/domain/entities/agent.js';
+import type { IWorkspaceDetectorService, WorkspaceInfo } from '../../core/interfaces/i-workspace-detector-service.js';
 /**
  * Service to detect IDE workspaces that contain the current working directory
  * Supports: VS Code (Github Copilot), Cursor, Claude, and Codex
  */
-export declare class WorkspaceDetectorService {
+export declare class WorkspaceDetectorService implements IWorkspaceDetectorService {
     private readonly claudeUserPath;
     private readonly codexUserPath;
     private readonly cursorUserPath;

package/dist/resources/prompts/curate-context-tree-curation.yml

@@ -2,6 +2,7 @@ description: "context tree curation instructions"
 prompt: |
 
   Your task is to assemble relevant high-level information (context) from the input data which will be saved to the context tree in the following steps.
+  Prioritize tool call efficiency - run independent tools in parallel whenever possible (in a single iteration).
 
   The information should be sufficient to understand what the user has provided to the coding assistant as the important context so that the coding assistant can use it to complete the task at hand. When organizing the context, keep in mind the hierarchical structure with a maximum of 2 levels: domain → topic → subtopic. If subtopics contain complex information, break them into separate topics rather than creating deeper nesting.
 
@@ -16,28 +17,39 @@ prompt: |
 
   After collecting all the information, follow these steps to understand and update the context tree:
 
-  1. **Explore existing context**: Use `glob_files` and `grep_content` to understand the current related context in the context tree. You may use bash commands (e.g., `ls`, `find`) to list directories if necessary to navigate the context tree structure.
+  1. **Detect and read referenced files**:
+     - IMPORTANT: Before proceeding, analyze the user's input content for any file path references (e.g., "implemented in auth.ts", "see config.json", "refer to src/utils/helper.ts")
+     - If there are file references that you must read, use the `read_file` tool to read these files IN PARALLEL (in a single iteration) to gather comprehensive context
+     - Multiple file reads can be done simultaneously - they don't depend on each other
+     - This ensures you have complete information before creating knowledge topics
 
-  2. **Find existing knowledge**: Use `find_knowledge_topics` to retrieve concise information about existing knowledge topics in the context tree that relate to the current domain and text segments.
+  2. **Explore existing context**: Use `glob_files` and `grep_content` to understand the current related context in the context tree. You may use bash commands (e.g., `ls`, `find`) to list directories if necessary to navigate the context tree structure.
 
-  3. **Create or update knowledge**: Once you have gathered all information about:
+  3. **Find existing knowledge**: Use `find_knowledge_topics` to retrieve concise information about existing knowledge topics in the context tree that relate to the current domain and text segments.
+
+  4. **Create or update knowledge**: Once you have gathered all information about:
      - The current domain and text segments from the user's input data
      - The existing context in the context tree
-     Use the `create_knowledge_topic` tool to create new knowledge topics or update existing ones. Ensure that:
+     Use the `curate` tool to create new knowledge topics or update existing ones. Ensure that:
      - The context is well-structured and MUST meet **Context quality requirements**
      - There is no duplication with existing context
      - The information is clear and easy to understand
-     
-  4. **Context quality requirements**: Each context in the `contexts` array must:
-       - Important: Minimum 2-4 sentences per context. Otherwise, DO NOT add that context.
-       - A developer should understand the concept without reading source code
-       - Include names of functions, classes, patterns, or key concepts
 
-       AVOID vague contexts like:
+  5. **Tool Execution Efficiency:**
+     - When multiple tools don't depend on each other's results, execute them in parallel (same iteration)
+     - Example: Reading multiple files can be done in parallel
+     - Example: `detect_domains` and `read_file` operations for different files can run together
+
+  6. **Context quality requirements**: Each context in the `contexts` array must:
+     - Important: Minimum 2-4 sentences per context. Otherwise, DO NOT add that context.
+     - A developer should understand the concept without reading source code
+     - Include names of functions, classes, patterns, or key concepts
+
+   AVOID vague contexts like:
        - "Hook system" 
        - "Error handling" 
 
-       WRITE detailed contexts like:
+   WRITE detailed contexts like:
        - "The hook system allows registering callbacks for lifecycle events. Register hooks using 
         `HookRegistry.register(hookName, callback)` and trigger them with `HookRegistry.trigger(hookName, context)`. Hooks are used to: 
         support async callbacks and are commonly used for: pre/post tool execution, agent lifecycle events, and custom 

package/dist/resources/prompts/query-context-tree-retrieval.yml

@@ -10,15 +10,14 @@ prompt: |
   1. **Understand the query**: Analyze what the user is asking for - which domains, topics, or specific information they need.
 
   2. **Search strategically**:
-     - Use `find_knowledge_topics` to locate relevant topics across domains with pattern matching
+     - Use `find_knowledge_topics` to locate relevant topics across domains with pattern matching. Use the 'path' field for `read_file` tool if you need full content.
      - Use `read_file` to read the full content of relevant context.md files
      - Use `grep_content` to search for specific terms, code snippets, or patterns within context files
      - Use `glob_files` to find files by path patterns if needed
      - For multi-part queries (queries that include words like "and"), use tools in parallel:
       - Use `find_knowledge_topics` and `read_file` multiple times to get all relevant topics and their full content.
       - If ANY of these tools don't depend on each other, try to run them in the same iteration.
-
-     - Consider the context tree structure: `.brv/context-tree/{domain}/{topic}/context.md`
+     - Consider the context tree structure: `.brv/context-tree/{domain}/{topic}/context.md` or `.brv/context-tree/{domain}/{topic}/{subtopic}/context.md`
 
   3. **Read relevant content**:
      - Use `read_file` to read the full content of relevant context.md files
@@ -37,7 +36,7 @@ prompt: |
      - If initial search returns too many results, refine with more specific patterns
      - If search returns no results, try broader patterns or alternative terms
 
-  Available domains in the context tree:
+  Default domains in the context tree (search in .brv/context-tree if users add new domains):
   - `code_style` - Coding standards, style guidelines, quality standards
   - `design` - UI/UX design, component libraries, themes, design systems
   - `structure` - Project structure, architecture, component organization

package/dist/resources/prompts/system-prompt.yml

@@ -19,7 +19,7 @@ prompt: |
   **Context Curation (organizing knowledge):**
   - `detect_domains` - Identify knowledge domains in user input (required first step)
   - `find_knowledge_topics` - Check existing context before creating duplicates
-  - `create_knowledge_topic` - Organize new context into the context tree
+  - `curate` - Organize new context into the context tree
   - Use `grep_content`, `glob_files`, `read_file` to gather information from codebase
 
   **File Modification:**

package/dist/resources/prompts/tool-outputs.yml

@@ -18,13 +18,14 @@ prompts:
     Memory deleted successfully.
 
   detect_domains_output: |
-    Domains detected. Now use create_knowledge_topic to organize them into the context tree.
+    Domains detected. Now use curate to organize them into the context tree.
 
-  create_knowledge_topic_output: |
-    Knowledge topic created successfully.
+  curate_output: |
+    Context tree curated successfully.
     If you detected multiple domains, create topics for the remaining ones.
     Once all domains are organized, your curation task is complete.
 
   find_knowledge_topics_output: |
     Search complete. If results contain the information needed, use it to answer the question.
     Use includeContent or followRelations if the current results are insufficient.
+    If you need the entire content of any detected topic or subtopic, use the exact 'path' field for read_file tool.

package/dist/templates/sections/command-reference.md

@@ -10,6 +10,10 @@
 
 - `CONTEXT`: Knowledge context: patterns, decisions, errors, or insights (triggers autonomous mode, optional)
 
+**Flags:**
+
+- `--files`, `-f`: Include file paths for critical context (max 5 files). Only text/code files from the current project directory are allowed. **CONTEXT argument must come BEFORE this flag.**
+
 **Good examples of context:**
 
 - "Auth uses JWT with 24h expiry. Tokens stored in httpOnly cookies via authMiddleware.ts"
@@ -28,12 +32,20 @@ brv curate
 
 # Autonomous mode - LLM auto-categorizes your context
 brv curate "Auth uses JWT with 24h expiry. Tokens stored in httpOnly cookies via authMiddleware.ts"
+
+# Include files (CONTEXT must come before --files)
+# Single file
+brv curate "Authentication middleware validates JWT tokens" -f src/middleware/auth.ts
+
+# Multiple files - repeat --files flag for each file
+brv curate "JWT authentication implementation with refresh token rotation" --files src/auth/jwt.ts --files docs/auth.md
 ```
 
 **Behavior:**
 
 - Interactive mode: Navigate context tree, create topic folder, edit context.md
 - Autonomous mode: LLM automatically categorizes and places context in appropriate location
+- When `--files` is provided, agent reads files in parallel before creating knowledge topics
 
 **Requirements:** Project must be initialized (`brv init`) and authenticated (`brv login`)
 

package/dist/templates/sections/workflow.md

@@ -8,11 +8,20 @@ Core Rules:
 
 ## Context Tree Guideline
 
-- Be specific (“Use React Query for data fetching in web modules”).
+- Be specific ("Use React Query for data fetching in web modules").
 - Be actionable (clear instruction a future agent/dev can apply).
 - Be contextual (mention module/service, constraints, links to source).
 - Include source (file + lines or commit) when possible.
 
+## Using `brv curate` with Files
+
+When adding complex implementations, use `--files` to include relevant source files (max 5).  Only text/code files from the current project directory are allowed. **CONTEXT argument must come BEFORE --files flag.** For multiple files, repeat the `--files` (or `-f`) flag for each file.
+
+Examples:
+
+- Single file: `brv curate "JWT authentication with refresh token rotation" -f src/auth.ts`
+- Multiple files: `brv curate "Authentication system" --files src/auth/jwt.ts --files src/auth/middleware.ts --files docs/auth.md`
+
 ## CLI Usage Notes
 
 - Use --help on any command to discover flags. Provide exact arguments for the scenario.

package/dist/tui/app.d.ts

@@ -0,0 +1,9 @@
+/**
+ * TUI App - Main Layout
+ *
+ * Two main states:
+ * - Unauthorized: Show login prompt
+ * - Authorized: Show main app with tabs
+ */
+import React from 'react';
+export declare const App: React.FC;

package/dist/tui/app.js

@@ -0,0 +1,26 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+/**
+ * TUI App - Main Layout
+ *
+ * Two main states:
+ * - Unauthorized: Show login prompt
+ * - Authorized: Show main app with tabs
+ */
+import { Box, useStdout } 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 { 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 { 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, {}) }))] }));
+};

package/dist/tui/components/enter-prompt.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Enter Prompt Component
+ *
+ * Displays "Press Enter to {action}" prompt
+ */
+import React from 'react';
+interface EnterPromptProps {
+    action: string;
+    active?: boolean;
+    onEnter?: () => void;
+}
+export declare const EnterPrompt: React.FC<EnterPromptProps>;
+export {};

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

@@ -0,0 +1,15 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * Enter Prompt Component
+ *
+ * Displays "Press Enter to {action}" prompt
+ */
+import { Text, useInput } from 'ink';
+export const EnterPrompt = ({ action, active = true, onEnter }) => {
+    useInput((_input, key) => {
+        if (key.return && active) {
+            onEnter?.();
+        }
+    }, { isActive: active });
+    return (_jsxs(Text, { color: "gray", children: ["Press", ' ', _jsx(Text, { backgroundColor: "cyan", color: "black", children: ' Enter ' }), ' ', "to ", action] }));
+};

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

@@ -0,0 +1,14 @@
+/**
+ * Execution Changes Component
+ *
+ * Displays created and updated file paths from an execution.
+ */
+import React from 'react';
+interface ExecutionChangesProps {
+    /** List of created file paths */
+    created: string[];
+    /** List of updated file paths */
+    updated: string[];
+}
+export declare const ExecutionChanges: React.FC<ExecutionChangesProps>;
+export {};

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

@@ -0,0 +1,15 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+/**
+ * Execution Changes Component
+ *
+ * Displays created and updated file paths from an execution.
+ */
+import { Box, Text } from 'ink';
+import { useTheme } from '../../hooks/index.js';
+export const ExecutionChanges = ({ created, updated }) => {
+    const { theme: { colors }, } = useTheme();
+    if (created.length === 0 && updated.length === 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))) })] }))] }));
+};

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

@@ -0,0 +1,25 @@
+/**
+ * Execution Content Component
+ *
+ * Displays execution content (result or error) with truncation support.
+ */
+import React from 'react';
+/**
+ * Truncate content string to maxLines, returning truncated content and remaining line count.
+ * Accounts for line wrapping when maxCharsPerLine is provided.
+ */
+export declare function truncateContent(content: string, maxLines: number, maxCharsPerLine?: number): {
+    remainingLines: number;
+    totalLines: number;
+    truncatedContent: string;
+};
+interface ExecutionContentProps {
+    /** The content to display */
+    content: string;
+    /** Whether this is error content */
+    isError?: boolean;
+    /** Maximum number of lines before truncation */
+    maxLines: number;
+}
+export declare const ExecutionContent: React.FC<ExecutionContentProps>;
+export {};

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

@@ -0,0 +1,67 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * Execution Content Component
+ *
+ * Displays execution content (result or error) with truncation support.
+ */
+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;
+}
+/**
+ * Truncate content string to maxLines, returning truncated content and remaining line count.
+ * Accounts for line wrapping when maxCharsPerLine is provided.
+ */
+export function truncateContent(content, maxLines, maxCharsPerLine) {
+    const lines = content.split('\n');
+    // Calculate total visual lines (accounting for wrapping)
+    let totalVisualLines = 0;
+    for (const line of lines) {
+        totalVisualLines += maxCharsPerLine ? getVisualLineCount(line, maxCharsPerLine) : 1;
+    }
+    if (totalVisualLines <= maxLines) {
+        return { remainingLines: 0, totalLines: totalVisualLines, truncatedContent: content };
+    }
+    // Build truncated content respecting visual line limit
+    const truncatedLines = [];
+    let visualLineCount = 0;
+    for (const line of lines) {
+        const lineVisualCount = maxCharsPerLine ? getVisualLineCount(line, maxCharsPerLine) : 1;
+        if (visualLineCount + lineVisualCount <= maxLines) {
+            truncatedLines.push(line);
+            visualLineCount += lineVisualCount;
+        }
+        else {
+            // Partial line truncation if needed
+            if (maxCharsPerLine && visualLineCount < maxLines) {
+                const remainingVisualLines = maxLines - visualLineCount;
+                const maxChars = remainingVisualLines * maxCharsPerLine;
+                truncatedLines.push(line.slice(0, maxChars));
+                visualLineCount = maxLines;
+            }
+            break;
+        }
+    }
+    return {
+        remainingLines: totalVisualLines - visualLineCount,
+        totalLines: totalVisualLines,
+        truncatedContent: truncatedLines.join('\n'),
+    };
+}
+export const ExecutionContent = ({ content, isError = false, maxLines }) => {
+    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"] })] }));
+};

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

@@ -0,0 +1,12 @@
+/**
+ * Execution Input Component
+ *
+ * Displays the input text in a bordered box.
+ */
+import React from 'react';
+interface ExecutionInputProps {
+    /** The input text to display */
+    input: string;
+}
+export declare const ExecutionInput: React.FC<ExecutionInputProps>;
+export {};

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

@@ -0,0 +1,16 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+/**
+ * Execution Input Component
+ *
+ * Displays the input text in a bordered box.
+ */
+import { Box, Text, useStdout } from 'ink';
+import { useTheme } from '../../hooks/index.js';
+import { truncateContent } from './execution-content.js';
+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 ? '...' : ''] }) }));
+};

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

@@ -0,0 +1,21 @@
+/**
+ * Execution Progress Component
+ *
+ * Displays tool calls progress with status indicators.
+ * Shows a limited number of items with "... and X more" indicator.
+ */
+import React from 'react';
+import type { ToolCallStatus } from '../../../core/domain/cipher/queue/types.js';
+interface ProgressItem {
+    id: string;
+    status: ToolCallStatus;
+    toolCallName: string;
+}
+interface ExecutionProgressProps {
+    /** Maximum number of items to show (default: 3) */
+    maxItems?: number;
+    /** Array of progress items */
+    progress: ProgressItem[];
+}
+export declare const ExecutionProgress: React.FC<ExecutionProgressProps>;
+export {};

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

@@ -0,0 +1,21 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+/**
+ * Execution Progress Component
+ *
+ * Displays tool calls progress with status indicators.
+ * Shows a limited number of items with "... and X more" indicator.
+ */
+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 }) => {
+    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)))] }));
+};

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

@@ -0,0 +1,13 @@
+/**
+ * Execution Status Component
+ *
+ * Displays the execution status with appropriate spinner and message.
+ */
+import React from 'react';
+import type { ExecutionStatus as ExecutionStatusType } from '../../../core/domain/cipher/queue/types.js';
+interface ExecutionStatusProps {
+    /** The execution status */
+    status: ExecutionStatusType;
+}
+export declare const ExecutionStatus: React.FC<ExecutionStatusProps>;
+export {};

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

@@ -0,0 +1,19 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * Execution Status Component
+ *
+ * Displays the execution status with appropriate spinner and message.
+ */
+import { Text } from 'ink';
+import Spinner from 'ink-spinner';
+import { useTheme } from '../../hooks/index.js';
+export const ExecutionStatus = ({ status }) => {
+    const { theme: { colors }, } = useTheme();
+    if (status === 'running') {
+        return (_jsxs(Text, { color: colors.dimText, children: [_jsx(Spinner, { type: "line" }), " Processing..."] }));
+    }
+    if (status === 'queued') {
+        return (_jsxs(Text, { color: colors.dimText, children: [_jsx(Spinner, { type: "dots" }), " Queued..."] }));
+    }
+    return null;
+};

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

@@ -0,0 +1,11 @@
+/**
+ * Execution Components
+ *
+ * Reusable components for displaying execution state (tool calls, progress, content).
+ */
+export { ExecutionChanges } from './execution-changes.js';
+export { ExecutionContent, truncateContent } from './execution-content.js';
+export { ExecutionInput } from './execution-input.js';
+export { ExecutionProgress } from './execution-progress.js';
+export { ExecutionStatus } from './execution-status.js';
+export { LogItem } from './log-item.js';