byterover-cli 1.7.2 → 2.0.0

package/dist/tui/features/tasks/stores/tasks-store.js

@@ -0,0 +1,262 @@
+/**
+ * Tasks Store
+ *
+ * Zustand store for task lifecycle state.
+ * Subscribes to task:* and llmservice:* transport events.
+ */
+import { create } from 'zustand';
+function computeStats(tasks) {
+    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 };
+}
+export const useTasksStore = create()((set, get) => ({
+    addReasoningContent: (taskId, item) => set((state) => {
+        const task = state.tasks.get(taskId);
+        if (!task)
+            return state;
+        // Deduplicate: don't add another thinking item if last one is still thinking
+        const existing = task.reasoningContents ?? [];
+        const last = existing.at(-1);
+        if (item.isThinking && last?.isThinking)
+            return state;
+        const tasks = new Map(state.tasks);
+        tasks.set(taskId, {
+            ...task,
+            reasoningContents: [...existing, item],
+        });
+        return { stats: computeStats(tasks), tasks };
+    }),
+    addToolCall: (taskId, toolCall) => set((state) => {
+        const task = state.tasks.get(taskId);
+        if (!task)
+            return state;
+        const tasks = new Map(state.tasks);
+        // Deduplicate by callId
+        const existingIndex = toolCall.callId ? task.toolCalls.findIndex((tc) => tc.callId === toolCall.callId) : -1;
+        if (existingIndex >= 0) {
+            const existing = task.toolCalls[existingIndex];
+            const hasNewArgs = toolCall.args && Object.keys(toolCall.args).length > 0;
+            const updatedCalls = [...task.toolCalls];
+            updatedCalls[existingIndex] = {
+                ...existing,
+                args: hasNewArgs ? toolCall.args : existing.args,
+                sessionId: toolCall.sessionId,
+            };
+            tasks.set(taskId, { ...task, sessionId: toolCall.sessionId, toolCalls: updatedCalls });
+        }
+        else {
+            tasks.set(taskId, {
+                ...task,
+                sessionId: toolCall.sessionId,
+                toolCalls: [...task.toolCalls, toolCall],
+            });
+        }
+        return { stats: computeStats(tasks), tasks };
+    }),
+    appendStreamingContent: ({ content, isComplete, sessionId, taskId, type }) => set((state) => {
+        const task = state.tasks.get(taskId);
+        if (!task)
+            return state;
+        const tasks = new Map(state.tasks);
+        if (type === 'reasoning') {
+            const existing = task.reasoningContents ?? [];
+            const lastIndex = existing.length - 1;
+            const lastItem = existing[lastIndex];
+            if (lastItem) {
+                const updated = [...existing];
+                updated[lastIndex] = {
+                    ...lastItem,
+                    content: lastItem.content + content,
+                    isThinking: false,
+                };
+                tasks.set(taskId, {
+                    ...task,
+                    isStreaming: !isComplete,
+                    reasoningContents: updated,
+                    sessionId: sessionId ?? task.sessionId,
+                });
+            }
+            else {
+                // No placeholder from llmservice:thinking — create one from first chunk
+                tasks.set(taskId, {
+                    ...task,
+                    isStreaming: !isComplete,
+                    reasoningContents: [{ content, isThinking: false, timestamp: Date.now() }],
+                    sessionId: sessionId ?? task.sessionId,
+                });
+            }
+        }
+        else {
+            tasks.set(taskId, {
+                ...task,
+                isStreaming: !isComplete,
+                sessionId: sessionId ?? task.sessionId,
+                streamingContent: (task.streamingContent ?? '') + content,
+            });
+        }
+        return { stats: computeStats(tasks), tasks };
+    }),
+    clearTasks: () => set({ stats: { created: 0, started: 0 }, tasks: new Map() }),
+    createTask: (taskId, type, content, files) => set((state) => {
+        const tasks = new Map(state.tasks);
+        tasks.set(taskId, {
+            content,
+            createdAt: Date.now(),
+            files,
+            input: content,
+            status: 'created',
+            taskId,
+            toolCalls: [],
+            type,
+        });
+        return { stats: computeStats(tasks), tasks };
+    }),
+    getTask: (taskId) => get().tasks.get(taskId),
+    setCancelled: (taskId) => set((state) => {
+        const task = state.tasks.get(taskId);
+        if (!task) {
+            // Handle missed task:created
+            const tasks = new Map(state.tasks);
+            const now = Date.now();
+            tasks.set(taskId, {
+                completedAt: now,
+                content: '',
+                createdAt: now,
+                input: '',
+                startedAt: now,
+                status: 'cancelled',
+                taskId,
+                toolCalls: [],
+                type: 'query',
+            });
+            return { stats: computeStats(tasks), tasks };
+        }
+        const tasks = new Map(state.tasks);
+        tasks.set(taskId, { ...task, completedAt: Date.now(), status: 'cancelled' });
+        return { stats: computeStats(tasks), tasks };
+    }),
+    setCompleted: (taskId, result) => set((state) => {
+        const task = state.tasks.get(taskId);
+        const now = Date.now();
+        const tasks = new Map(state.tasks);
+        if (task) {
+            const finalizedToolCalls = task.toolCalls.map((tc) => tc.status === 'running' ? { ...tc, status: 'completed' } : tc);
+            const finalizedReasoning = task.reasoningContents?.filter((rc) => !rc.isThinking);
+            tasks.set(taskId, {
+                ...task,
+                completedAt: now,
+                reasoningContents: finalizedReasoning,
+                result,
+                status: 'completed',
+                toolCalls: finalizedToolCalls,
+            });
+        }
+        else {
+            tasks.set(taskId, {
+                completedAt: now,
+                content: '',
+                createdAt: now,
+                input: '',
+                result,
+                startedAt: now,
+                status: 'completed',
+                taskId,
+                toolCalls: [],
+                type: 'query',
+            });
+        }
+        return { stats: computeStats(tasks), tasks };
+    }),
+    setError: (taskId, error) => set((state) => {
+        const task = state.tasks.get(taskId);
+        const now = Date.now();
+        const tasks = new Map(state.tasks);
+        if (task) {
+            const finalizedToolCalls = task.toolCalls.map((tc) => tc.status === 'running' ? { ...tc, status: 'error' } : tc);
+            tasks.set(taskId, {
+                ...task,
+                completedAt: now,
+                error,
+                status: 'error',
+                toolCalls: finalizedToolCalls,
+            });
+        }
+        else {
+            tasks.set(taskId, {
+                completedAt: now,
+                content: '',
+                createdAt: now,
+                error,
+                input: '',
+                startedAt: now,
+                status: 'error',
+                taskId,
+                toolCalls: [],
+                type: 'query',
+            });
+        }
+        return { stats: computeStats(tasks), tasks };
+    }),
+    setResponse: (taskId, content, sessionId) => set((state) => {
+        const task = state.tasks.get(taskId);
+        if (!task)
+            return state;
+        const tasks = new Map(state.tasks);
+        tasks.set(taskId, {
+            ...task,
+            isStreaming: false,
+            result: content,
+            sessionId: sessionId ?? task.sessionId,
+            streamingContent: undefined,
+        });
+        return { stats: computeStats(tasks), tasks };
+    }),
+    setStarted: (taskId) => set((state) => {
+        const task = state.tasks.get(taskId);
+        if (!task)
+            return state;
+        const tasks = new Map(state.tasks);
+        tasks.set(taskId, { ...task, startedAt: Date.now(), status: 'started' });
+        return { stats: computeStats(tasks), tasks };
+    }),
+    stats: { created: 0, started: 0 },
+    tasks: new Map(),
+    updateToolCallResult: ({ callId, error, errorType, result, success, taskId, toolName }) => set((state) => {
+        const task = state.tasks.get(taskId);
+        if (!task)
+            return state;
+        // Find by callId first, then fallback to toolName
+        let index = -1;
+        if (callId) {
+            index = task.toolCalls.findIndex((tc) => tc.callId === callId);
+        }
+        if (index === -1 && toolName) {
+            for (let i = task.toolCalls.length - 1; i >= 0; i--) {
+                if (task.toolCalls[i].toolName === toolName && task.toolCalls[i].status === 'running') {
+                    index = i;
+                    break;
+                }
+            }
+        }
+        if (index === -1)
+            return state;
+        const updatedCalls = [...task.toolCalls];
+        updatedCalls[index] = {
+            ...updatedCalls[index],
+            error,
+            errorType,
+            result,
+            status: success ? 'completed' : 'error',
+        };
+        const tasks = new Map(state.tasks);
+        tasks.set(taskId, { ...task, toolCalls: updatedCalls });
+        return { stats: computeStats(tasks), tasks };
+    }),
+}));

