byterover-cli 0.3.5 → 0.4.1

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

@@ -0,0 +1,402 @@
+import { randomUUID } from 'node:crypto';
+import { getCurrentConfig } from '../../config/environment.js';
+import { PROJECT } from '../../constants.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';
+export class QueryUseCase {
+    projectConfigStore;
+    terminal;
+    tokenStore;
+    trackingService;
+    constructor(options) {
+        this.projectConfigStore = options.projectConfigStore;
+        this.terminal = options.terminal;
+        this.tokenStore = options.tokenStore;
+        this.trackingService = options.trackingService;
+    }
+    /**
+     * 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' });
+        // Initialize storage for tool call tracking (auto-detects .brv/blobs)
+        const storage = await getAgentStorage();
+        let executionId = null;
+        try {
+            // Get authentication token
+            const token = await this.tokenStore.load();
+            if (!token) {
+                this.terminal.log('Authentication required. Please run "/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 "/init" to select your team and workspace.', '.brv');
+            }
+            // 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);
+                await this.trackingService.track('mem:query', { status: 'finished' });
+            }
+            finally {
+                // Cleanup old executions
+                storage.cleanupOldExecutions(100);
+            }
+        }
+        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;
+            }
+            // Display context on one line, error on separate line
+            process.stderr.write('Failed to query context tree:\n');
+            await this.trackingService.track('mem:query', { message: formatError(error), status: 'error' });
+            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
+     */
+    extractCurateSummary(result) {
+        if (typeof result === 'string') {
+            try {
+                const parsed = JSON.parse(result);
+                return parsed.summary ?? null;
+            }
+            catch {
+                return null;
+            }
+        }
+        if (typeof result === 'object' && result !== null) {
+            const resultObj = result;
+            return resultObj.summary ?? null;
+        }
+        return null;
+    }
+    /**
+     * Format curate tool operation summary
+     */
+    formatCurateResult(result) {
+        const summary = this.extractCurateSummary(result);
+        if (!summary) {
+            return '';
+        }
+        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 (Array.isArray(result)) {
+            return `${result.length} items`;
+        }
+        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`;
+        }
+        if (Array.isArray(result)) {
+            return `${result.length} matches found`;
+        }
+        return '';
+    }
+    /**
+     * Format tool result summary for display
+     */
+    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);
+                }
+                case 'list_directory': {
+                    return this.formatItemsCount(result);
+                }
+                default: {
+                    return '';
+                }
+            }
+        }
+        catch {
+            return '';
+        }
+    }
+    /**
+     * Format topics count from find_knowledge_topics result
+     */
+    formatTopicsCount(result) {
+        if (typeof result === 'string') {
+            try {
+                const parsed = JSON.parse(result);
+                const count = Array.isArray(parsed) ? parsed.length : Object.keys(parsed).length;
+                return `${count} topics retrieved`;
+            }
+            catch {
+                return '';
+            }
+        }
+        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`;
+            }
+        }
+        return '';
+    }
+    /**
+     * Get user-friendly description for a tool
+     *
+     * @param toolName - Name of the tool
+     * @param args - Tool arguments
+     * @returns User-friendly description
+     */
+    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...';
+            }
+            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...';
+            }
+        }
+    }
+    /**
+     * 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');
+        }
+        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.
+        }
+        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.
+        }
+    }
+    /**
+     * Setup tool call tracking to persist in database
+     */
+    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);
+                    }
+                    else {
+                        const errorMsg = payload.error ?? (typeof payload.result === 'string' ? payload.result : 'Unknown error');
+                        result = JSON.stringify({ error: errorMsg });
+                    }
+                    storage.updateToolCall(toolCallId, payload.success ? 'completed' : 'failed', {
+                        result,
+                        resultSummary: payload.success ? this.createResultSummary(result) : undefined,
+                    });
+                }
+            }
+            catch {
+                // Ignore errors - don't break query execution
+            }
+        });
+    }
+}

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

