byterover-cli 1.7.2 → 2.0.0

package/dist/tui/features/space/components/space-switch-flow.d.ts

@@ -0,0 +1,13 @@
+/**
+ * SpaceSwitchFlow Component
+ *
+ * React flow for the /space switch command.
+ * Fetches spaces → renders selection → switches config → pulls context from new space.
+ */
+import React from 'react';
+export interface SpaceSwitchFlowProps {
+    isActive?: boolean;
+    onCancel: () => void;
+    onComplete: (message: string) => void;
+}
+export declare const SpaceSwitchFlow: React.FC<SpaceSwitchFlowProps>;

package/dist/tui/features/space/components/space-switch-flow.js

@@ -0,0 +1,97 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+/**
+ * SpaceSwitchFlow Component
+ *
+ * React flow for the /space switch command.
+ * Fetches spaces → renders selection → switches config → pulls context from new space.
+ */
+import { Box, Text } from 'ink';
+import Spinner from 'ink-spinner';
+import { useCallback, useEffect, useMemo, useState } from 'react';
+import { PullEvents } from '../../../../shared/transport/events/index.js';
+import { SelectableList } from '../../../components/selectable-list.js';
+import { useTheme } from '../../../hooks/index.js';
+import { BRV_DIR, CONTEXT_TREE_CONFLICT_DIR } from '../../../lib/environment.js';
+import { useTransportStore } from '../../../stores/transport-store.js';
+import { formatTransportError } from '../../../utils/error-messages.js';
+import { useGetSpaces } from '../api/get-spaces.js';
+import { useSwitchSpace } from '../api/switch-space.js';
+export const SpaceSwitchFlow = ({ isActive = true, onCancel, onComplete }) => {
+    const { theme: { colors }, } = useTheme();
+    const [error, setError] = useState(null);
+    const [step, setStep] = useState('selecting');
+    const [selectedSpaceId, setSelectedSpaceId] = useState(null);
+    const [progressMessages, setProgressMessages] = useState([]);
+    const { data, error: fetchError, isLoading } = useGetSpaces();
+    const switchMutation = useSwitchSpace();
+    const allSpaces = useMemo(() => (data?.teams ?? []).flatMap((t) => t.spaces), [data]);
+    // Handle fetch error (e.g., not authenticated, not initialized)
+    useEffect(() => {
+        if (fetchError) {
+            onComplete(formatTransportError(fetchError));
+        }
+    }, [fetchError, onComplete]);
+    // Auto-complete if no spaces
+    useEffect(() => {
+        if (!isLoading && allSpaces.length === 0 && data) {
+            onComplete('No spaces found. Please create a space in the ByteRover dashboard first.');
+        }
+    }, [allSpaces.length, data, isLoading, onComplete]);
+    const spaceItems = useMemo(() => allSpaces.map((s) => ({ description: s.isDefault ? '(default)' : '', id: s.id, name: `${s.teamName}/${s.name}` })), [allSpaces]);
+    // Subscribe to pull progress and execute switch
+    useEffect(() => {
+        if (step !== 'executing' || !selectedSpaceId)
+            return;
+        const { apiClient } = useTransportStore.getState();
+        let unsubProgress;
+        if (apiClient) {
+            unsubProgress = apiClient.on(PullEvents.PROGRESS, (progressData) => {
+                setProgressMessages((prev) => [...prev, progressData.message]);
+            });
+        }
+        switchMutation.mutate({ spaceId: selectedSpaceId }, {
+            onError(error_) {
+                unsubProgress?.();
+                setStep('selecting');
+                setError(formatTransportError(error_));
+            },
+            onSuccess(result) {
+                unsubProgress?.();
+                if (!result.success) {
+                    onComplete(`Failed to switch space: ${result.pullError ?? 'Unknown error'}`);
+                    return;
+                }
+                const spaceLine = `Successfully switched to space: ${result.config.spaceName}`;
+                let pullLine;
+                if (result.pullResult) {
+                    pullLine = `Pulled: +${result.pullResult.added} ~${result.pullResult.edited} -${result.pullResult.deleted}`;
+                    if (result.pullResult.conflicted) {
+                        pullLine += `\n  ${result.pullResult.conflicted} conflict(s) auto-merged — review ${BRV_DIR}/${CONTEXT_TREE_CONFLICT_DIR}/ for original files`;
+                    }
+                }
+                else {
+                    pullLine = 'No remote context found.';
+                }
+                onComplete(`${spaceLine}\n${pullLine}\nConfiguration updated in: .brv/config.json`);
+            },
+        });
+        return () => {
+            unsubProgress?.();
+        };
+    }, [step, selectedSpaceId]);
+    const handleSelect = useCallback((item) => {
+        setError(null);
+        setSelectedSpaceId(item.id);
+        setStep('executing');
+    }, []);
+    if (isLoading) {
+        return (_jsx(Box, { children: _jsx(Text, { color: colors.dimText, children: "Fetching spaces..." }) }));
+    }
+    if (allSpaces.length === 0) {
+        return (_jsx(Box, { children: _jsx(Text, { color: colors.dimText, children: "Loading..." }) }));
+    }
+    if (step === 'executing') {
+        return (_jsxs(_Fragment, { children: [progressMessages.map((msg, i) => (_jsx(Text, { children: msg }, i))), _jsxs(Text, { children: [_jsx(Spinner, { type: "dots" }), " Switching space..."] })] }));
+    }
+    return (_jsxs(Box, { flexDirection: "column", children: [error && (_jsx(Box, { marginBottom: 1, children: _jsx(Text, { color: colors.errorText, children: error }) })), _jsx(SelectableList, { filterKeys: (item) => [item.id, item.name], getCurrentKey: (item) => item.id, isActive: isActive, items: spaceItems, keyExtractor: (item) => item.id, onCancel: onCancel, onSelect: handleSelect, renderItem: (item, isHighlighted) => (_jsxs(Box, { gap: 2, children: [_jsx(Text, { backgroundColor: isHighlighted ? colors.dimText : undefined, color: colors.text, children: item.name }), item.description && _jsx(Text, { color: colors.dimText, children: item.description })] })), title: "Select a space" })] }));
+};

