byterover-cli 1.7.2 → 2.0.0

package/dist/server/infra/usecase/query-use-case.d.ts

@@ -1,73 +0,0 @@
-import { type ConnectionResult } from '@campfirein/brv-transport-client';
-import type { BrvConfig } from '../../core/domain/entities/brv-config.js';
-import type { ITerminal } from '../../core/interfaces/services/i-terminal.js';
-import type { ITrackingService } from '../../core/interfaces/services/i-tracking-service.js';
-import type { IQueryUseCase, QueryUseCaseRunOptions } from '../../core/interfaces/usecase/i-query-use-case.js';
-import { CipherAgent } from '../../../agent/infra/agent/index.js';
-/** Type for transport connection function (for DI/testing) */
-export type TransportConnector = (fromDir?: string) => Promise<ConnectionResult>;
-/**
- * Structured query result for JSON output.
- */
-export interface QueryResult {
-    error?: string;
-    result?: string;
-    status: 'completed' | 'error';
-    toolCalls?: Array<{
-        status: string;
-        summary: string;
-        tool: string;
-    }>;
-}
-export interface QueryUseCaseOptions {
-    terminal: ITerminal;
-    trackingService: ITrackingService;
-    /** Optional transport connector for dependency injection (defaults to connectToTransport) */
-    transportConnector?: TransportConnector;
-}
-export declare class QueryUseCase implements IQueryUseCase {
-    private readonly terminal;
-    private readonly trackingService;
-    private readonly transportConnector;
-    constructor(options: QueryUseCaseOptions);
-    /**
-     * Create CipherAgent instance. Protected to allow test overrides.
-     */
-    protected createCipherAgent(llmConfig: any, brvConfig: BrvConfig): CipherAgent;
-    /**
-     * Generate a unique session ID for the query agent.
-     * Uses crypto.randomUUID() for guaranteed uniqueness (122 bits of entropy).
-     */
-    protected generateSessionId(): string;
-    run(options: QueryUseCaseRunOptions): Promise<void>;
-    /**
-     * Format a parsed object result into a concise summary.
-     */
-    private formatParsedResult;
-    /**
-     * Format tool arguments for display.
-     * Extract the most meaningful value for human reading.
-     */
-    private formatToolArgs;
-    /**
-     * Format tool result for display.
-     * Shows meaningful, concise summary - NEVER shows raw JSON.
-     */
-    private formatToolResult;
-    /**
-     * Handle connection-related errors with user-friendly messages.
-     */
-    private handleConnectionError;
-    /**
-     * Handle connection errors with JSON output.
-     */
-    private handleConnectionErrorJson;
-    /**
-     * Output JSON result for headless mode.
-     */
-    private outputJsonResult;
-    /**
-     * Stream task results from the connected instance.
-     */
-    private streamTaskResults;
-}

package/dist/server/infra/usecase/query-use-case.js

