byterover-cli 1.8.0 → 2.1.0

package/dist/tui/contexts/services-context.d.ts

@@ -1,32 +0,0 @@
-/**
- * Services Context
- *
- * Provides dependency injection for stores and app config.
- * This context is stable - values don't change during the app lifecycle.
- */
-import React from 'react';
-import type { ITokenStore } from '../../server/core/interfaces/auth/i-token-store.js';
-import type { IConnectorManager } from '../../server/core/interfaces/connectors/i-connector-manager.js';
-import type { ITrackingService } from '../../server/core/interfaces/services/i-tracking-service.js';
-import type { IOnboardingPreferenceStore } from '../../server/core/interfaces/storage/i-onboarding-preference-store.js';
-import type { IProjectConfigStore } from '../../server/core/interfaces/storage/i-project-config-store.js';
-export interface ServicesContextValue {
-    connectorManager: IConnectorManager;
-    onboardingPreferenceStore: IOnboardingPreferenceStore;
-    projectConfigStore: IProjectConfigStore;
-    tokenStore: ITokenStore;
-    trackingService: ITrackingService;
-    version: string;
-}
-interface ServicesProviderProps {
-    children: React.ReactNode;
-    connectorManager: IConnectorManager;
-    onboardingPreferenceStore: IOnboardingPreferenceStore;
-    projectConfigStore: IProjectConfigStore;
-    tokenStore: ITokenStore;
-    trackingService: ITrackingService;
-    version: string;
-}
-export declare function ServicesProvider({ children, connectorManager, onboardingPreferenceStore, projectConfigStore, tokenStore, trackingService, version, }: ServicesProviderProps): React.ReactElement;
-export declare function useServices(): ServicesContextValue;
-export {};

package/dist/tui/contexts/services-context.js

@@ -1,27 +0,0 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-/**
- * Services Context
- *
- * Provides dependency injection for stores and app config.
- * This context is stable - values don't change during the app lifecycle.
- */
-import { createContext, useContext, useMemo } from 'react';
-const ServicesContext = createContext(undefined);
-export function ServicesProvider({ children, connectorManager, onboardingPreferenceStore, projectConfigStore, tokenStore, trackingService, version, }) {
-    const value = useMemo(() => ({
-        connectorManager,
-        onboardingPreferenceStore,
-        projectConfigStore,
-        tokenStore,
-        trackingService,
-        version,
-    }), [connectorManager, onboardingPreferenceStore, projectConfigStore, tokenStore, trackingService, version]);
-    return _jsx(ServicesContext.Provider, { value: value, children: children });
-}
-export function useServices() {
-    const context = useContext(ServicesContext);
-    if (!context) {
-        throw new Error('useServices must be used within ServicesProvider');
-    }
-    return context;
-}

package/dist/tui/contexts/tasks-context.d.ts

@@ -1,101 +0,0 @@
-import type { TaskErrorData, ToolErrorType } from '@campfirein/brv-transport-client';
-import React from 'react';
-import { TaskStats } from '../types/ui.js';
-/**
- * Task status derived from task lifecycle events.
- */
-export type TaskStatus = 'cancelled' | 'completed' | 'created' | 'error' | 'started';
-/**
- * Tool call tracking with status from toolResult.
- */
-export type ToolCallEvent = {
-    args: Record<string, unknown>;
-    callId?: string;
-    error?: string;
-    errorType?: ToolErrorType;
-    result?: unknown;
-    sessionId: string;
-    status: 'completed' | 'error' | 'running';
-    timestamp: number;
-    toolName: string;
-};
-/**
- * Reasoning content item with timestamp for sorting.
- */
-export type ReasoningContentItem = {
-    content: string;
-    isThinking?: boolean;
-    timestamp: number;
-};
-/**
- * Task data aggregated from transport events.
- */
-export type Task = {
-    /** Task completion timestamp */
-    completedAt?: number;
-    /** Task content/prompt */
-    content: string;
-    /** Task creation timestamp */
-    createdAt: number;
-    /** Error data if task failed */
-    error?: TaskErrorData;
-    /** File paths for curate --files */
-    files?: string[];
-    /** Folder paths for curate-folder */
-    folders?: string[];
-    /** Input of query/curate */
-    input: string;
-    /** Whether task is currently streaming LLM response */
-    isStreaming?: boolean;
-    /** Accumulated reasoning/thinking content items with timestamps */
-    reasoningContents?: ReasoningContentItem[];
-    /** Result string if task completed */
-    result?: string;
-    /** Session ID from LLM events */
-    sessionId?: string;
-    /** Task start timestamp */
-    startedAt?: number;
-    /** Current task status */
-    status: TaskStatus;
-    /** Accumulated streaming text content during LLM response */
-    streamingContent?: string;
-    /** Unique task identifier */
-    taskId: string;
-    /** Tool calls executed during task */
-    toolCalls: ToolCallEvent[];
-    /** Task type */
-    type: 'curate' | 'curate-folder' | 'query';
-};
-/**
- * Context value for tasks state.
- */
-export type TasksContextValue = {
-    /** Clear all tasks from memory */
-    clearTasks: () => void;
-    /** Get a specific task by ID */
-    getTask: (taskId: string) => Task | undefined;
-    /** Transport statistics */
-    stats: TaskStats;
-    /** Map of all tasks by taskId */
-    tasks: Map<string, Task>;
-};
-/**
- * Provider component that subscribes to task events and maintains task state.
- * Tracks task lifecycle and LLM tool calls for all tasks.
- *
- * Event Flow:
- * 1. task:created → Create task with 'created' status
- * 2. task:started → Update to 'started' status
- * 3. llmservice:toolCall → Add tool call with 'running' status
- * 4. llmservice:toolResult → Update tool call status to 'completed' or 'error'
- * 5. llmservice:response → Update task result content from LLM response
- * 6. task:completed | task:error | task:cancelled → Terminal state
- */
-export declare function TasksProvider({ children }: {
-    children: React.ReactNode;
-}): React.ReactElement;
-/**
- * Hook to access tasks context.
- * Must be used within a TasksProvider.
- */
-export declare function useTasks(): TasksContextValue;