package/dist/tui/features/status/api/get-status.d.ts

@@ -0,0 +1,16 @@
+import type { QueryConfig } from '../../../lib/react-query.js';
+import { type StatusGetResponse } from '../../../../shared/transport/events/index.js';
+export declare const getStatus: () => Promise<StatusGetResponse>;
+export declare const getStatusQueryOptions: () => import("@tanstack/react-query").OmitKeyof<import("@tanstack/react-query").UseQueryOptions<StatusGetResponse, Error, StatusGetResponse, string[]>, "queryFn"> & {
+    queryFn?: import("@tanstack/react-query").QueryFunction<StatusGetResponse, string[], never> | undefined;
+} & {
+    queryKey: string[] & {
+        [dataTagSymbol]: StatusGetResponse;
+        [dataTagErrorSymbol]: Error;
+    };
+};
+type UseGetStatusOptions = {
+    queryConfig?: QueryConfig<typeof getStatusQueryOptions>;
+};
+export declare const useGetStatus: ({ queryConfig }?: UseGetStatusOptions) => import("@tanstack/react-query").UseQueryResult<StatusGetResponse, Error>;
+export {};

package/dist/tui/features/status/api/get-status.js

@@ -0,0 +1,17 @@
+import { queryOptions, useQuery } from '@tanstack/react-query';
+import { StatusEvents } from '../../../../shared/transport/events/index.js';
+import { useTransportStore } from '../../../stores/transport-store.js';
+export const getStatus = () => {
+    const { apiClient } = useTransportStore.getState();
+    if (!apiClient)
+        return Promise.reject(new Error('Not connected'));
+    return apiClient.request(StatusEvents.GET);
+};
+export const getStatusQueryOptions = () => queryOptions({
+    queryFn: getStatus,
+    queryKey: ['status'],
+});
+export const useGetStatus = ({ queryConfig } = {}) => useQuery({
+    ...getStatusQueryOptions(),
+    ...queryConfig,
+});

package/dist/tui/features/status/components/status-view.d.ts

@@ -0,0 +1,12 @@
+/**
+ * StatusView Component
+ *
+ * Fetches CLI status and displays it, then calls onComplete.
+ */
+import React from 'react';
+import type { CustomDialogCallbacks } from '../../../types/commands.js';
+interface StatusViewProps extends CustomDialogCallbacks {
+    version?: string;
+}
+export declare function StatusView({ onComplete, version }: StatusViewProps): React.ReactNode;
+export {};

package/dist/tui/features/status/components/status-view.js

@@ -0,0 +1,26 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * StatusView Component
+ *
+ * Fetches CLI status and displays it, then calls onComplete.
+ */
+import { Text } from 'ink';
+import Spinner from 'ink-spinner';
+import { useEffect } from 'react';
+import { useGetStatus } from '../api/get-status.js';
+import { formatStatus } from '../utils/format-status.js';
+export function StatusView({ onComplete, version }) {
+    const { data, error, isLoading } = useGetStatus();
+    useEffect(() => {
+        if (data) {
+            onComplete(formatStatus(data.status, version));
+        }
+        if (error) {
+            onComplete(`Failed to get status: ${error.message}`);
+        }
+    }, [data, error, onComplete, version]);
+    if (isLoading) {
+        return (_jsxs(Text, { children: [_jsx(Spinner, { type: "dots" }), " Loading status..."] }));
+    }
+    return null;
+}