@@ -1,410 +0,0 @@
-import { ConnectionError, ConnectionFailedError, connectToTransport, InstanceCrashedError, NoInstanceRunningError, } from '@campfirein/brv-transport-client';
-import { randomUUID } from 'node:crypto';
-import { CipherAgent } from '../../../agent/infra/agent/index.js';
-import { formatError } from '../../utils/error-handler.js';
-import { getSandboxEnvironmentName, isSandboxEnvironment, isSandboxNetworkError } from '../../utils/sandbox-detector.js';
-import { InlineAgent } from '../process/inline-agent-executor.js';
-import { HeadlessTerminal } from '../terminal/headless-terminal.js';
-export class QueryUseCase {
-    terminal;
-    trackingService;
-    transportConnector;
-    constructor(options) {
-        this.terminal = options.terminal;
-        this.trackingService = options.trackingService;
-        this.transportConnector = options.transportConnector ?? connectToTransport;
-    }
-    /**
-     * Create CipherAgent instance. Protected to allow test overrides.
-     */
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    createCipherAgent(llmConfig, brvConfig) {
-        return new CipherAgent(llmConfig, brvConfig);
-    }
-    /**
-     * Generate a unique session ID for the query agent.
-     * Uses crypto.randomUUID() for guaranteed uniqueness (122 bits of entropy).
-     */
-    generateSessionId() {
-        return randomUUID();
-    }
-    async run(options) {
-        await this.trackingService.track('mem:query', { status: 'started' });
-        const format = options.format ?? 'text';
-        if (!options.query.trim()) {
-            if (format === 'json') {
-                this.outputJsonResult({ error: 'Query argument is required', status: 'error' });
-            }
-            else {
-                this.terminal.log('Query argument is required.');
-                this.terminal.log('Usage: brv query "your question here"');
-            }
-            return;
-        }
-        const verbose = options.verbose || false;
-        // Connect to running instance or create inline agent
-        let client;
-        try {
-            if (options.headless) {
-                const inlineAgent = await InlineAgent.create();
-                client = inlineAgent.transportClient;
-            }
-            else {
-                if (verbose) {
-                    this.terminal.log('Discovering running instance...');
-                }
-                // Use modern connectToTransport API (auto-discovers and connects)
-                const { client: connectedClient } = await this.transportConnector();
-                client = connectedClient;
-            }
-            if (verbose) {
-                this.terminal.log(`Connected to instance (clientId: ${client.getClientId()})`);
-            }
-            // Generate taskId in UseCase (Application layer owns task creation)
-            const taskId = randomUUID();
-            // Send task:create request
-            await client.requestWithAck('task:create', {
-                content: options.query,
-                taskId,
-                type: 'query',
-            });
-            // Note: response.taskId confirms what we sent (no longer extracting)
-            if (verbose) {
-                this.terminal.log(`Task created: ${taskId}`);
-            }
-            // Wait for task completion with streaming
-            await this.streamTaskResults(client, taskId, verbose, format);
-            await this.trackingService.track('mem:query', { status: 'finished' });
-        }
-        catch (error) {
-            if (format === 'json') {
-                this.handleConnectionErrorJson(error);
-            }
-            else {
-                this.handleConnectionError(error);
-            }
-            await this.trackingService.track('mem:query', { message: formatError(error), status: 'error' });
-        }
-        finally {
-            // Cleanup
-            if (client) {
-                await client.disconnect();
-            }
-        }
-    }
-    /**
-     * Format a parsed object result into a concise summary.
-     */
-    formatParsedResult(obj) {
-        // Check for common patterns
-        if ('topics' in obj && Array.isArray(obj.topics)) {
-            return `${obj.topics.length} topics found`;
-        }
-        if ('results' in obj && Array.isArray(obj.results)) {
-            return `${obj.results.length} matches`;
-        }
-        if ('matches' in obj && Array.isArray(obj.matches)) {
-            return `${obj.matches.length} matches`;
-        }
-        if ('filesSearched' in obj) {
-            const files = obj.filesSearched;
-            const matches = Array.isArray(obj.matches) ? obj.matches.length : 0;
-            return `${files} files searched, ${matches} matches`;
-        }
-        // glob_files returns {files: [...]}
-        if ('files' in obj && Array.isArray(obj.files)) {
-            return `${obj.files.length} files`;
-        }
-        // list_directory returns {entries: [...]}
-        if ('entries' in obj && Array.isArray(obj.entries)) {
-            return `${obj.entries.length} entries`;
-        }
-        // read_file returns {content: string, ...}
-        if ('content' in obj && typeof obj.content === 'string') {
-            const content = obj.content;
-            const lines = content.split('\n').length;
-            return `${lines} lines`;
-        }
-        if ('count' in obj) {
-            return `${obj.count} items`;
-        }
-        // Check for any array property as fallback
-        for (const key of Object.keys(obj)) {
-            if (Array.isArray(obj[key])) {
-                return `${obj[key].length} ${key}`;
-            }
-        }
-        // Generic object - just show it worked
-        return 'Done';
-    }
-    /**
-     * Format tool arguments for display.
-     * Extract the most meaningful value for human reading.
-     */
-    formatToolArgs(toolName, args) {
-        // Extract the most meaningful arg based on tool type
-        // Tool names use snake_case (LLM convention)
-        /* eslint-disable camelcase */
-        const meaningfulKeys = {
-            curate: ['operations'],
-            find_knowledge_topics: ['topicPattern', 'query'],
-            glob_files: ['pattern', 'glob'],
-            grep_content: ['pattern', 'query'],
-            list_directory: ['path', 'directory'],
-            read_file: ['filePath', 'path'],
-            read_knowledge_topic: ['topicPath', 'path'],
-        };
-        /* eslint-enable camelcase */
-        const keys = meaningfulKeys[toolName] ?? Object.keys(args);
-        for (const key of keys) {
-            if (args[key] !== undefined) {
-                const value = args[key];
-                if (typeof value === 'string') {
-                    // Clean display - just the value, truncated if needed
-                    return value.length > 40 ? `${value.slice(0, 37)}...` : value;
-                }
-                if (Array.isArray(value)) {
-                    return `${value.length} items`;
-                }
-            }
-        }
-        return '';
-    }
-    /**
-     * Format tool result for display.
-     * Shows meaningful, concise summary - NEVER shows raw JSON.
-     */
-    formatToolResult(payload) {
-        if (!payload.success) {
-            const errMsg = payload.error ?? 'Failed';
-            return errMsg.length > 50 ? `${errMsg.slice(0, 47)}...` : errMsg;
-        }
-        if (!payload.result)
-            return 'Done';
-        // Handle different result types with concise output
-        if (Array.isArray(payload.result)) {
-            return `${payload.result.length} results`;
-        }
-        // Handle string results - might be JSON
-        if (typeof payload.result === 'string') {
-            // Try to parse as JSON for better formatting
-            try {
-                const parsed = JSON.parse(payload.result);
-                return this.formatParsedResult(parsed);
-            }
-            catch {
-                // Not JSON - show char count for long strings
-                if (payload.result.length > 100) {
-                    return `${payload.result.length} chars`;
-                }
-                return payload.result.length > 40 ? `${payload.result.slice(0, 37)}...` : payload.result;
-            }
-        }
-        if (typeof payload.result === 'object') {
-            return this.formatParsedResult(payload.result);
-        }
-        return 'Done';
-    }
-    /**
-     * Handle connection-related errors with user-friendly messages.
-     */
-    handleConnectionError(error) {
-        if (error instanceof NoInstanceRunningError) {
-            // Check if running in sandbox environment
-            if (isSandboxEnvironment()) {
-                const sandboxName = getSandboxEnvironmentName();
-                this.terminal.log(`Error: No ByteRover instance is running.\n` +
-                    `⚠️  Sandbox environment detected (${sandboxName}).\n\n` +
-                    `Please run 'brv' command in a separate terminal window/tab outside the sandbox first.`);
-            }
-            else {
-                this.terminal.log('No ByteRover instance is running.\n\n' +
-                    'Start a ByteRover instance by running "brv" in a separate terminal window/tab.\n' +
-                    'The instance will keep running and handle your commands.');
-            }
-            return;
-        }
-        if (error instanceof InstanceCrashedError) {
-            this.terminal.log('ByteRover instance has crashed.\n\nPlease restart with: brv');
-            return;
-        }
-        if (error instanceof ConnectionFailedError) {
-            // Check if it's specifically a sandbox network restriction error
-            const isSandboxError = isSandboxNetworkError(error.originalError ?? error);
-            if (isSandboxError) {
-                const sandboxName = getSandboxEnvironmentName();
-                this.terminal.log(`Error: Failed to connect to ByteRover instance.\n` +
-                    `Port: ${error.port ?? 'unknown'}\n` +
-                    `⚠️  Sandbox network restriction detected (${sandboxName}).\n\n` +
-                    `Please allow network access in the sandbox and retry the command.`);
-            }
-            else {
-                this.terminal.log(`Failed to connect to ByteRover instance: ${error.message}`);
-            }
-            return;
-        }
-        if (error instanceof ConnectionError) {
-            this.terminal.log(`Connection error: ${error.message}`);
-            return;
-        }
-        // Unknown error
-        const message = error instanceof Error ? error.message : String(error);
-        this.terminal.log(`Unexpected error: ${message}`);
-    }
-    /**
-     * Handle connection errors with JSON output.
-     */
-    handleConnectionErrorJson(error) {
-        let errorMessage = 'An unexpected error occurred';
-        if (error instanceof NoInstanceRunningError) {
-            errorMessage = 'No ByteRover instance is running. Start one with: brv';
-        }
-        else if (error instanceof InstanceCrashedError) {
-            errorMessage = 'ByteRover instance has crashed. Please restart with: brv';
-        }
-        else if (error instanceof ConnectionFailedError) {
-            errorMessage = `Failed to connect to ByteRover instance: ${error.message}`;
-        }
-        else if (error instanceof ConnectionError) {
-            errorMessage = `Connection error: ${error.message}`;
-        }
-        else if (error instanceof Error) {
-            errorMessage = error.message;
-        }
-        this.outputJsonResult({ error: errorMessage, status: 'error' });
-    }
-    /**
-     * Output JSON result for headless mode.
-     */
-    outputJsonResult(result) {
-        const response = {
-            command: 'query',
-            data: result,
-            success: result.status !== 'error',
-            timestamp: new Date().toISOString(),
-        };
-        if (this.terminal instanceof HeadlessTerminal) {
-            this.terminal.writeFinalResponse(response);
-        }
-        else {
-            this.terminal.log(JSON.stringify(response));
-        }
-    }
-    /**
-     * Stream task results from the connected instance.
-     */
-    async streamTaskResults(client, taskId, verbose, format = 'text') {
-        return new Promise((resolve, reject) => {
-            let completed = false;
-            let resultPrinted = false; // Track if we've already printed the result
-            let finalResult;
-            const toolCalls = [];
-            // Timeout after 5 minutes
-            const timeout = setTimeout(() => {
-                if (!completed) {
-                    completed = true;
-                    cleanup();
-                    if (format === 'json') {
-                        this.outputJsonResult({ error: 'Task timed out after 5 minutes', status: 'error' });
-                        resolve();
-                    }
-                    else {
-                        reject(new Error('Task timed out after 5 minutes'));
-                    }
-                }
-            }, 5 * 60 * 1000);
-            // Setup all event handlers
-            const unsubscribers = [
-                // task:ack - immediate acknowledgment
-                client.on('task:ack', (payload) => {
-                    if (payload.taskId === taskId && verbose) {
-                        this.terminal.log('Task acknowledged by server');
-                    }
-                }),
-                // task:started - task is being processed
-                client.on('task:started', (payload) => {
-                    if (payload.taskId === taskId && verbose) {
-                        this.terminal.log('Task started processing...');
-                    }
-                }),
-                // llmservice:response - final response from LLM (only print once)
-                client.on('llmservice:response', (payload) => {
-                    if (payload.taskId === taskId && payload.content && !resultPrinted) {
-                        resultPrinted = true;
-                        finalResult = payload.content;
-                        if (format === 'text') {
-                            this.terminal.log('\nResult:');
-                            this.terminal.log(payload.content);
-                        }
-                    }
-                }),
-                // llmservice:toolCall - tool invocation (stop showing after response)
-                client.on('llmservice:toolCall', (payload) => {
-                    if (payload.taskId === taskId && !resultPrinted) {
-                        const detail = payload.args ? this.formatToolArgs(payload.toolName, payload.args) : '';
-                        const suffix = detail ? `: ${detail}` : '';
-                        if (format === 'text') {
-                            this.terminal.log(`🔧 ${payload.toolName}${suffix}`);
-                        }
-                        // Track tool call for JSON output
-                        toolCalls.push({ status: 'started', summary: suffix, tool: payload.toolName });
-                    }
-                }),
-                // llmservice:toolResult - tool result with summary (stop showing after response)
-                client.on('llmservice:toolResult', (payload) => {
-                    if (payload.taskId === taskId && !resultPrinted) {
-                        const status = payload.success ? '✓' : '✗';
-                        const resultSummary = this.formatToolResult(payload);
-                        if (format === 'text') {
-                            this.terminal.log(`  ${status} ${resultSummary}`);
-                        }
-                        // Update last tool call with result
-                        const lastCall = toolCalls.at(-1);
-                        if (lastCall) {
-                            lastCall.status = payload.success ? 'success' : 'failed';
-                            lastCall.summary = resultSummary;
-                        }
-                    }
-                }),
-                // task:completed - task finished (chunks already streamed, just resolve)
-                client.on('task:completed', (payload) => {
-                    if (payload.taskId === taskId && !completed) {
-                        completed = true;
-                        cleanup();
-                        if (format === 'json') {
-                            this.outputJsonResult({
-                                result: finalResult,
-                                status: 'completed',
-                                toolCalls: toolCalls.length > 0 ? toolCalls : undefined,
-                            });
-                        }
-                        else {
-                            this.terminal.log(''); // Final newline for clean output
-                        }
-                        resolve();
-                    }
-                }),
-                // task:error - task failed
-                client.on('task:error', (payload) => {
-                    if (payload.taskId === taskId && !completed) {
-                        completed = true;
-                        cleanup();
-                        if (format === 'json') {
-                            this.outputJsonResult({ error: payload.error.message, status: 'error' });
-                            resolve();
-                        }
-                        else {
-                            reject(new Error(payload.error.message));
-                        }
-                    }
-                }),
-                // Clear timeout when done
-                () => clearTimeout(timeout),
-            ];
-            const cleanup = () => {
-                for (const unsub of unsubscribers)
-                    unsub();
-            };
-        });
-    }
-}