package/dist/tui/contexts/tasks-context.js

@@ -1,422 +0,0 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-import { createContext, useCallback, useContext, useEffect, useMemo, useState } from 'react';
-import { useTransport } from './transport-context.js';
-const TasksContext = createContext(undefined);
-/**
- * Provider component that subscribes to task events and maintains task state.
- * Tracks task lifecycle and LLM tool calls for all tasks.
- *
- * Event Flow:
- * 1. task:created → Create task with 'created' status
- * 2. task:started → Update to 'started' status
- * 3. llmservice:toolCall → Add tool call with 'running' status
- * 4. llmservice:toolResult → Update tool call status to 'completed' or 'error'
- * 5. llmservice:response → Update task result content from LLM response
- * 6. task:completed | task:error | task:cancelled → Terminal state
- */
-export function TasksProvider({ children }) {
-    const { client } = useTransport();
-    const [tasks, setTasks] = useState(new Map());
-    useEffect(() => {
-        if (!client)
-            return;
-        const unsubscribers = [];
-        // Handle task:created - Initialize new task
-        // Extended type to include folderPath (not yet in transport-client package)
-        const handleTaskCreated = (data) => {
-            // Convert folderPath to folders array for consistent handling
-            const folders = data.folderPath ? [data.folderPath] : undefined;
-            setTasks((prev) => {
-                const newTasks = new Map(prev);
-                newTasks.set(data.taskId, {
-                    completedAt: undefined,
-                    content: data.content,
-                    createdAt: Date.now(),
-                    error: undefined,
-                    files: data.files,
-                    folders,
-                    input: data.content,
-                    result: undefined,
-                    sessionId: undefined,
-                    startedAt: undefined,
-                    status: 'created',
-                    taskId: data.taskId,
-                    toolCalls: [],
-                    type: data.type,
-                });
-                return newTasks;
-            });
-        };
-        // Handle task:started - Update status and timestamp
-        const handleTaskStarted = (data) => {
-            setTasks((prev) => {
-                const task = prev.get(data.taskId);
-                if (!task)
-                    return prev;
-                const newTasks = new Map(prev);
-                newTasks.set(data.taskId, {
-                    ...task,
-                    startedAt: Date.now(),
-                    status: 'started',
-                });
-                return newTasks;
-            });
-        };
-        // Handle task:completed - Set result and completion time
-        // If task doesn't exist (e.g., missed task:created event from MCP), create a minimal entry
-        // Also marks any remaining 'running' tool calls as 'completed' since task is done
-        const handleTaskCompleted = (data) => {
-            setTasks((prev) => {
-                const task = prev.get(data.taskId);
-                const now = Date.now();
-                const newTasks = new Map(prev);
-                if (task) {
-                    // Mark any remaining 'running' tool calls as 'completed'
-                    // This handles cases where toolResult events were missed or arrived out of order
-                    const finalizedToolCalls = task.toolCalls.map((tc) => tc.status === 'running' ? { ...tc, status: 'completed' } : tc);
-                    // Filter out incomplete reasoning content (still thinking)
-                    const finalizedReasoningContent = task.reasoningContents?.filter((rc) => !rc.isThinking);
-                    // Normal case: update existing task
-                    newTasks.set(data.taskId, {
-                        ...task,
-                        completedAt: now,
-                        reasoningContents: finalizedReasoningContent,
-                        result: data.result,
-                        status: 'completed',
-                        toolCalls: finalizedToolCalls,
-                    });
-                }
-                else {
-                    // Task not found - create minimal entry (handles missed task:created events)
-                    newTasks.set(data.taskId, {
-                        completedAt: now,
-                        content: '',
-                        createdAt: now,
-                        error: undefined,
-                        files: undefined,
-                        input: '',
-                        result: data.result,
-                        sessionId: undefined,
-                        startedAt: now,
-                        status: 'completed',
-                        taskId: data.taskId,
-                        toolCalls: [],
-                        type: 'query', // Default to query; will be overridden if task:created arrives later
-                    });
-                }
-                return newTasks;
-            });
-        };
-        // Handle task:error - Set error and completion time
-        // If task doesn't exist, create minimal entry (handles missed task:created events)
-        // Also marks any remaining 'running' tool calls as 'error' since task failed
-        const handleTaskError = (data) => {
-            setTasks((prev) => {
-                const task = prev.get(data.taskId);
-                const now = Date.now();
-                const newTasks = new Map(prev);
-                if (task) {
-                    // Mark any remaining 'running' tool calls as 'error'
-                    const finalizedToolCalls = task.toolCalls.map((tc) => tc.status === 'running' ? { ...tc, status: 'error' } : tc);
-                    newTasks.set(data.taskId, {
-                        ...task,
-                        completedAt: now,
-                        error: data.error,
-                        status: 'error',
-                        toolCalls: finalizedToolCalls,
-                    });
-                }
-                else {
-                    // Task not found - create minimal entry
-                    newTasks.set(data.taskId, {
-                        completedAt: now,
-                        content: '',
-                        createdAt: now,
-                        error: data.error,
-                        files: undefined,
-                        input: '',
-                        result: undefined,
-                        sessionId: undefined,
-                        startedAt: now,
-                        status: 'error',
-                        taskId: data.taskId,
-                        toolCalls: [],
-                        type: 'query',
-                    });
-                }
-                return newTasks;
-            });
-        };
-        // Handle task:cancelled - Set cancelled status
-        // If task doesn't exist, create minimal entry (handles missed task:created events)
-        const handleTaskCancelled = (data) => {
-            setTasks((prev) => {
-                const task = prev.get(data.taskId);
-                const now = Date.now();
-                const newTasks = new Map(prev);
-                if (task) {
-                    newTasks.set(data.taskId, {
-                        ...task,
-                        completedAt: now,
-                        status: 'cancelled',
-                    });
-                }
-                else {
-                    // Task not found - create minimal entry
-                    newTasks.set(data.taskId, {
-                        completedAt: now,
-                        content: '',
-                        createdAt: now,
-                        error: undefined,
-                        files: undefined,
-                        input: '',
-                        result: undefined,
-                        sessionId: undefined,
-                        startedAt: now,
-                        status: 'cancelled',
-                        taskId: data.taskId,
-                        toolCalls: [],
-                        type: 'query',
-                    });
-                }
-                return newTasks;
-            });
-        };
-        // Handle llmservice:toolCall - Add new tool call or update existing one
-        // Tool calls may be emitted multiple times (once from stream with empty args, once from execution with actual args)
-        // We use callId to deduplicate and merge the data
-        // Handle llmservice:toolCall - Add new tool call with 'running' status
-        const handleToolCall = (data) => {
-            // Guard: taskId is optional in package types but required for transport events
-            const { taskId } = data;
-            if (!taskId)
-                return;
-            setTasks((prev) => {
-                const task = prev.get(taskId);
-                if (!task)
-                    return prev;
-                const newTasks = new Map(prev);
-                // Check if we already have a tool call with this callId
-                const existingIndex = data.callId ? task.toolCalls.findIndex((tc) => tc.callId === data.callId) : -1;
-                if (existingIndex >= 0) {
-                    // Update existing tool call with new data (merge args if new ones have content)
-                    const existingToolCall = task.toolCalls[existingIndex];
-                    const hasNewArgs = data.args && Object.keys(data.args).length > 0;
-                    const updatedToolCalls = [...task.toolCalls];
-                    updatedToolCalls[existingIndex] = {
-                        ...existingToolCall,
-                        args: hasNewArgs ? data.args : existingToolCall.args,
-                        sessionId: data.sessionId,
-                    };
-                    newTasks.set(taskId, {
-                        ...task,
-                        sessionId: data.sessionId,
-                        toolCalls: updatedToolCalls,
-                    });
-                }
-                else {
-                    // Add new tool call
-                    newTasks.set(taskId, {
-                        ...task,
-                        sessionId: data.sessionId,
-                        toolCalls: [
-                            ...task.toolCalls,
-                            {
-                                args: data.args,
-                                callId: data.callId,
-                                sessionId: data.sessionId,
-                                status: 'running',
-                                timestamp: Date.now(),
-                                toolName: data.toolName,
-                            },
-                        ],
-                    });
-                }
-                return newTasks;
-            });
-        };
-        // Handle llmservice:toolResult - Update tool call status
-        const handleToolResult = (data) => {
-            // Guard: taskId is optional in package types but required for transport events
-            const { taskId } = data;
-            if (!taskId)
-                return;
-            setTasks((prev) => {
-                const task = prev.get(taskId);
-                if (!task)
-                    return prev;
-                // Find the tool call to update using multiple strategies:
-                // 1. Match by callId (most reliable when both have callId)
-                // 2. Fallback: match by toolName for most recent 'running' tool call
-                let toolCallIndex = -1;
-                // Strategy 1: Match by callId if present in both
-                if (data.callId) {
-                    toolCallIndex = task.toolCalls.findIndex((tc) => tc.callId === data.callId);
-                }
-                // Strategy 2: Fallback to toolName matching for most recent running tool
-                if (toolCallIndex === -1 && data.toolName) {
-                    for (let i = task.toolCalls.length - 1; i >= 0; i--) {
-                        if (task.toolCalls[i].toolName === data.toolName && task.toolCalls[i].status === 'running') {
-                            toolCallIndex = i;
-                            break;
-                        }
-                    }
-                }
-                if (toolCallIndex === -1)
-                    return prev;
-                const updatedToolCalls = [...task.toolCalls];
-                updatedToolCalls[toolCallIndex] = {
-                    ...updatedToolCalls[toolCallIndex],
-                    error: data.error,
-                    errorType: data.errorType,
-                    result: data.result,
-                    status: data.success ? 'completed' : 'error',
-                };
-                const newTasks = new Map(prev);
-                newTasks.set(taskId, {
-                    ...task,
-                    toolCalls: updatedToolCalls,
-                });
-                return newTasks;
-            });
-        };
-        // Handle llmservice:thinking - Add a new reasoning content item with isThinking: true
-        // Deduplicates consecutive thinking events to prevent multiple "Thinking." entries
-        // from appearing when the agentic loop emits thinking per iteration or subagent events leak
-        const handleThinking = (data) => {
-            setTasks((prev) => {
-                const task = prev.get(data.taskId);
-                if (!task)
-                    return prev;
-                // Don't add another thinking item if the last one is still in thinking state
-                const existingContent = task.reasoningContents ?? [];
-                const lastItem = existingContent.at(-1);
-                if (lastItem?.isThinking) {
-                    return prev;
-                }
-                const newReasoningItem = {
-                    content: '',
-                    isThinking: true,
-                    timestamp: Date.now(),
-                };
-                const newTasks = new Map(prev);
-                newTasks.set(data.taskId, {
-                    ...task,
-                    reasoningContents: [...existingContent, newReasoningItem],
-                });
-                return newTasks;
-            });
-        };
-        // Handle llmservice:chunk - Accumulate streaming content for real-time display
-        // Separates reasoning/thinking content from regular text content
-        // For reasoning chunks, updates the last item with isThinking: true (paired with thinking event)
-        const handleChunk = (data) => {
-            const { taskId } = data;
-            if (!taskId)
-                return;
-            setTasks((prev) => {
-                const task = prev.get(taskId);
-                if (!task)
-                    return prev;
-                const newTasks = new Map(prev);
-                // Route content to appropriate field based on type
-                if (data.type === 'reasoning') {
-                    const existingContent = task.reasoningContents ?? [];
-                    const lastIndex = existingContent.length - 1;
-                    const lastItem = existingContent[lastIndex];
-                    // Update the last reasoning item (paired with thinking event)
-                    if (lastItem) {
-                        const updatedContent = [...existingContent];
-                        updatedContent[lastIndex] = {
-                            ...lastItem,
-                            content: lastItem.content + data.content,
-                            isThinking: false,
-                        };
-                        newTasks.set(taskId, {
-                            ...task,
-                            isStreaming: !data.isComplete,
-                            reasoningContents: updatedContent,
-                            sessionId: data.sessionId,
-                        });
-                    }
-                }
-                else {
-                    newTasks.set(taskId, {
-                        ...task,
-                        isStreaming: !data.isComplete,
-                        sessionId: data.sessionId,
-                        streamingContent: (task.streamingContent ?? '') + data.content,
-                    });
-                }
-                return newTasks;
-            });
-        };
-        // Handle llmservice:response - Update task content from LLM response
-        // Also clears streaming state since response marks end of streaming
-        const handleResponse = (data) => {
-            // Guard: taskId is optional in package types but required for transport events
-            const { taskId } = data;
-            if (!taskId)
-                return;
-            setTasks((prev) => {
-                const task = prev.get(taskId);
-                if (!task)
-                    return prev;
-                const newTasks = new Map(prev);
-                newTasks.set(taskId, {
-                    ...task,
-                    isStreaming: false,
-                    result: data.content,
-                    sessionId: data.sessionId,
-                    streamingContent: undefined, // Clear streaming content once final response received
-                });
-                return newTasks;
-            });
-        };
-        // Subscribe to events
-        unsubscribers.push(client.on('task:created', handleTaskCreated), client.on('task:started', handleTaskStarted), client.on('task:completed', handleTaskCompleted), client.on('task:error', handleTaskError), client.on('task:cancelled', handleTaskCancelled), client.on('llmservice:toolCall', handleToolCall), client.on('llmservice:toolResult', handleToolResult), client.on('llmservice:response', handleResponse), client.on('llmservice:thinking', handleThinking), client.on('llmservice:chunk', handleChunk), client.on('llmservice:toolCall', handleToolCall), client.on('llmservice:toolResult', handleToolResult), client.on('llmservice:response', handleResponse));
-        // Cleanup subscriptions
-        return () => {
-            for (const unsub of unsubscribers)
-                unsub();
-        };
-    }, [client]);
-    // Clear all tasks from memory
-    const clearTasks = useCallback(() => {
-        setTasks(new Map());
-    }, []);
-    // Helper function to get task by ID
-    const getTask = useCallback((taskId) => tasks.get(taskId), [tasks]);
-    // Calculate transport stats
-    const stats = useMemo(() => {
-        let created = 0;
-        let started = 0;
-        for (const task of tasks.values()) {
-            if (task.status === 'created') {
-                created++;
-            }
-            else if (task.status === 'started') {
-                started++;
-            }
-        }
-        return { created, started };
-    }, [tasks]);
-    const value = {
-        clearTasks,
-        getTask,
-        stats,
-        tasks,
-    };
-    return _jsx(TasksContext.Provider, { value: value, children: children });
-}
-/**
- * Hook to access tasks context.
- * Must be used within a TasksProvider.
- */
-export function useTasks() {
-    const context = useContext(TasksContext);
-    if (!context) {
-        throw new Error('useTasks must be used within a TasksProvider');
-    }
-    return context;
-}