@@ -0,0 +1,27 @@
+import type { IProjectConfigStore } from '../../core/interfaces/i-project-config-store.js';
+import type { ISpaceService } from '../../core/interfaces/i-space-service.js';
+import type { ITerminal } from '../../core/interfaces/i-terminal.js';
+import type { ITokenStore } from '../../core/interfaces/i-token-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/infra/usecase/space-list-use-case.js

@@ -0,0 +1,64 @@
+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 "brv init" first.');
+            return;
+        }
+        const token = await this.tokenStore.load();
+        if (!token) {
+            this.terminal.error('Not authenticated. Please run "brv login" first.');
+            return;
+        }
+        if (!token.isValid()) {
+            this.terminal.error('Authentication token expired. Please run "brv 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.accessToken, 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.');
+            }
+        }
+    }
+}

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

@@ -0,0 +1,36 @@
+import type { Space } from '../../core/domain/entities/space.js';
+import type { Team } from '../../core/domain/entities/team.js';
+import type { IProjectConfigStore } from '../../core/interfaces/i-project-config-store.js';
+import type { ISpaceService } from '../../core/interfaces/i-space-service.js';
+import type { ITeamService } from '../../core/interfaces/i-team-service.js';
+import type { ITerminal } from '../../core/interfaces/i-terminal.js';
+import type { ITokenStore } from '../../core/interfaces/i-token-store.js';
+import type { IWorkspaceDetectorService } from '../../core/interfaces/i-workspace-detector-service.js';
+import type { ISpaceSwitchUseCase } from '../../core/interfaces/usecase/i-space-switch-use-case.js';
+import { Agent } from '../../core/domain/entities/agent.js';
+export interface SpaceSwitchUseCaseDependencies {
+    projectConfigStore: IProjectConfigStore;
+    spaceService: ISpaceService;
+    teamService: ITeamService;
+    terminal: ITerminal;
+    tokenStore: ITokenStore;
+    workspaceDetector: IWorkspaceDetectorService;
+}
+export declare class SpaceSwitchUseCase implements ISpaceSwitchUseCase {
+    private readonly projectConfigStore;
+    private readonly spaceService;
+    private readonly teamService;
+    private readonly terminal;
+    private readonly tokenStore;
+    private readonly workspaceDetector;
+    constructor(deps: SpaceSwitchUseCaseDependencies);
+    /**
+     * Prompts the user to select an agent.
+     * This method is protected to allow test overrides.
+     * @returns The selected agent
+     */
+    protected promptForAgentSelection(): Promise<Agent>;
+    protected promptForSpaceSelection(spaces: Space[]): Promise<Space | undefined>;
+    protected promptForTeamSelection(teams: Team[]): Promise<Team | undefined>;
+    run(): Promise<void>;
+}

package/dist/infra/usecase/space-switch-use-case.js

