byterover-cli 0.4.0 → 1.0.0

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

@@ -0,0 +1,218 @@
+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
+        const handleTaskCreated = (data) => {
+            setTasks((prev) => {
+                const newTasks = new Map(prev);
+                newTasks.set(data.taskId, {
+                    completedAt: undefined,
+                    content: data.content,
+                    createdAt: Date.now(),
+                    error: undefined,
+                    files: data.files,
+                    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
+        const handleTaskCompleted = (data) => {
+            setTasks((prev) => {
+                const task = prev.get(data.taskId);
+                if (!task)
+                    return prev;
+                const newTasks = new Map(prev);
+                newTasks.set(data.taskId, {
+                    ...task,
+                    completedAt: Date.now(),
+                    status: 'completed',
+                });
+                return newTasks;
+            });
+        };
+        // Handle task:error - Set error and completion time
+        const handleTaskError = (data) => {
+            setTasks((prev) => {
+                const task = prev.get(data.taskId);
+                if (!task)
+                    return prev;
+                const newTasks = new Map(prev);
+                newTasks.set(data.taskId, {
+                    ...task,
+                    completedAt: Date.now(),
+                    error: data.error,
+                    status: 'error',
+                });
+                return newTasks;
+            });
+        };
+        // Handle task:cancelled - Set cancelled status
+        const handleTaskCancelled = (data) => {
+            setTasks((prev) => {
+                const task = prev.get(data.taskId);
+                if (!task)
+                    return prev;
+                const newTasks = new Map(prev);
+                newTasks.set(data.taskId, {
+                    ...task,
+                    completedAt: Date.now(),
+                    status: 'cancelled',
+                });
+                return newTasks;
+            });
+        };
+        // Handle llmservice:toolCall - Add new tool call with 'running' status
+        const handleToolCall = (data) => {
+            setTasks((prev) => {
+                const task = prev.get(data.taskId);
+                if (!task)
+                    return prev;
+                const newTasks = new Map(prev);
+                newTasks.set(data.taskId, {
+                    ...task,
+                    sessionId: data.sessionId,
+                    toolCalls: [
+                        ...task.toolCalls,
+                        {
+                            args: data.args,
+                            callId: data.callId,
+                            sessionId: data.sessionId,
+                            status: 'running',
+                            toolName: data.toolName,
+                        },
+                    ],
+                });
+                return newTasks;
+            });
+        };
+        // Handle llmservice:toolResult - Update tool call status
+        const handleToolResult = (data) => {
+            setTasks((prev) => {
+                const task = prev.get(data.taskId);
+                if (!task)
+                    return prev;
+                // Find the tool call to update (match by callId if present, otherwise by toolName and most recent)
+                const toolCallIndex = task.toolCalls.findIndex((tc) => tc.callId === data.callId);
+                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(data.taskId, {
+                    ...task,
+                    toolCalls: updatedToolCalls,
+                });
+                return newTasks;
+            });
+        };
+        // Handle llmservice:response - Update task content from LLM response
+        const handleResponse = (data) => {
+            setTasks((prev) => {
+                const task = prev.get(data.taskId);
+                if (!task)
+                    return prev;
+                const newTasks = new Map(prev);
+                newTasks.set(data.taskId, {
+                    ...task,
+                    result: data.content,
+                    sessionId: data.sessionId,
+                });
+                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));
+        // 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/transport-context.d.ts

@@ -0,0 +1,29 @@
+import React from 'react';
+import type { ConnectionState, ITransportClient } from '../../core/interfaces/transport/i-transport-client.js';
+/**
+ * Context value for transport client state.
+ */
+export type TransportContextValue = {
+    /** The connected transport client, or null if not connected */
+    client: ITransportClient | null;
+    /** Current connection state */
+    connectionState: ConnectionState;
+    /** Connection error if any */
+    error: Error | null;
+    /** Whether the client is connected */
+    isConnected: boolean;
+    /** Number of reconnection attempts */
+    reconnectCount: number;
+};
+/**
+ * Provider component that manages transport client connection and state.
+ * Subscribes to task and LLM events from the transport server.
+ */
+export declare function TransportProvider({ children }: {
+    children: React.ReactNode;
+}): React.ReactElement;
+/**
+ * Hook to access transport client from context.
+ * @throws Error if used outside TransportProvider
+ */
+export declare function useTransport(): TransportContextValue;

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

@@ -0,0 +1,82 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useContext, useEffect, useState } from 'react';
+import { createTransportClientFactory } from '../../infra/transport/transport-client-factory.js';
+const TransportContext = createContext(undefined);
+/**
+ * Provider component that manages transport client connection and state.
+ * Subscribes to task and LLM events from the transport server.
+ */
+export function TransportProvider({ children }) {
+    const [client, setClient] = useState(null);
+    const [connectionState, setConnectionState] = useState('disconnected');
+    const [error, setError] = useState(null);
+    const [reconnectCount, setReconnectCount] = useState(0);
+    useEffect(() => {
+        let mounted = true;
+        let transportClient = null;
+        let stateChangeUnsubscribe;
+        async function initializeTransport() {
+            try {
+                setConnectionState('connecting');
+                // Create factory and connect
+                const factory = createTransportClientFactory();
+                const { client: newClient } = await factory.connect();
+                if (!mounted) {
+                    await newClient.disconnect();
+                    return;
+                }
+                transportClient = newClient;
+                // Subscribe to connection state changes
+                stateChangeUnsubscribe = newClient.onStateChange((state) => {
+                    setConnectionState(state);
+                    if (state === 'reconnecting') {
+                        setReconnectCount((prev) => prev + 1);
+                    }
+                });
+                // Join broadcast room to receive all events
+                await newClient.joinRoom('broadcast-room');
+                // Set client in state
+                setClient(newClient);
+                setConnectionState(newClient.getState());
+                setError(null);
+            }
+            catch (error_) {
+                if (mounted) {
+                    setError(error_ instanceof Error ? error_ : new Error(String(error_)));
+                    setConnectionState('disconnected');
+                }
+            }
+        }
+        initializeTransport();
+        return () => {
+            mounted = false;
+            if (stateChangeUnsubscribe) {
+                stateChangeUnsubscribe();
+            }
+            if (transportClient) {
+                transportClient.disconnect().catch(() => {
+                    // Ignore errors during cleanup
+                });
+            }
+        };
+    }, []);
+    const value = {
+        client,
+        connectionState,
+        error,
+        isConnected: connectionState === 'connected',
+        reconnectCount,
+    };
+    return _jsx(TransportContext.Provider, { value: value, children: children });
+}
+/**
+ * Hook to access transport client from context.
+ * @throws Error if used outside TransportProvider
+ */
+export function useTransport() {
+    const context = useContext(TransportContext);
+    if (!context) {
+        throw new Error('useTransport must be used within a TransportProvider');
+    }
+    return context;
+}

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

@@ -1,17 +1,21 @@
 /**
  * TUI Hooks
  */
-export { CommandsProvider, useCommands } from '../contexts/use-commands.js';
-export { ModeProvider, useMode } from '../contexts/use-mode.js';
-export { ThemeProvider, useTheme } from '../contexts/use-theme.js';
-export { composeChangesFromToolCalls, parseExecutionContent, useActivityLogs } from './use-activity-logs.js';
+export { CommandsProvider, useCommands } from '../contexts/commands-context.js';
+export { ModeProvider, useMode } from '../contexts/mode-context.js';
+export { ThemeProvider, useTheme } from '../contexts/theme-context.js';
+export { parseExecutionContent, useActivityLogs } from './use-activity-logs.js';
 export type { UseActivityLogsReturn } from './use-activity-logs.js';
-export { useConsumer } from './use-consumer.js';
+export { useAuthPolling } from './use-auth-polling.js';
+export type { UseAuthPollingOptions } from './use-auth-polling.js';
 export { useOnboarding } from './use-onboarding.js';
 export type { OnboardingStep, UseOnboardingReturn } from './use-onboarding.js';
-export { useQueuePolling, useQueuePollingCleanup } from './use-queue-polling.js';
 export { useSlashCommandProcessor } from './use-slash-command-processor.js';
 export { useSlashCompletion } from './use-slash-completion.js';
 export { useTabNavigation } from './use-tab-navigation.js';
+export { useTerminalBreakpoint } from './use-terminal-breakpoint.js';
+export type { TerminalBreakpoint, TerminalBreakpointReturn } from './use-terminal-breakpoint.js';
+export { useUIHeights } from './use-ui-heights.js';
+export type { MessageItemHeights, UIHeights } from './use-ui-heights.js';
 export { useVisibleWindow } from './use-visible-window.js';
 export type { UseVisibleWindowReturn } from './use-visible-window.js';

package/dist/tui/hooks/index.js

@@ -1,14 +1,15 @@
 /**
  * TUI Hooks
  */
-export { CommandsProvider, useCommands } from '../contexts/use-commands.js';
-export { ModeProvider, useMode } from '../contexts/use-mode.js';
-export { ThemeProvider, useTheme } from '../contexts/use-theme.js';
-export { composeChangesFromToolCalls, parseExecutionContent, useActivityLogs } from './use-activity-logs.js';
-export { useConsumer } from './use-consumer.js';
+export { CommandsProvider, useCommands } from '../contexts/commands-context.js';
+export { ModeProvider, useMode } from '../contexts/mode-context.js';
+export { ThemeProvider, useTheme } from '../contexts/theme-context.js';
+export { parseExecutionContent, useActivityLogs } from './use-activity-logs.js';
+export { useAuthPolling } from './use-auth-polling.js';
 export { useOnboarding } from './use-onboarding.js';
-export { useQueuePolling, useQueuePollingCleanup } from './use-queue-polling.js';
 export { useSlashCommandProcessor } from './use-slash-command-processor.js';
 export { useSlashCompletion } from './use-slash-completion.js';
 export { useTabNavigation } from './use-tab-navigation.js';
+export { useTerminalBreakpoint } from './use-terminal-breakpoint.js';
+export { useUIHeights } from './use-ui-heights.js';
 export { useVisibleWindow } from './use-visible-window.js';

package/dist/tui/hooks/use-activity-logs.d.ts

@@ -1,26 +1,18 @@
 /**
  * Activity Logs Hook
  *
- * Transforms sessionExecutions into ActivityLog format for display.
+ * Transforms tasks from transport events into ActivityLog format for display.
  */
-import type { ToolCall } from '../../core/domain/cipher/queue/types.js';
 import type { ActivityLog } from '../types.js';
 /**
  * Parse execution input to extract content
  */
 export declare function parseExecutionContent(input: string): string;
-/**
- * Extract file changes from curate tool calls
- */
-export declare function composeChangesFromToolCalls(toolCalls: ToolCall[]): {
-    created: string[];
-    updated: string[];
-};
 export interface UseActivityLogsReturn {
-    /** Activity logs derived from session executions */
+    /** Activity logs derived from tasks */
     logs: ActivityLog[];
 }
 /**
- * Hook that transforms sessionExecutions into ActivityLog format
+ * Hook that transforms tasks from transport events into ActivityLog format
  */
 export declare function useActivityLogs(): UseActivityLogsReturn;

package/dist/tui/hooks/use-activity-logs.js

@@ -1,19 +1,18 @@
 /**
  * Activity Logs Hook
  *
- * Transforms sessionExecutions into ActivityLog format for display.
+ * Transforms tasks from transport events into ActivityLog format for display.
  */
-import { join } from 'node:path';
 import { useMemo } from 'react';
 import { array as zArray, object as zObject, string as zString } from 'zod';
-import { BRV_DIR, CONTEXT_TREE_DIR } from '../../constants.js';
-import { useConsumer } from '../contexts/index.js';
+import { useTasks } from '../contexts/tasks-context.js';
 const ExecutionInputSchema = zObject({
     content: zString(),
 });
 const CurateResultSchema = zObject({
     result: zObject({
         applied: zArray(zObject({
+            filePath: zString(),
             path: zString(),
             status: zString(),
             type: zString(),
@@ -32,16 +31,24 @@ export function parseExecutionContent(input) {
     }
 }
 /**
- * Extract file changes from curate tool calls
+ * Extract file changes from curate tool calls (transport events)
  */
-export function composeChangesFromToolCalls(toolCalls) {
+function composeChangesFromToolCalls(toolCalls) {
     const changes = { created: [], updated: [] };
-    const contextTreeDir = join(BRV_DIR, CONTEXT_TREE_DIR);
     for (const tc of toolCalls) {
-        if (tc.status !== 'completed' || tc.name !== 'curate' || !tc.result) {
+        if (tc.status !== 'completed' || tc.toolName !== 'curate' || !tc.result) {
             continue;
         }
-        const parseResult = CurateResultSchema.safeParse(JSON.parse(tc.result));
+        // Parse JSON - skip if invalid
+        let parsed;
+        try {
+            parsed = JSON.parse(String(tc.result));
+        }
+        catch {
+            continue;
+        }
+        // Validate schema with safeParse
+        const parseResult = CurateResultSchema.safeParse(parsed);
         if (!parseResult.success) {
             continue;
         }
@@ -50,41 +57,87 @@ export function composeChangesFromToolCalls(toolCalls) {
             if (operation.status !== 'success') {
                 continue;
             }
-            const contextPath = join(contextTreeDir, operation.path, 'context.md');
             if (operation.type === 'ADD') {
-                changes.created.push(contextPath);
+                changes.created.push(operation.filePath);
             }
             else if (operation.type === 'UPDATE') {
-                changes.updated.push(contextPath);
+                changes.updated.push(operation.filePath);
             }
         }
     }
     return changes;
 }
 /**
- * Hook that transforms sessionExecutions into ActivityLog format
+ * Map task status to execution status
+ */
+function mapTaskStatusToExecutionStatus(taskStatus) {
+    switch (taskStatus) {
+        case 'cancelled': {
+            return 'failed';
+        }
+        case 'completed': {
+            return 'completed';
+        }
+        case 'created':
+        case 'started': {
+            return 'running';
+        }
+        case 'error': {
+            return 'failed';
+        }
+        default: {
+            return 'running';
+        }
+    }
+}
+/**
+ * Map tool call status to ToolCallStatus
+ */
+function mapToolCallStatus(status) {
+    switch (status) {
+        case 'completed': {
+            return 'completed';
+        }
+        case 'error': {
+            return 'failed';
+        }
+        case 'running': {
+            return 'running';
+        }
+        default: {
+            return 'running';
+        }
+    }
+}
+/**
+ * Hook that transforms tasks from transport events into ActivityLog format
  */
 export function useActivityLogs() {
-    const { sessionExecutions } = useConsumer();
-    const logs = useMemo(() => sessionExecutions.map(({ execution, toolCalls }) => {
-        const progress = toolCalls.map((tc) => ({
-            id: tc.id,
-            status: tc.status,
-            toolCallName: tc.name,
-        }));
-        const changes = composeChangesFromToolCalls(toolCalls);
-        const activityLog = {
-            changes,
-            content: execution.status === 'failed' ? execution.error ?? '' : execution.result ?? '',
-            id: execution.id,
-            input: parseExecutionContent(execution.input),
-            progress,
-            source: 'agent',
-            status: execution.status,
-            timestamp: new Date(execution.updatedAt),
-            type: execution.type,
-        };
-        return activityLog;
-    }), [sessionExecutions]);
+    const { tasks } = useTasks();
+    const logs = useMemo(() => {
+        const taskArray = [...tasks.values()];
+        return taskArray
+            .filter((task) => task.status !== 'created')
+            .map((task) => {
+            const progress = task.toolCalls.map((tc, index) => ({
+                id: tc.callId ?? `${task.taskId}-${index}`,
+                status: mapToolCallStatus(tc.status),
+                toolCallName: tc.toolName,
+            }));
+            const changes = composeChangesFromToolCalls(task.toolCalls);
+            const activityLog = {
+                changes,
+                content: task.status === 'error' ? task.error?.message ?? '' : task.result ?? '',
+                id: task.taskId,
+                input: task.content,
+                progress,
+                source: 'agent',
+                status: mapTaskStatusToExecutionStatus(task.status),
+                timestamp: new Date(task.completedAt ?? task.startedAt ?? task.createdAt),
+                type: task.type,
+            };
+            return activityLog;
+        });
+    }, [tasks]);
     return { logs };
 }

package/dist/tui/hooks/use-auth-polling.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Auth Polling Hook
+ *
+ * Periodically checks auth state and refreshes token when needed.
+ */
+import type { AuthToken } from '../../core/domain/entities/auth-token.js';
+import type { ITokenStore } from '../../core/interfaces/i-token-store.js';
+export interface UseAuthPollingOptions {
+    /** Current auth token */
+    authToken: AuthToken | undefined;
+    /** Callback when token is refreshed or cleared */
+    onTokenChange: (token?: AuthToken) => void;
+    /** Token store for persistence */
+    tokenStore: ITokenStore;
+}
+/**
+ * Hook that polls auth state and refreshes token when needed.
+ *
+ * - Polls every 30 seconds when authorized
+ * - Validates token by calling user API
+ * - Refreshes token if validation fails
+ * - Clears auth state if refresh fails
+ */
+export declare function useAuthPolling({ authToken, onTokenChange, tokenStore }: UseAuthPollingOptions): void;