package/dist/tui/contexts/theme-context.d.ts

@@ -1,55 +0,0 @@
-/**
- * Theme Context
- *
- * Global context for managing theme state across the entire app.
- * Any component can access the current theme or switch themes dynamically.
- *
- * Usage:
- * ```tsx
- * const {theme, setTheme} = useTheme()
- *
- * // Access theme properties
- * <Text color={theme.colors.primary}>Hello</Text>
- *
- * // Switch theme (future feature)
- * setTheme('default')
- * ```
- */
-import React from 'react';
-export interface ThemeColors {
-    bg1: string;
-    bg2: string;
-    bg3: string;
-    border: string;
-    curateCommand: string;
-    dimPrimary: string;
-    dimText: string;
-    errorText: string;
-    info: string;
-    logoBold: string;
-    logoDecor: string;
-    logoVersion: string;
-    primary: string;
-    queryCommand: string;
-    secondary: string;
-    text: string;
-    warning: string;
-}
-export interface Theme {
-    colors: ThemeColors;
-}
-export declare const themes: {
-    readonly default: Theme;
-};
-export type ThemeName = keyof typeof themes;
-interface ThemeContextValue {
-    setTheme: (name: ThemeName) => void;
-    theme: Theme;
-}
-interface ThemeProviderProps {
-    children: React.ReactNode;
-    initialTheme?: ThemeName;
-}
-export declare function ThemeProvider({ children, initialTheme }: ThemeProviderProps): React.ReactElement;
-export declare function useTheme(): ThemeContextValue;
-export {};