package/dist/server/infra/usecase/reset-use-case.d.ts

@@ -1,21 +0,0 @@
-import type { IContextTreeService } from '../../core/interfaces/context-tree/i-context-tree-service.js';
-import type { IContextTreeSnapshotService } from '../../core/interfaces/context-tree/i-context-tree-snapshot-service.js';
-import type { ITerminal } from '../../core/interfaces/services/i-terminal.js';
-import type { IResetUseCase } from '../../core/interfaces/usecase/i-reset-use-case.js';
-export interface ResetUseCaseOptions {
-    contextTreeService: IContextTreeService;
-    contextTreeSnapshotService: IContextTreeSnapshotService;
-    terminal: ITerminal;
-}
-export declare class ResetUseCase implements IResetUseCase {
-    private readonly contextTreeService;
-    private readonly contextTreeSnapshotService;
-    private readonly terminal;
-    constructor(options: ResetUseCaseOptions);
-    protected confirmReset(): Promise<boolean>;
-    protected deleteContextTree(contextTreeDir: string): Promise<void>;
-    run(options: {
-        directory?: string;
-        skipConfirmation: boolean;
-    }): Promise<void>;
-}

package/dist/server/infra/usecase/reset-use-case.js

@@ -1,60 +0,0 @@
-import { rm } from 'node:fs/promises';
-import { join } from 'node:path';
-import { BRV_DIR, CONTEXT_TREE_DIR } from '../../constants.js';
-export class ResetUseCase {
-    contextTreeService;
-    contextTreeSnapshotService;
-    terminal;
-    constructor(options) {
-        this.contextTreeService = options.contextTreeService;
-        this.contextTreeSnapshotService = options.contextTreeSnapshotService;
-        this.terminal = options.terminal;
-    }
-    // Protected method for testability - can be overridden in tests
-    async confirmReset() {
-        return this.terminal.confirm({
-            default: false,
-            message: 'Are you sure you want to reset the context tree? This will remove all existing context. Your context tree will be empty.',
-        });
-    }
-    async deleteContextTree(contextTreeDir) {
-        await rm(contextTreeDir, { force: true, recursive: true });
-    }
-    async run(options) {
-        try {
-            // Check if context tree exists
-            const exists = await this.contextTreeService.exists(options.directory);
-            if (!exists) {
-                this.terminal.log('No context tree found. Nothing to reset.');
-                return;
-            }
-            // Confirmation prompt (unless skipConfirmation is true)
-            if (!options.skipConfirmation) {
-                const confirmed = await this.confirmReset();
-                if (!confirmed) {
-                    this.terminal.log('Cancelled. Context tree was not reset.');
-                    return;
-                }
-            }
-            // Remove existing context tree directory
-            const baseDir = options.directory ?? process.cwd();
-            const contextTreeDir = join(baseDir, BRV_DIR, CONTEXT_TREE_DIR);
-            await this.deleteContextTree(contextTreeDir);
-            // Re-initialize empty context tree
-            await this.contextTreeService.initialize(options.directory);
-            // Re-initialize empty snapshot
-            await this.contextTreeSnapshotService.initEmptySnapshot(options.directory);
-            this.terminal.log('✓ Context tree reset successfully. Your context tree is now empty.');
-        }
-        catch (error) {
-            // Handle user cancelling the prompt (Ctrl+C or closing stdin)
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            if (errorMessage.includes('User force closed') || errorMessage.includes('force closed')) {
-                this.terminal.log('Cancelled. Context tree was not reset.');
-                return;
-            }
-            // For other errors, log error message
-            this.terminal.error(error instanceof Error ? error.message : 'Failed to reset context tree');
-        }
-    }
-}