package/dist/tui/features/status/utils/format-status.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Pure formatting function for CLI status output.
+ */
+import type { StatusDTO } from '../../../../shared/transport/types/dto.js';
+export declare function formatStatus(status: StatusDTO, version?: string): string;

package/dist/tui/features/status/utils/format-status.js

@@ -0,0 +1,62 @@
+/**
+ * Pure formatting function for CLI status output.
+ */
+import chalk from 'chalk';
+export function formatStatus(status, version) {
+    const lines = [];
+    lines.push(`CLI Version: ${version ?? ''}`);
+    switch (status.authStatus) {
+        case 'expired': {
+            lines.push('Account: Session expired');
+            break;
+        }
+        case 'logged_in': {
+            lines.push(`Account: ${status.userEmail}`);
+            break;
+        }
+        case 'not_logged_in': {
+            lines.push('Account: Not logged in');
+            break;
+        }
+        default: {
+            lines.push('Account: Unable to check');
+        }
+    }
+    lines.push(`Current Directory: ${status.currentDirectory}`);
+    if (status.teamName && status.spaceName) {
+        lines.push(`Space: ${status.teamName}/${status.spaceName}`);
+    }
+    else {
+        lines.push('Space: Not connected');
+    }
+    switch (status.contextTreeStatus) {
+        case 'has_changes': {
+            if (status.contextTreeChanges && status.contextTreeRelativeDir) {
+                const { added, deleted, modified } = status.contextTreeChanges;
+                const formatPath = (file) => `${status.contextTreeRelativeDir}/${file}`;
+                const allChanges = [
+                    ...modified.map((f) => ({ color: chalk.red, path: f, status: 'modified:' })),
+                    ...added.map((f) => ({ color: chalk.red, path: f, status: 'new file:' })),
+                    ...deleted.map((f) => ({ color: chalk.red, path: f, status: 'deleted:' })),
+                ].sort((a, b) => a.path.localeCompare(b.path));
+                lines.push('Context Tree Changes:');
+                for (const change of allChanges) {
+                    lines.push(`   ${change.color(`${change.status.padEnd(10)} ${formatPath(change.path)}`)}`);
+                }
+            }
+            break;
+        }
+        case 'no_changes': {
+            lines.push('Context Tree: No changes');
+            break;
+        }
+        case 'not_initialized': {
+            lines.push('Context Tree: Not initialized');
+            break;
+        }
+        default: {
+            lines.push('Context Tree: Unable to check status');
+        }
+    }
+    return lines.join('\n');
+}

package/dist/tui/features/tasks/components/task-subscription-initializer.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Invisible component that subscribes the tasks Zustand store to transport events.
+ * Place this inside the TransportProvider tree.
+ */
+export declare function TaskSubscriptionInitializer(): null;

package/dist/tui/features/tasks/components/task-subscription-initializer.js

@@ -0,0 +1,9 @@
+/**
+ * Invisible component that subscribes the tasks Zustand store to transport events.
+ * Place this inside the TransportProvider tree.
+ */
+import { useTaskSubscriptions } from '../hooks/use-task-subscriptions.js';
+export function TaskSubscriptionInitializer() {
+    useTaskSubscriptions();
+    return null;
+}

package/dist/tui/features/tasks/hooks/use-task-subscriptions.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Hook that subscribes the tasks Zustand store to transport events.
+ * Call this once from a top-level component to wire up task lifecycle events.
+ */
+export declare function useTaskSubscriptions(): void;

package/dist/tui/features/tasks/hooks/use-task-subscriptions.js