@@ -0,0 +1,140 @@
+import { BRV_DIR, PROJECT_CONFIG_FILE } from '../../constants.js';
+import { AGENT_VALUES } from '../../core/domain/entities/agent.js';
+import { BrvConfig } from '../../core/domain/entities/brv-config.js';
+/**
+ * Array of all agents with name and value properties.
+ * Useful for UI components like select dropdowns.
+ */
+const AGENTS = AGENT_VALUES.map((agent) => ({
+    name: agent,
+    value: agent,
+}));
+export class SpaceSwitchUseCase {
+    projectConfigStore;
+    spaceService;
+    teamService;
+    terminal;
+    tokenStore;
+    workspaceDetector;
+    constructor(deps) {
+        this.projectConfigStore = deps.projectConfigStore;
+        this.spaceService = deps.spaceService;
+        this.teamService = deps.teamService;
+        this.terminal = deps.terminal;
+        this.tokenStore = deps.tokenStore;
+        this.workspaceDetector = deps.workspaceDetector;
+    }
+    /**
+     * Prompts the user to select an agent.
+     * This method is protected to allow test overrides.
+     * @returns The selected agent
+     */
+    async promptForAgentSelection() {
+        return this.terminal.search({
+            message: 'Which agent you are using (type to search):',
+            source(input) {
+                if (!input)
+                    return AGENTS;
+                return AGENTS.filter((agent) => agent.name.toLowerCase().includes(input.toLowerCase()) ||
+                    agent.value.toLowerCase().includes(input.toLowerCase()));
+            },
+        });
+    }
+    async promptForSpaceSelection(spaces) {
+        const selectedSpaceId = await this.terminal.select({
+            choices: spaces.map((space) => ({
+                name: space.getDisplayName(),
+                value: space.id,
+            })),
+            message: 'Select a space',
+        });
+        const selectedSpace = spaces.find((space) => space.id === selectedSpaceId);
+        if (!selectedSpace) {
+            this.terminal.log('Space selection failed');
+            return undefined;
+        }
+        return selectedSpace;
+    }
+    async promptForTeamSelection(teams) {
+        const selectedTeamId = await this.terminal.select({
+            choices: teams.map((team) => ({
+                name: team.name,
+                value: team.id,
+            })),
+            message: 'Select a team',
+        });
+        const selectedTeam = teams.find((team) => team.id === selectedTeamId);
+        if (!selectedTeam) {
+            this.terminal.log('Team selection failed');
+            return undefined;
+        }
+        return selectedTeam;
+    }
+    async run() {
+        // Check project initialization (MUST exist for switch)
+        const currentConfig = await this.projectConfigStore.read();
+        if (!currentConfig) {
+            this.terminal.log('Project not initialized. Please run "brv init" first.');
+            return;
+        }
+        // Show current configuration
+        this.terminal.log('Current configuration:');
+        this.terminal.log(`  Team: ${currentConfig.teamName}`);
+        this.terminal.log(`  Space: ${currentConfig.spaceName}`);
+        this.terminal.log();
+        // Validate authentication
+        const token = await this.tokenStore.load();
+        if (!token) {
+            this.terminal.log('Not authenticated. Please run "brv login" first.');
+            return;
+        }
+        if (!token.isValid()) {
+            this.terminal.log('Authentication token expired. Please run "brv login" again.');
+            return;
+        }
+        // Fetch all teams
+        this.terminal.actionStart('Fetching all teams');
+        const teamResult = await this.teamService.getTeams(token.accessToken, token.sessionKey, { fetchAll: true });
+        this.terminal.actionStop();
+        if (teamResult.teams.length === 0) {
+            this.terminal.log('No teams found. Please create a team in the ByteRover dashboard first.');
+            return;
+        }
+        // Prompt for team selection
+        this.terminal.log();
+        const selectedTeam = await this.promptForTeamSelection(teamResult.teams);
+        if (!selectedTeam)
+            return;
+        // Fetch spaces for selected team
+        this.terminal.actionStart('Fetching all spaces');
+        const spaceResult = await this.spaceService.getSpaces(token.accessToken, token.sessionKey, selectedTeam.id, {
+            fetchAll: true,
+        });
+        this.terminal.actionStop();
+        if (spaceResult.spaces.length === 0) {
+            this.terminal.log(`No spaces found in team "${selectedTeam.getDisplayName()}". Please create a space in the ByteRover dashboard first.`);
+            return;
+        }
+        // Prompt for space selection
+        this.terminal.log();
+        const selectedSpace = await this.promptForSpaceSelection(spaceResult.spaces);
+        if (!selectedSpace)
+            return;
+        // Prompt for agent selection
+        this.terminal.log();
+        const selectedAgent = await this.promptForAgentSelection();
+        this.terminal.log();
+        const { chatLogPath, cwd } = this.workspaceDetector.detectWorkspaces(selectedAgent);
+        // Update configuration
+        const newConfig = BrvConfig.fromSpace({
+            chatLogPath,
+            cwd,
+            ide: selectedAgent,
+            space: selectedSpace,
+        });
+        await this.projectConfigStore.write(newConfig);
+        // Display success
+        this.terminal.log(`\n✓ Successfully switched to space: ${selectedSpace.getDisplayName()}`);
+        this.terminal.log(`✓ Configuration updated in: ${BRV_DIR}/${PROJECT_CONFIG_FILE}`);
+    }
+}