byterover-cli 0.4.1 → 1.0.1

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

@@ -1,288 +1,97 @@
 import { randomUUID } from 'node:crypto';
-import fs from 'node:fs';
-import path from 'node:path';
-import open from 'open';
-import { CONTEXT_TREE_DOMAINS } from '../../config/context-tree-domains.js';
-import { BRV_DIR, CONTEXT_FILE, CONTEXT_TREE_DIR } from '../../constants.js';
-import { validateFileForCurate } from '../../utils/file-validator.js';
-import { getAgentStorage } from '../cipher/storage/agent-storage.js';
-import { WorkspaceNotInitializedError } from '../cipher/validation/workspace-validator.js';
-// Full path to context tree
-const CONTEXT_TREE_PATH = path.join(BRV_DIR, CONTEXT_TREE_DIR);
+import { ConnectionError, ConnectionFailedError, InstanceCrashedError, NoInstanceRunningError } from '../../core/domain/errors/connection-error.js';
+import { formatError } from '../../utils/error-handler.js';
+import { getSandboxEnvironmentName, isSandboxEnvironment, isSandboxNetworkError } from '../../utils/sandbox-detector.js';
+import { createTransportClientFactory } from '../transport/transport-client-factory.js';
 export class CurateUseCase {
-    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 topic folder with context.md file
-     * @param targetPath - The parent path where the topic folder will be created
-     * @param topicName - The name of the topic folder to create
-     * @returns The path to the created context.md file
-     */
-    createTopicWithContextFile(targetPath, topicName) {
-        const topicPath = path.join(targetPath, topicName);
-        const contextFilePath = path.join(topicPath, CONTEXT_FILE);
-        // Create the topic directory
-        fs.mkdirSync(topicPath, { recursive: true });
-        // Create the context.md file with initial content
-        const initialContent = `# ${topicName}\n\n<!-- Add your context here -->\n`;
-        fs.writeFileSync(contextFilePath, initialContent, 'utf8');
-        return contextFilePath;
-    }
-    /**
-     * Generate a unique session ID for the autonomous agent.
-     * Uses crypto.randomUUID() for guaranteed uniqueness (122 bits of entropy).
-     */
-    generateSessionId() {
-        return randomUUID();
-    }
-    /**
-     * Navigate through the context tree using file selector
-     * Returns the selected path relative to context-tree root
-     */
-    async navigateContextTree() {
-        const contextTreePath = path.resolve(process.cwd(), CONTEXT_TREE_PATH);
-        // Ensure context tree directory exists
-        if (!fs.existsSync(contextTreePath)) {
-            fs.mkdirSync(contextTreePath, { recursive: true });
-        }
-        // Ensure predefined domains exist as directories
-        for (const domain of CONTEXT_TREE_DOMAINS) {
-            const domainPath = path.join(contextTreePath, domain.name);
-            if (!fs.existsSync(domainPath)) {
-                fs.mkdirSync(domainPath, { recursive: true });
-            }
-        }
-        while (true) {
-            try {
-                // eslint-disable-next-line no-await-in-loop
-                const selectedItem = await this.terminal.fileSelector({
-                    allowCancel: true,
-                    basePath: contextTreePath,
-                    filter: (item) => item.isDirectory,
-                    message: 'Target context location:',
-                    pageSize: 15,
-                    theme: {
-                        labels: {
-                            messages: {
-                                cancel: 'Selection cancelled.',
-                                empty: 'No sub-folders. Press Enter to add content here.',
-                            },
-                        },
-                    },
-                    type: 'directory',
-                });
-                // User cancelled
-                if (!selectedItem) {
-                    return null;
-                }
-                // Restrict navigation to stay within the context tree
-                const normalizedItemPath = path.resolve(selectedItem.path);
-                const isValid = normalizedItemPath.startsWith(contextTreePath);
-                if (isValid) {
-                    // Valid selection - proceed
-                    return selectedItem.path;
-                }
-                // Invalid selection - retry
-                this.terminal.log('Invalid selection. Please choose a valid location within the context tree.');
-            }
-            catch {
-                // Error occurred
-                return null;
-            }
-        }
-    }
-    /**
-     * Open a file in the default editor
-     * @param filePath - The path to the file to open
-     */
-    async openFile(filePath) {
-        await open(filePath);
-    }
-    /**
-     * Prompt user to enter topic name with validation
-     * @param targetPath - The path where the topic folder will be created
-     * @returns The topic name or null if cancelled
-     */
-    async promptForTopicName(targetPath) {
-        try {
-            const topicName = await this.terminal.input({
-                message: 'New topic name:',
-                validate: (value) => this.validateTopicName(value, targetPath),
-            });
-            return topicName.trim();
-        }
-        catch {
-            return null;
-        }
-    }
-    async run(options) {
+    async run({ context, files, verbose = false }) {
         await this.trackingService.track('mem:curate', { status: 'started' });
-        // Determine mode: autonomous if context is provided
-        return options.context ? this.runAutonomous(options.context, options) : this.runInteractive();
-    }
-    /**
-     * Handle workspace not initialized error
-     */
-    handleWorkspaceError(_error) {
-        const message = 'Project not initialized. Please run "/init" to select your team and workspace.';
-        this.terminal.log(message);
-    }
-    /**
-     * Process file paths from --files flag
-     * @param filePaths - Array of file paths (relative or absolute)
-     * @returns Formatted instructions for the agent to read the specified files, or undefined if validation fails
-     */
-    processFileReferences(filePaths) {
-        const MAX_FILES = 5;
-        if (!filePaths || filePaths.length === 0) {
-            return '';
+        if (!context) {
+            this.terminal.log('Context argument is required.');
+            this.terminal.log('Usage: brv curate "your context here"');
+            return;
         }
-        // Validate max files and truncate if needed
-        if (filePaths.length > MAX_FILES) {
-            const ignored = filePaths.slice(MAX_FILES);
-            this.terminal.log(`\n⚠️  Only the first ${MAX_FILES} files will be processed. Ignoring: ${ignored.join(', ')}\n`);
-            filePaths = filePaths.slice(0, MAX_FILES);
-        }
-        // Get project root (current directory with .brv)
-        const projectRoot = process.cwd();
-        // Validate each file and collect errors
-        const validPaths = [];
-        const errors = [];
-        for (const filePath of filePaths) {
-            const result = validateFileForCurate(filePath, projectRoot);
-            if (result.valid && result.normalizedPath) {
-                validPaths.push(result.normalizedPath);
-            }
-            else {
-                errors.push(`  ✗ ${result.error}`);
-            }
-        }
-        // If there are any validation errors, show them and return undefined
-        if (errors.length > 0) {
-            this.terminal.log('\n❌ File validation failed:\n');
-            this.terminal.log(errors.join('\n'));
-            this.terminal.log('');
-            this.terminal.log('Invalid files provided. Please fix the errors above and try again.');
-            return undefined;
-        }
-        // Format instructions for the agent
-        const instructions = [
-            '\n## IMPORTANT: Critical Files to Read (--files flag)',
-            '',
-            'The user has explicitly specified these files as critical context that MUST be read before creating knowledge topics:',
-            '',
-            ...validPaths.map((p) => `- ${p}`),
-            '',
-            '**MANDATORY INSTRUCTIONS:**',
-            '- You MUST use the `read_file` tool to read ALL of these files IN PARALLEL (in a single iteration) before proceeding to create knowledge topics',
-            '- These files contain essential context that will help you create comprehensive and accurate knowledge topics',
-            '- Read them in parallel to maximize efficiency - they do not depend on each other',
-            '- After reading all files, proceed with the normal workflow: detect domains, find existing knowledge, and create/update topics',
-            '',
-        ];
-        return instructions.join('\n');
-    }
-    /**
-     * Run in autonomous mode - push to queue for background processing
-     */
-    async runAutonomous(content, options) {
+        let client;
         try {
-            // Get authentication token
-            const token = await this.tokenStore.load();
-            if (!token) {
-                this.terminal.log('Authentication required. Please run "/login" first.');
-                return;
+            const transportClientFactory = this.transportClientFactoryCreator();
+            if (verbose) {
+                this.terminal.log('Discovering running instance...');
             }
-            // Load project config
-            const brvConfig = await this.projectConfigStore.read();
-            // Validate workspace is initialized
-            if (!brvConfig) {
-                throw new WorkspaceNotInitializedError('Project not initialized. Please run "/init" to select your team and workspace.', '.brv');
+            const { client: connectedClient } = await transportClientFactory.connect();
+            client = connectedClient;
+            if (verbose) {
+                this.terminal.log(`Connected to instance (clientId: ${client.getClientId()})`);
             }
-            // Process file references if provided (validates and creates instructions)
-            const fileReferenceInstructions = this.processFileReferences(options.files ?? []);
-            if (fileReferenceInstructions === undefined) {
-                // Validation failed, error already displayed
-                return;
-            }
-            // Initialize storage and create execution (auto-detects .brv/blobs)
-            const storage = await getAgentStorage();
-            // Create execution with status='queued'
-            storage.createExecution('curate', JSON.stringify({
-                content,
-                fileReferenceInstructions,
-                flags: { apiKey: options.apiKey, model: options.model, verbose: options.verbose },
-            }));
-            // Simple output for agents - just confirm saved
+            // Generate taskId in UseCase (Application layer owns task creation)
+            const taskId = randomUUID();
+            // Send task:create - Transport routes to Agent, UseCase handles logic
+            await client.request('task:create', {
+                content: context,
+                ...(files?.length ? { files } : {}),
+                taskId,
+                type: 'curate',
+            });
             this.terminal.log('✓ Context queued for processing.');
-            // Track the event
             await this.trackingService.track('mem:curate', { status: 'finished' });
         }
         catch (error) {
-            if (error instanceof WorkspaceNotInitializedError) {
-                this.handleWorkspaceError(error);
-                return;
+            this.handleConnectionError(error);
+            await this.trackingService.track('mem:curate', { message: formatError(error), status: 'error' });
+        }
+        finally {
+            if (client) {
+                await client.disconnect();
             }
-            // Display error
-            const errMsg = error instanceof Error ? error.message : 'Runtime error occurred';
-            await this.trackingService.track('mem:curate', { message: errMsg, status: 'error' });
-            this.terminal.error(errMsg);
         }
     }
-    /**
-     * Run in interactive mode with manual prompts
-     */
-    async runInteractive() {
-        try {
-            // Navigate to target location in context tree
-            const targetPath = await this.navigateContextTree();
-            if (!targetPath) {
-                this.terminal.log('\nOperation cancelled.');
-                return;
+    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.`);
             }
-            // Prompt for topic name with validation
-            const topicName = await this.promptForTopicName(targetPath);
-            if (!topicName) {
-                this.terminal.log('\nOperation cancelled.');
-                return;
+            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.');
             }
-            // Create the topic folder with context.md
-            const contextFilePath = this.createTopicWithContextFile(targetPath, topicName);
-            this.terminal.log(`\nCreated: ${path.relative(process.cwd(), contextFilePath)}`);
-            // Track the event
-            this.trackingService.track('mem:curate');
-            // Auto-open context.md in default editor
-            this.terminal.log('Opening context.md for editing...');
-            await this.openFile(contextFilePath);
-        }
-        catch (error) {
-            const errMsg = error instanceof Error ? error.message : 'Unexpected error occurred';
-            await this.trackingService.track('mem:curate', { message: errMsg, status: 'error' });
-            this.terminal.error(errMsg);
-        }
-    }
-    validateTopicName(value, targetPath) {
-        const trimmed = value.trim();
-        if (!trimmed) {
-            return 'Topic name cannot be empty';
-        }
-        // Only allow letters, numbers, and hyphens
-        if (!/^[a-zA-Z0-9-]+$/.test(trimmed)) {
-            return 'Topic name can only contain letters (a-z, A-Z), numbers (0-9), and hyphens (-)';
+            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;
         }
-        // Check if folder already exists
-        const topicPath = path.join(targetPath, trimmed);
-        if (fs.existsSync(topicPath)) {
-            return `Topic "${trimmed}" already exists at this location`;
+        if (error instanceof ConnectionError) {
+            this.terminal.log(`Connection error: ${error.message}`);
+            return;
         }
-        return true;
+        const message = error instanceof Error ? error.message : String(error);
+        this.terminal.log(`Unexpected error: ${message}`);
     }
 }

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

@@ -105,7 +105,7 @@ export class InitUseCase {
         return token;
     }
     async fetchAndSelectSpace(token, team) {
-        this.terminal.actionStart('\nFetching all spaces');
+        this.terminal.actionStart('Fetching all spaces');
         const { spaces } = await this.spaceService.getSpaces(token.accessToken, token.sessionKey, team.id, { fetchAll: true });
         this.terminal.actionStop();
         if (spaces.length === 0) {
@@ -433,7 +433,7 @@ export class InitUseCase {
     }
     async syncFromRemoteOrInitialize(params) {
         // Pull from remote - fail if network/API error
-        this.terminal.log('\nSyncing from ByteRover...');
+        this.terminal.actionStart('Syncing from ByteRover...');
         try {
             const coGitSnapshot = await this.cogitPullService.pull({
                 accessToken: params.token.accessToken,
@@ -464,6 +464,7 @@ export class InitUseCase {
             await this.trackingService.track('init', { message: syncFailureErr, status: 'error' });
             throw new Error(syncFailureErr);
         }
+        this.terminal.actionStop();
     }
     /**
      * Appends ByteRover rules to a file that has no ByteRover content.

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

@@ -1,21 +1,20 @@
 import type { BrvConfig } from '../../core/domain/entities/brv-config.js';
-import type { IProjectConfigStore } from '../../core/interfaces/i-project-config-store.js';
 import type { ITerminal } from '../../core/interfaces/i-terminal.js';
-import type { ITokenStore } from '../../core/interfaces/i-token-store.js';
 import type { ITrackingService } from '../../core/interfaces/i-tracking-service.js';
 import type { IQueryUseCase, QueryUseCaseRunOptions } from '../../core/interfaces/usecase/i-query-use-case.js';
-import { CipherAgent } from '../cipher/cipher-agent.js';
+import { CipherAgent } from '../cipher/agent/index.js';
+import { type TransportClientFactory } from '../transport/transport-client-factory.js';
+export type TransportClientFactoryCreator = () => TransportClientFactory;
 export interface QueryUseCaseOptions {
-    projectConfigStore: IProjectConfigStore;
     terminal: ITerminal;
-    tokenStore: ITokenStore;
     trackingService: ITrackingService;
+    /** Optional factory creator for dependency injection (defaults to createTransportClientFactory) */
+    transportClientFactoryCreator?: TransportClientFactoryCreator;
 }
 export declare class QueryUseCase implements IQueryUseCase {
-    private readonly projectConfigStore;
     private readonly terminal;
-    private readonly tokenStore;
     private readonly trackingService;
+    private readonly transportClientFactoryCreator;
     constructor(options: QueryUseCaseOptions);
     /**
      * Create CipherAgent instance. Protected to allow test overrides.
@@ -28,51 +27,25 @@ export declare class QueryUseCase implements IQueryUseCase {
     protected generateSessionId(): string;
     run(options: QueryUseCaseRunOptions): Promise<void>;
     /**
-     * Create result summary for tool call
+     * Format a parsed object result into a concise summary.
      */
-    private createResultSummary;
+    private formatParsedResult;
     /**
-     * Extract summary from curate tool result
+     * Format tool arguments for display.
+     * Extract the most meaningful value for human reading.
      */
-    private extractCurateSummary;
+    private formatToolArgs;
     /**
-     * Format curate tool operation summary
+     * Format tool result for display.
+     * Shows meaningful, concise summary - NEVER shows raw JSON.
      */
-    private formatCurateResult;
+    private formatToolResult;
     /**
-     * Format items count from list_directory result
+     * Handle connection-related errors with user-friendly messages.
      */
-    private formatItemsCount;
+    private handleConnectionError;
     /**
-     * Format matches count from grep_content result
+     * Stream task results from the connected instance.
      */
-    private formatMatchesCount;
-    /**
-     * Format tool result summary for display
-     */
-    private formatToolResultSummary;
-    /**
-     * Format topics count from find_knowledge_topics result
-     */
-    private formatTopicsCount;
-    /**
-     * Get user-friendly description for a tool
-     *
-     * @param toolName - Name of the tool
-     * @param args - Tool arguments
-     * @returns User-friendly description
-     */
-    private getToolDescription;
-    /**
-     * Handle workspace not initialized error
-     */
-    private handleWorkspaceError;
-    /**
-     * Setup event listeners for CipherAgent
-     */
-    private setupEventListeners;
-    /**
-     * Setup tool call tracking to persist in database
-     */
-    private setupToolCallTracking;
+    private streamTaskResults;
 }