@@ -0,0 +1,74 @@
+/**
+ * Hook that subscribes the tasks Zustand store to transport events.
+ * Call this once from a top-level component to wire up task lifecycle events.
+ */
+import { useEffect } from 'react';
+import { useTransportStore } from '../../../stores/transport-store.js';
+import { useTasksStore } from '../stores/tasks-store.js';
+export function useTaskSubscriptions() {
+    const client = useTransportStore((s) => s.client);
+    useEffect(() => {
+        if (!client)
+            return;
+        const store = useTasksStore.getState();
+        const unsubscribers = [];
+        unsubscribers.push(client.on('task:created', (data) => {
+            store.createTask(data.taskId, data.type, data.content, data.files);
+        }), client.on('task:started', (data) => {
+            store.setStarted(data.taskId);
+        }), client.on('task:completed', (data) => {
+            store.setCompleted(data.taskId, data.result);
+        }), client.on('task:error', (data) => {
+            store.setError(data.taskId, data.error);
+        }), client.on('task:cancelled', (data) => {
+            store.setCancelled(data.taskId);
+        }), client.on('llmservice:toolCall', (data) => {
+            if (!data.taskId)
+                return;
+            store.addToolCall(data.taskId, {
+                args: data.args,
+                callId: data.callId,
+                sessionId: data.sessionId,
+                status: 'running',
+                timestamp: Date.now(),
+                toolName: data.toolName,
+            });
+        }), client.on('llmservice:toolResult', (data) => {
+            if (!data.taskId)
+                return;
+            store.updateToolCallResult({
+                callId: data.callId,
+                error: data.error,
+                errorType: data.errorType,
+                result: data.result,
+                success: data.success,
+                taskId: data.taskId,
+                toolName: data.toolName,
+            });
+        }), client.on('llmservice:response', (data) => {
+            if (!data.taskId)
+                return;
+            store.setResponse(data.taskId, data.content, data.sessionId);
+        }), client.on('llmservice:thinking', (data) => {
+            store.addReasoningContent(data.taskId, {
+                content: '',
+                isThinking: true,
+                timestamp: Date.now(),
+            });
+        }), client.on('llmservice:chunk', (data) => {
+            if (!data.taskId)
+                return;
+            store.appendStreamingContent({
+                content: data.content,
+                isComplete: data.isComplete ?? false,
+                sessionId: data.sessionId,
+                taskId: data.taskId,
+                type: data.type === 'reasoning' ? 'reasoning' : 'text',
+            });
+        }));
+        return () => {
+            for (const unsub of unsubscribers)
+                unsub();
+        };
+    }, [client]);
+}

package/dist/tui/features/tasks/stores/tasks-store.d.ts

@@ -0,0 +1,92 @@
+/**
+ * Tasks Store
+ *
+ * Zustand store for task lifecycle state.
+ * Subscribes to task:* and llmservice:* transport events.
+ */
+import type { TaskStats } from '../../../types/ui.js';
+export type TaskStatus = 'cancelled' | 'completed' | 'created' | 'error' | 'started';
+export interface ToolCallEvent {
+    args: Record<string, unknown>;
+    callId?: string;
+    error?: string;
+    errorType?: string;
+    result?: unknown;
+    sessionId: string;
+    status: 'completed' | 'error' | 'running';
+    timestamp: number;
+    toolName: string;
+}
+export interface ReasoningContentItem {
+    content: string;
+    isThinking?: boolean;
+    timestamp: number;
+}
+export interface TaskErrorData {
+    code?: string;
+    message: string;
+}
+export interface Task {
+    completedAt?: number;
+    content: string;
+    createdAt: number;
+    error?: TaskErrorData;
+    files?: string[];
+    folders?: string[];
+    input: string;
+    isStreaming?: boolean;
+    reasoningContents?: ReasoningContentItem[];
+    result?: string;
+    sessionId?: string;
+    startedAt?: number;
+    status: TaskStatus;
+    streamingContent?: string;
+    taskId: string;
+    toolCalls: ToolCallEvent[];
+    type: 'curate' | 'query';
+}
+export interface TasksState {
+    stats: TaskStats;
+    tasks: Map<string, Task>;
+}
+export interface TasksActions {
+    /** Add a reasoning content item to a task */
+    addReasoningContent: (taskId: string, item: ReasoningContentItem) => void;
+    /** Add or update a tool call on a task */
+    addToolCall: (taskId: string, toolCall: ToolCallEvent) => void;
+    /** Append streaming content to a task */
+    appendStreamingContent: (params: {
+        content: string;
+        isComplete: boolean;
+        sessionId?: string;
+        taskId: string;
+        type: 'reasoning' | 'text';
+    }) => void;
+    /** Clear all tasks */
+    clearTasks: () => void;
+    /** Create a new task */
+    createTask: (taskId: string, type: 'curate' | 'query', content: string, files?: string[]) => void;
+    /** Get a task by ID */
+    getTask: (taskId: string) => Task | undefined;
+    /** Set task to cancelled */
+    setCancelled: (taskId: string) => void;
+    /** Set task to completed with result */
+    setCompleted: (taskId: string, result?: string) => void;
+    /** Set task error */
+    setError: (taskId: string, error: TaskErrorData) => void;
+    /** Set task LLM response (final) */
+    setResponse: (taskId: string, content: string, sessionId?: string) => void;
+    /** Set task to started */
+    setStarted: (taskId: string) => void;
+    /** Update a tool call result */
+    updateToolCallResult: (params: {
+        callId: string | undefined;
+        error?: string;
+        errorType?: string;
+        result?: unknown;
+        success: boolean;
+        taskId: string;
+        toolName: string;
+    }) => void;
+}
+export declare const useTasksStore: import("zustand").UseBoundStore<import("zustand").StoreApi<TasksActions & TasksState>>;