package/dist/tui/features/transport/components/transport-initializer.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Transport Initializer
+ *
+ * Connects to the daemon via connectToDaemon() and manages the transport lifecycle.
+ * The daemon is already running (ensureDaemonRunning() in main.ts).
+ * connectToDaemon() handles: ensure daemon + connect + register + join rooms.
+ */
+import React from 'react';
+interface TransportInitializerProps {
+    children: React.ReactNode;
+}
+export declare function TransportInitializer({ children }: TransportInitializerProps): React.ReactNode;
+export {};

package/dist/tui/features/transport/components/transport-initializer.js

@@ -0,0 +1,107 @@
+import { Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
+/**
+ * Transport Initializer
+ *
+ * Connects to the daemon via connectToDaemon() and manages the transport lifecycle.
+ * The daemon is already running (ensureDaemonRunning() in main.ts).
+ * connectToDaemon() handles: ensure daemon + connect + register + join rooms.
+ */
+import { connectToDaemon, createDaemonReconnector, } from '@campfirein/brv-transport-client';
+import { useEffect } from 'react';
+import { getAllEventValues } from '../../../../shared/transport/events/index.js';
+import { initTransportLog, logTransportEvent } from '../../../lib/transport-logger.js';
+import { useTransportStore } from '../../../stores/transport-store.js';
+export function TransportInitializer({ children }) {
+    const { incrementReconnectCount, setClient, setConnectionState, setError } = useTransportStore();
+    useEffect(() => {
+        let mounted = true;
+        let reconnectorHandle;
+        const eventUnsubscribes = [];
+        function registerEventHandlers(client) {
+            // Clear old handlers first
+            for (const unsub of eventUnsubscribes) {
+                unsub();
+            }
+            eventUnsubscribes.length = 0;
+            // Register new handlers
+            const eventValues = getAllEventValues();
+            logTransportEvent('_handlers', { count: eventValues.length, events: eventValues });
+            for (const event of eventValues) {
+                const unsub = client.on(event, (data) => logTransportEvent(event, data));
+                eventUnsubscribes.push(unsub);
+            }
+            logTransportEvent('_handlers', { registered: eventUnsubscribes.length });
+        }
+        async function initializeTransport() {
+            try {
+                initTransportLog();
+                setConnectionState('connecting');
+                // connectToDaemon = ensureDaemonRunning (no-op, already running) + connect + register + join rooms
+                const connectOptions = {
+                    clientType: 'tui',
+                    joinRooms: ['broadcast-room'],
+                    projectPath: process.cwd(),
+                };
+                const { client: newClient } = await connectToDaemon(connectOptions);
+                if (!mounted) {
+                    await newClient.disconnect();
+                    return;
+                }
+                logTransportEvent('_room', { room: 'broadcast-room', state: 'joined' });
+                // Register event handlers for logging
+                registerEventHandlers(newClient);
+                logTransportEvent('_connection', { clientId: newClient.getClientId(), state: 'initialized' });
+                // Set client in store (this also creates apiClient)
+                setClient(newClient);
+                // Auto-reconnect on disconnect (shared logic from brv-transport-client)
+                reconnectorHandle = createDaemonReconnector(newClient, {
+                    connectOptions,
+                    onReconnected(reconnectedClient) {
+                        if (!mounted)
+                            return;
+                        registerEventHandlers(reconnectedClient);
+                        setClient(reconnectedClient);
+                        logTransportEvent('_reconnect', { clientId: reconnectedClient.getClientId(), state: 'success' });
+                    },
+                    onStateChange(state, client) {
+                        if (!mounted)
+                            return;
+                        setConnectionState(state);
+                        logTransportEvent('_connection', { clientId: client.getClientId(), state });
+                        if (state === 'reconnecting') {
+                            incrementReconnectCount();
+                        }
+                        if (state === 'connected') {
+                            registerEventHandlers(client);
+                        }
+                    },
+                });
+            }
+            catch (error_) {
+                if (mounted) {
+                    const err = error_ instanceof Error ? error_ : new Error(String(error_));
+                    setError(err);
+                    logTransportEvent('_connection', { error: err.message, state: 'failed' });
+                }
+            }
+        }
+        initializeTransport();
+        return () => {
+            mounted = false;
+            reconnectorHandle?.cancel();
+            // Clean up all event handlers
+            for (const unsub of eventUnsubscribes) {
+                unsub();
+            }
+            // Get the current client from store for cleanup
+            const { client } = useTransportStore.getState();
+            if (client) {
+                logTransportEvent('_connection', { state: 'closing' });
+                client.disconnect().catch(() => {
+                    // Ignore errors during cleanup
+                });
+            }
+        };
+    }, [incrementReconnectCount, setClient, setConnectionState, setError]);
+    return _jsx(_Fragment, { children: children });
+}

package/dist/tui/features/transport/hooks/use-transport.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Transport Hook
+ *
+ * Provides transport client state with the same interface as the old context.
+ */
+import type { TransportState } from '../../../stores/transport-store.js';
+export interface UseTransportReturn {
+    /** The connected transport client, or null if not connected */
+    client: TransportState['client'];
+    /** Current connection state */
+    connectionState: TransportState['connectionState'];
+    /** Connection error if any */
+    error: TransportState['error'];
+    /** Whether the client is connected */
+    isConnected: boolean;
+    /** Number of reconnection attempts */
+    reconnectCount: number;
+}
+export declare function useTransport(): UseTransportReturn;

package/dist/tui/features/transport/hooks/use-transport.js

@@ -0,0 +1,16 @@
+/**
+ * Transport Hook
+ *
+ * Provides transport client state with the same interface as the old context.
+ */
+import { useTransportStore } from '../../../stores/transport-store.js';
+export function useTransport() {
+    const store = useTransportStore();
+    return {
+        client: store.client,
+        connectionState: store.connectionState,
+        error: store.error,
+        isConnected: store.isConnected,
+        reconnectCount: store.reconnectCount,
+    };
+}

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

@@ -1,20 +1,21 @@
 /**
  * TUI Hooks
+ *
+ * Barrel export for all hooks. Feature-specific hooks are re-exported
+ * from their respective feature folders for convenience.
  */
-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 { useAuthPolling } from './use-auth-polling.js';
-export type { UseAuthPollingOptions } from './use-auth-polling.js';
+export { parseExecutionContent, useActivityLogs } from '../features/activity/hooks/use-activity-logs.js';
+export type { UseActivityLogsReturn } from '../features/activity/hooks/use-activity-logs.js';
+export { useFeedNavigation } from '../features/activity/hooks/use-feed-navigation.js';
+export { useCommands, useCommandsController } from '../features/commands/hooks/use-commands-controller.js';
+export { useSlashCommandProcessor } from '../features/commands/hooks/use-slash-command-processor.js';
+export { useSlashCompletion } from '../features/commands/hooks/use-slash-completion.js';
+export { useCommandsStore } from '../features/commands/stores/commands-store.js';
+export { useMode, useModeStore } from '../stores/mode-store.js';
+export type { Mode, Shortcut } from '../stores/mode-store.js';
+export { useTheme, useThemeStore } from '../stores/theme-store.js';
+export type { Theme, ThemeColors, ThemeName } from '../stores/theme-store.js';
 export { useIsLatestVersion } from './use-is-latest-version.js';
-export { useOnboardingLogs } from './use-onboarding-logs.js';
-export type { UseOnboardingLogsReturn } from './use-onboarding-logs.js';
-export { useOnboarding } from './use-onboarding.js';
-export type { OnboardingStep, UseOnboardingReturn } from './use-onboarding.js';
-export { useSlashCommandProcessor } from './use-slash-command-processor.js';
-export { useSlashCompletion } from './use-slash-completion.js';
 export { useTerminalBreakpoint } from './use-terminal-breakpoint.js';
 export type { TerminalBreakpoint, TerminalBreakpointReturn } from './use-terminal-breakpoint.js';
 export { useUIHeights } from './use-ui-heights.js';

package/dist/tui/hooks/index.js

@@ -1,16 +1,22 @@
 /**
  * TUI Hooks
+ *
+ * Barrel export for all hooks. Feature-specific hooks are re-exported
+ * from their respective feature folders for convenience.
  */
-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';
+// Feature: Activity
+export { parseExecutionContent, useActivityLogs } from '../features/activity/hooks/use-activity-logs.js';
+export { useFeedNavigation } from '../features/activity/hooks/use-feed-navigation.js';
+// Feature: Commands
+export { useCommands, useCommandsController } from '../features/commands/hooks/use-commands-controller.js';
+export { useSlashCommandProcessor } from '../features/commands/hooks/use-slash-command-processor.js';
+export { useSlashCompletion } from '../features/commands/hooks/use-slash-completion.js';
+export { useCommandsStore } from '../features/commands/stores/commands-store.js';
+// Stores
+export { useMode, useModeStore } from '../stores/mode-store.js';
+export { useTheme, useThemeStore } from '../stores/theme-store.js';
+// Generic UI utilities (kept in this folder)
 export { useIsLatestVersion } from './use-is-latest-version.js';
-export { useOnboardingLogs } from './use-onboarding-logs.js';
-export { useOnboarding } from './use-onboarding.js';
-export { useSlashCommandProcessor } from './use-slash-command-processor.js';
-export { useSlashCompletion } from './use-slash-completion.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-terminal-breakpoint.js

@@ -16,15 +16,16 @@ import { useEffect, useState } from 'react';
  */
 export function useTerminalBreakpoint() {
     const { stdout } = useStdout();
+    // Subtract 1 from rows to account for the shell prompt line that launched the app
     const [dimensions, setDimensions] = useState({
         columns: stdout?.columns ?? 80,
-        rows: stdout?.rows ?? 24,
+        rows: (stdout?.rows ?? 24) - 1,
     });
     useEffect(() => {
         const handleResize = () => {
             setDimensions({
                 columns: process.stdout.columns,
-                rows: process.stdout.rows,
+                rows: process.stdout.rows - 1,
             });
         };
         process.stdout.on('resize', handleResize);

package/dist/tui/lib/api-client.d.ts

@@ -0,0 +1,20 @@
+/**
+ * BrvApiClient
+ *
+ * Generic typed wrapper around ITransportClient.
+ * Provides request/response and event subscription primitives.
+ * Domain-specific methods live in each feature's api/ files.
+ */
+import type { ITransportClient, RequestOptions } from '@campfirein/brv-transport-client';
+export declare class BrvApiClient {
+    private readonly client;
+    constructor(client: ITransportClient);
+    /**
+     * Subscribe to a transport event. Returns an unsubscribe function.
+     */
+    on<T>(event: string, handler: (data: T) => void): () => void;
+    /**
+     * Send a request and wait for an acknowledged response.
+     */
+    request<TResponse, TRequest = unknown>(event: string, data?: TRequest, options?: RequestOptions): Promise<TResponse>;
+}

package/dist/tui/lib/api-client.js

@@ -0,0 +1,29 @@
+/**
+ * BrvApiClient
+ *
+ * Generic typed wrapper around ITransportClient.
+ * Provides request/response and event subscription primitives.
+ * Domain-specific methods live in each feature's api/ files.
+ */
+import { logTransportEvent } from './transport-logger.js';
+export class BrvApiClient {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    /**
+     * Subscribe to a transport event. Returns an unsubscribe function.
+     */
+    on(event, handler) {
+        return this.client.on(event, handler);
+    }
+    /**
+     * Send a request and wait for an acknowledged response.
+     */
+    async request(event, data, options) {
+        logTransportEvent(event, data);
+        const response = await this.client.requestWithAck(event, data, options);
+        logTransportEvent(event, response);
+        return response;
+    }
+}

package/dist/tui/lib/environment.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Environment utilities for TUI
+ *
+ * Simple environment checks and constants that don't require server imports.
+ */
+/**
+ * Check if the current environment is development.
+ * Uses BRV_ENV which is set by bin/dev.js and bin/run.js.
+ */
+export declare const isDevelopment: () => boolean;
+/**
+ * Project-level ByteRover directory name.
+ */
+export declare const BRV_DIR = ".brv";
+/**
+ * Directory for conflict review files created during space switch merge.
+ */
+export declare const CONTEXT_TREE_CONFLICT_DIR = "context-tree-conflicts";

package/dist/tui/lib/environment.js

@@ -0,0 +1,18 @@
+/**
+ * Environment utilities for TUI
+ *
+ * Simple environment checks and constants that don't require server imports.
+ */
+/**
+ * Check if the current environment is development.
+ * Uses BRV_ENV which is set by bin/dev.js and bin/run.js.
+ */
+export const isDevelopment = () => process.env.BRV_ENV === 'development';
+/**
+ * Project-level ByteRover directory name.
+ */
+export const BRV_DIR = '.brv';
+/**
+ * Directory for conflict review files created during space switch merge.
+ */
+export const CONTEXT_TREE_CONFLICT_DIR = 'context-tree-conflicts';

package/dist/tui/lib/react-query.d.ts

@@ -0,0 +1,17 @@
+/**
+ * React Query Configuration
+ *
+ * Shared types and default config for @tanstack/react-query.
+ */
+import type { UseMutationOptions } from '@tanstack/react-query';
+export declare const queryConfig: {
+    queries: {
+        gcTime: number;
+        refetchOnWindowFocus: false;
+        retry: false;
+        staleTime: number;
+    };
+};
+export type ApiFnReturnType<FnType extends (...args: never[]) => Promise<unknown>> = Awaited<ReturnType<FnType>>;
+export type QueryConfig<T extends (...args: never[]) => unknown> = Omit<ReturnType<T>, 'queryFn' | 'queryKey'>;
+export type MutationConfig<MutationFnType extends (...args: never[]) => Promise<unknown>> = UseMutationOptions<ApiFnReturnType<MutationFnType>, Error, Parameters<MutationFnType>[0]>;

package/dist/tui/lib/react-query.js

@@ -0,0 +1,17 @@
+/**
+ * React Query Configuration
+ *
+ * Shared types and default config for @tanstack/react-query.
+ */
+export const queryConfig = {
+    queries: {
+        // cached data is garbage collected immediately after unmount,
+        // so no stale data is ever served
+        gcTime: 0,
+        refetchOnWindowFocus: false,
+        retry: false,
+        // data is stale immediately,
+        // so React Query will refetch on triggers
+        staleTime: 0,
+    },
+};

package/dist/tui/lib/transport-logger.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Transport Event Logger
+ *
+ * Logs transport events to a file for debugging in development mode.
+ */
+/**
+ * Log a transport event to file (development mode only).
+ */
+export declare function logTransportEvent(eventName: string, data: unknown): void;
+/**
+ * Initialize the transport log file (clears previous content).
+ */
+export declare function initTransportLog(): void;