package/dist/server/infra/usecase/space-list-use-case.d.ts

@@ -1,27 +0,0 @@
-import type { ITokenStore } from '../../core/interfaces/auth/i-token-store.js';
-import type { ISpaceService } from '../../core/interfaces/services/i-space-service.js';
-import type { ITerminal } from '../../core/interfaces/services/i-terminal.js';
-import type { IProjectConfigStore } from '../../core/interfaces/storage/i-project-config-store.js';
-import type { ISpaceListUseCase } from '../../core/interfaces/usecase/i-space-list-use-case.js';
-export interface SpaceListFlags {
-    all: boolean;
-    json: boolean;
-    limit: number;
-    offset: number;
-}
-export interface SpaceListUseCaseDependencies {
-    flags: SpaceListFlags;
-    projectConfigStore: IProjectConfigStore;
-    spaceService: ISpaceService;
-    terminal: ITerminal;
-    tokenStore: ITokenStore;
-}
-export declare class SpaceListUseCase implements ISpaceListUseCase {
-    private readonly flags;
-    private readonly projectConfigStore;
-    private readonly spaceService;
-    private readonly terminal;
-    private readonly tokenStore;
-    constructor(deps: SpaceListUseCaseDependencies);
-    run(): Promise<void>;
-}

package/dist/server/infra/usecase/space-list-use-case.js

