byterover-cli 0.4.0 → 1.0.0

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

@@ -1,21 +1,17 @@
 import { randomUUID } from 'node:crypto';
-import { getCurrentConfig } from '../../config/environment.js';
-import { PROJECT } from '../../constants.js';
+import { ConnectionError, ConnectionFailedError, InstanceCrashedError, NoInstanceRunningError, } from '../../core/domain/errors/connection-error.js';
 import { formatError } from '../../utils/error-handler.js';
-import { formatToolCall, formatToolResult } from '../../utils/tool-display-formatter.js';
-import { CipherAgent } from '../cipher/cipher-agent.js';
-import { getAgentStorage, getAgentStorageSync } from '../cipher/storage/agent-storage.js';
-import { WorkspaceNotInitializedError } from '../cipher/validation/workspace-validator.js';
+import { getSandboxEnvironmentName, isSandboxEnvironment, isSandboxNetworkError } from '../../utils/sandbox-detector.js';
+import { CipherAgent } from '../cipher/agent/index.js';
+import { createTransportClientFactory } from '../transport/transport-client-factory.js';
 export class QueryUseCase {
-    projectConfigStore;
     terminal;
-    tokenStore;
     trackingService;
+    transportClientFactoryCreator;
     constructor(options) {
-        this.projectConfigStore = options.projectConfigStore;
         this.terminal = options.terminal;
-        this.tokenStore = options.tokenStore;
         this.trackingService = options.trackingService;
+        this.transportClientFactoryCreator = options.transportClientFactoryCreator ?? createTransportClientFactory;
     }
     /**
      * Create CipherAgent instance. Protected to allow test overrides.
@@ -32,370 +28,299 @@ export class QueryUseCase {
         return randomUUID();
     }
     async run(options) {
-        // Initialize storage for tool call tracking (auto-detects .brv/blobs)
-        const storage = await getAgentStorage();
-        let executionId = null;
+        await this.trackingService.track('mem:query', { status: 'started' });
+        if (!options.query.trim()) {
+            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
+        let client;
         try {
-            // Get authentication token
-            const token = await this.tokenStore.load();
-            if (!token) {
-                this.terminal.log('Authentication required. Please run "brv login" first.');
-                return;
-            }
-            // Load project config
-            const brvConfig = await this.projectConfigStore.read();
-            // Validate workspace is initialized
-            if (!brvConfig) {
-                throw new WorkspaceNotInitializedError('Project not initialized. Please run "brv init" to select your team and workspace.', '.brv');
+            const transportClientFactory = this.transportClientFactoryCreator();
+            if (verbose) {
+                this.terminal.log('Discovering running instance...');
             }
-            // Create execution with status='running' (query runs synchronously)
-            executionId = storage.createExecution('query', options.query);
-            // Create LLM config
-            const model = options.model ?? (options.apiKey ? 'google/gemini-2.5-pro' : 'gemini-2.5-pro');
-            const envConfig = getCurrentConfig();
-            const llmConfig = {
-                accessToken: token.accessToken,
-                apiBaseUrl: envConfig.llmApiBaseUrl,
-                fileSystemConfig: { workingDirectory: process.cwd() },
-                maxIterations: 5,
-                maxTokens: 2048,
-                model,
-                openRouterApiKey: options.apiKey,
-                projectId: PROJECT,
-                sessionKey: token.sessionKey,
-                temperature: 0.7,
-                topK: 10,
-                topP: 0.95,
-                verbose: options.verbose ?? false,
-            };
-            // Create and start CipherAgent
-            const agent = this.createCipherAgent(llmConfig, brvConfig);
-            this.terminal.log('Querying context tree...');
-            await agent.start();
-            try {
-                const sessionId = this.generateSessionId();
-                // Setup event listeners (display + tool call tracking)
-                this.setupEventListeners(agent, options.verbose ?? false);
-                this.setupToolCallTracking(agent, executionId);
-                // Execute with autonomous mode and query commandType
-                const prompt = `Search the context tree for: ${options.query}`;
-                const response = await agent.execute(prompt, sessionId, {
-                    executionContext: { commandType: 'query' },
-                    mode: 'autonomous',
-                });
-                // Mark execution as completed
-                storage.updateExecutionStatus(executionId, 'completed', response);
-                this.terminal.log('\nQuery Results:');
-                this.terminal.log(response);
-                // Track query
-                await this.trackingService.track('mem:query');
+            const { client: connectedClient } = await transportClientFactory.connect();
+            client = connectedClient;
+            if (verbose) {
+                this.terminal.log(`Connected to instance (clientId: ${client.getClientId()})`);
             }
-            finally {
-                // Cleanup old executions
-                storage.cleanupOldExecutions(100);
+            // Generate taskId in UseCase (Application layer owns task creation)
+            const taskId = randomUUID();
+            // Send task:create request
+            await client.request('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);
+            await this.trackingService.track('mem:query', { status: 'finished' });
         }
         catch (error) {
-            // Mark execution as failed
-            if (executionId) {
-                const errorMessage = error instanceof Error ? error.message : String(error);
-                storage.updateExecutionStatus(executionId, 'failed', undefined, errorMessage);
-            }
-            if (error instanceof WorkspaceNotInitializedError) {
-                this.handleWorkspaceError(error);
-                return;
+            this.handleConnectionError(error);
+            await this.trackingService.track('mem:query', { message: formatError(error), status: 'error' });
+        }
+        finally {
+            // Cleanup
+            if (client) {
+                await client.disconnect();
             }
-            // Display context on one line, error on separate line
-            process.stderr.write('Failed to query context tree:\n');
-            this.terminal.log(formatError(error));
         }
     }
     /**
-     * Create result summary for tool call
-     */
-    createResultSummary(result) {
-        const lines = result.split('\n').length;
-        const chars = result.length;
-        return `${lines} lines, ${chars} chars`;
-    }
-    /**
-     * Extract summary from curate tool result
+     * Format a parsed object result into a concise summary.
      */
-    extractCurateSummary(result) {
-        if (typeof result === 'string') {
-            try {
-                const parsed = JSON.parse(result);
-                return parsed.summary ?? null;
-            }
-            catch {
-                return null;
-            }
+    formatParsedResult(obj) {
+        // Check for common patterns
+        if ('topics' in obj && Array.isArray(obj.topics)) {
+            return `${obj.topics.length} topics found`;
         }
-        if (typeof result === 'object' && result !== null) {
-            const resultObj = result;
-            return resultObj.summary ?? null;
+        if ('results' in obj && Array.isArray(obj.results)) {
+            return `${obj.results.length} matches`;
         }
-        return null;
-    }
-    /**
-     * Format curate tool operation summary
-     */
-    formatCurateResult(result) {
-        const summary = this.extractCurateSummary(result);
-        if (!summary) {
-            return '';
+        if ('matches' in obj && Array.isArray(obj.matches)) {
+            return `${obj.matches.length} matches`;
         }
-        const { added = 0, deleted = 0, failed = 0, merged = 0, updated = 0 } = summary;
-        const parts = [];
-        if (added > 0)
-            parts.push(`${added} added`);
-        if (updated > 0)
-            parts.push(`${updated} updated`);
-        if (merged > 0)
-            parts.push(`${merged} merged`);
-        if (deleted > 0)
-            parts.push(`${deleted} deleted`);
-        if (failed > 0)
-            parts.push(`${failed} failed`);
-        return parts.length > 0 ? parts.join(', ') : 'No operations';
-    }
-    /**
-     * Format items count from list_directory result
-     */
-    formatItemsCount(result) {
-        if (typeof result === 'string') {
-            const lines = result.split('\n').filter((line) => line.trim());
-            return `${lines.length} items`;
+        if ('filesSearched' in obj) {
+            const files = obj.filesSearched;
+            const matches = Array.isArray(obj.matches) ? obj.matches.length : 0;
+            return `${files} files searched, ${matches} matches`;
         }
-        if (Array.isArray(result)) {
-            return `${result.length} items`;
+        // glob_files returns {files: [...]}
+        if ('files' in obj && Array.isArray(obj.files)) {
+            return `${obj.files.length} files`;
         }
-        return '';
-    }
-    /**
-     * Format matches count from grep_content result
-     */
-    formatMatchesCount(result) {
-        if (typeof result === 'string') {
-            const lines = result.split('\n').filter((line) => line.trim());
-            return `${lines.length} matches found`;
+        // list_directory returns {entries: [...]}
+        if ('entries' in obj && Array.isArray(obj.entries)) {
+            return `${obj.entries.length} entries`;
         }
-        if (Array.isArray(result)) {
-            return `${result.length} matches found`;
+        // 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`;
         }
-        return '';
+        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 result summary for display
+     * Format tool arguments for display.
+     * Extract the most meaningful value for human reading.
      */
-    formatToolResultSummary(toolName, result) {
-        try {
-            switch (toolName) {
-                case 'bash_exec':
-                case 'create_knowledge_topic':
-                case 'delete_knowledge_topic':
-                case 'detect_domains':
-                case 'read_file':
-                case 'write_file': {
-                    return '';
-                }
-                case 'curate': {
-                    return this.formatCurateResult(result);
-                }
-                case 'find_knowledge_topics': {
-                    return this.formatTopicsCount(result);
-                }
-                case 'grep_content': {
-                    return this.formatMatchesCount(result);
+    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;
                 }
-                case 'list_directory': {
-                    return this.formatItemsCount(result);
-                }
-                default: {
-                    return '';
+                if (Array.isArray(value)) {
+                    return `${value.length} items`;
                 }
             }
         }
-        catch {
-            return '';
-        }
+        return '';
     }
     /**
-     * Format topics count from find_knowledge_topics result
+     * Format tool result for display.
+     * Shows meaningful, concise summary - NEVER shows raw JSON.
      */
-    formatTopicsCount(result) {
-        if (typeof result === 'string') {
+    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(result);
-                const count = Array.isArray(parsed) ? parsed.length : Object.keys(parsed).length;
-                return `${count} topics retrieved`;
+                const parsed = JSON.parse(payload.result);
+                return this.formatParsedResult(parsed);
             }
             catch {
-                return '';
+                // 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 result === 'object' && result !== null) {
-            const resultObj = result;
-            if (Array.isArray(resultObj.results)) {
-                return `${resultObj.results.length} topics retrieved`;
-            }
-            if (typeof resultObj.total === 'number') {
-                return `${resultObj.total} topics retrieved`;
-            }
-            if (Array.isArray(result)) {
-                return `${result.length} topics retrieved`;
-            }
+        if (typeof payload.result === 'object') {
+            return this.formatParsedResult(payload.result);
         }
-        return '';
+        return 'Done';
     }
     /**
-     * Get user-friendly description for a tool
-     *
-     * @param toolName - Name of the tool
-     * @param args - Tool arguments
-     * @returns User-friendly description
+     * Handle connection-related errors with user-friendly messages.
      */
-    getToolDescription(toolName, args) {
-        switch (toolName) {
-            case 'bash_exec': {
-                const cmd = String(args.command ?? '');
-                return cmd.length > 60 ? `Running command...` : `Running: ${cmd}`;
-            }
-            case 'create_knowledge_topic': {
-                return 'Creating knowledge topic...';
+    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.`);
             }
-            case 'curate': {
-                return 'Curating context tree...';
-            }
-            case 'find_knowledge_topics': {
-                return 'Querying context tree...';
-            }
-            case 'grep_content': {
-                return 'Searching context tree...';
-            }
-            case 'list_directory': {
-                return 'Listing directory...';
-            }
-            case 'read_file': {
-                return `Reading file...`;
-            }
-            case 'write_file': {
-                return 'Writing file...';
-            }
-            default: {
-                return 'Processing...';
+            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;
         }
-    }
-    /**
-     * Handle workspace not initialized error
-     */
-    handleWorkspaceError(_error) {
-        const message = 'Project not initialized. Please run "brv init" to select your team and workspace.';
-        this.terminal.log(message);
-    }
-    /**
-     * Setup event listeners for CipherAgent
-     */
-    setupEventListeners(agent, verbose) {
-        if (!agent.agentEventBus) {
-            throw new Error('Agent event bus not initialized');
+        if (error instanceof InstanceCrashedError) {
+            this.terminal.log('ByteRover instance has crashed.\n\nPlease restart with: brv');
+            return;
         }
-        const eventBus = agent.agentEventBus;
-        if (verbose) {
-            // Verbose mode: show detailed events
-            eventBus.on('llmservice:thinking', () => {
-                this.terminal.log('🤔 [Event] LLM is thinking...');
-            });
-            eventBus.on('llmservice:response', (payload) => {
-                this.terminal.log(`✅ [Event] LLM Response (${payload.provider}/${payload.model})`);
-            });
-            eventBus.on('llmservice:toolCall', (payload) => {
-                // Clear any spinner on current line before printing (use spaces instead of ANSI codes)
-                const formattedCall = formatToolCall(payload.toolName, payload.args);
-                this.terminal.log(`🔧 [Event] Tool Call: ${formattedCall}`);
-            });
-            eventBus.on('llmservice:toolResult', (payload) => {
-                const resultSummary = formatToolResult(payload.toolName, payload.success, payload.result, payload.error);
-                if (payload.success) {
-                    this.terminal.log(`✓ [Event] Tool Success: ${payload.toolName} → ${resultSummary}`);
-                }
-                else {
-                    this.terminal.log(`✗ [Event] Tool Error: ${payload.toolName} → ${resultSummary}`);
-                }
-            });
-            // NOTE: llmservice:error is handled by catch block in the run method
-            // which displays error via this.error(). DO NOT display here to avoid duplicate.
+        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;
         }
-        else {
-            // Non-verbose mode: show concise tool progress with descriptions
-            // eventBus.on('llmservice:toolCall', (payload) => {
-            //   // Clear any spinner on current line before printing (use spaces instead of ANSI codes)
-            //   const description = this.getToolDescription(payload.toolName, payload.args)
-            //   this.terminal.log(`🔧 ${payload.toolName} → ${description}`)
-            // })
-            // eventBus.on('llmservice:toolResult', (payload) => {
-            //   if (payload.success) {
-            //     // Show brief success summary for tool completion
-            //     const summary = this.formatToolResultSummary(payload.toolName, payload.result)
-            //     const completionText = summary ? `Complete (${summary})` : 'Complete'
-            //     this.terminal.log(`✅ ${payload.toolName} → ${completionText}`)
-            //   } else {
-            //     this.terminal.log(`✗ ${payload.toolName} → Failed: ${payload.error}`)
-            //   }
-            // })
-            // NOTE: llmservice:error is handled by catch block in the run method
-            // which displays error via this.error(). DO NOT display here to avoid duplicate.
+        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}`);
     }
     /**
-     * Setup tool call tracking to persist in database
+     * Stream task results from the connected instance.
      */
-    setupToolCallTracking(agent, executionId) {
-        if (!agent.agentEventBus) {
-            return;
-        }
-        const storage = getAgentStorageSync();
-        const eventBus = agent.agentEventBus;
-        const toolCallMap = new Map(); // callId -> dbToolCallId
-        eventBus.on('llmservice:toolCall', (payload) => {
-            try {
-                if (!payload.callId)
-                    return;
-                const toolCallId = storage.addToolCall(executionId, {
-                    args: payload.args,
-                    name: payload.toolName,
-                });
-                toolCallMap.set(payload.callId, toolCallId);
-            }
-            catch {
-                // Ignore errors - don't break query execution
-            }
-        });
-        eventBus.on('llmservice:toolResult', (payload) => {
-            try {
-                if (!payload.callId)
-                    return;
-                const toolCallId = toolCallMap.get(payload.callId);
-                if (toolCallId) {
-                    // Format result: if error, wrap in {error: "..."} object
-                    let result;
-                    if (payload.success) {
-                        result = typeof payload.result === 'string' ? payload.result : JSON.stringify(payload.result);
+    async streamTaskResults(client, taskId, verbose) {
+        return new Promise((resolve, reject) => {
+            let completed = false;
+            let resultPrinted = false; // Track if we've already printed the result
+            // Timeout after 5 minutes
+            const timeout = setTimeout(() => {
+                if (!completed) {
+                    completed = true;
+                    cleanup();
+                    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');
                     }
-                    else {
-                        const errorMsg = payload.error ?? (typeof payload.result === 'string' ? payload.result : 'Unknown error');
-                        result = JSON.stringify({ error: errorMsg });
+                }),
+                // task:started - task is being processed
+                client.on('task:started', (payload) => {
+                    if (payload.taskId === taskId && verbose) {
+                        this.terminal.log('Task started processing...');
                     }
-                    storage.updateToolCall(toolCallId, payload.success ? 'completed' : 'failed', {
-                        result,
-                        resultSummary: payload.success ? this.createResultSummary(result) : undefined,
-                    });
-                }
-            }
-            catch {
-                // Ignore errors - don't break query execution
-            }
+                }),
+                // llmservice:chunk - streaming content (for future release)
+                // client.on<LlmChunkPayload>('llmservice:chunk', (payload) => {
+                //   if (payload.taskId === taskId) {
+                //     if (!hasReceivedChunks) {
+                //       this.terminal.log('\nResult:')
+                //     }
+                //     hasReceivedChunks = true
+                //     process.stdout.write(payload.content)
+                //   }
+                // }),
+                // llmservice:response - final response from LLM (only print once)
+                client.on('llmservice:response', (payload) => {
+                    if (payload.taskId === taskId && payload.content && !resultPrinted) {
+                        resultPrinted = true;
+                        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}` : '';
+                        this.terminal.log(`🔧 ${payload.toolName}${suffix}`);
+                    }
+                }),
+                // 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);
+                        this.terminal.log(`  ${status} ${resultSummary}`);
+                    }
+                }),
+                // task:completed - task finished (chunks already streamed, just resolve)
+                client.on('task:completed', (payload) => {
+                    if (payload.taskId === taskId && !completed) {
+                        completed = true;
+                        cleanup();
+                        // Note: Don't log result here - chunks already streamed it
+                        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();
+                        reject(new Error(payload.error.message));
+                    }
+                }),
+                // Clear timeout when done
+                () => clearTimeout(timeout),
+            ];
+            const cleanup = () => {
+                for (const unsub of unsubscribers)
+                    unsub();
+            };
         });
     }
 }