@@ -1,64 +0,0 @@
-export class SpaceListUseCase {
-    flags;
-    projectConfigStore;
-    spaceService;
-    terminal;
-    tokenStore;
-    constructor(deps) {
-        this.flags = deps.flags;
-        this.projectConfigStore = deps.projectConfigStore;
-        this.spaceService = deps.spaceService;
-        this.terminal = deps.terminal;
-        this.tokenStore = deps.tokenStore;
-    }
-    async run() {
-        // Check project initialization
-        const projectConfig = await this.projectConfigStore.read();
-        if (!projectConfig) {
-            this.terminal.error('Project not initialized. Please run "/init" first.');
-            return;
-        }
-        const token = await this.tokenStore.load();
-        if (!token) {
-            this.terminal.error('Not authenticated. Please run "/login" first.');
-            return;
-        }
-        if (!token.isValid()) {
-            this.terminal.error('Authentication token expired. Please run "/login" again.');
-            return;
-        }
-        // Fetch spaces for the team from project config
-        this.terminal.actionStart(`Fetching spaces for ${projectConfig.teamName}`);
-        const result = await this.spaceService.getSpaces(token.sessionKey, projectConfig.teamId, this.flags.all ? { fetchAll: true } : { limit: this.flags.limit, offset: this.flags.offset });
-        this.terminal.actionStop();
-        // Handle empty results
-        if (result.spaces.length === 0) {
-            this.terminal.log(`No spaces found in team "${projectConfig.teamName}".`);
-            return;
-        }
-        // Display results based on format
-        if (this.flags.json) {
-            this.terminal.log(JSON.stringify({
-                showing: result.spaces.length,
-                spaces: result.spaces.map((s) => s.toJson()),
-                team: { id: projectConfig.teamId, name: projectConfig.teamName },
-                total: result.total,
-            }, null, 2));
-            return;
-        }
-        // Human-readable format
-        this.terminal.log(`\nSpaces in team "${projectConfig.teamName}":\n`);
-        this.terminal.log(`Found ${result.spaces.length} space(s):\n`);
-        for (const [index, space] of result.spaces.entries()) {
-            this.terminal.log(`  ${index + 1}. ${space.getDisplayName()}`);
-        }
-        // Pagination warning
-        if (!this.flags.all && result.spaces.length < result.total) {
-            const remaining = result.total - result.spaces.length - this.flags.offset;
-            this.terminal.log(`\nShowing ${result.spaces.length} of ${result.total} spaces.`);
-            if (remaining > 0) {
-                this.terminal.log('Use --all to fetch all spaces, or use --limit and --offset for pagination.');
-            }
-        }
-    }
-}