byterover-cli 1.6.0 → 1.7.0

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

@@ -0,0 +1,410 @@
+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

@@ -0,0 +1,21 @@
+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/space-list-use-case.d.ts

@@ -0,0 +1,27 @@
+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-switch-use-case.d.ts

@@ -0,0 +1,26 @@
+import type { Space } from '../../core/domain/entities/space.js';
+import type { Team } from '../../core/domain/entities/team.js';
+import type { ITokenStore } from '../../core/interfaces/auth/i-token-store.js';
+import type { ISpaceService } from '../../core/interfaces/services/i-space-service.js';
+import type { ITeamService } from '../../core/interfaces/services/i-team-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 { ISpaceSwitchUseCase } from '../../core/interfaces/usecase/i-space-switch-use-case.js';
+export interface SpaceSwitchUseCaseDependencies {
+    projectConfigStore: IProjectConfigStore;
+    spaceService: ISpaceService;
+    teamService: ITeamService;
+    terminal: ITerminal;
+    tokenStore: ITokenStore;
+}
+export declare class SpaceSwitchUseCase implements ISpaceSwitchUseCase {
+    private readonly projectConfigStore;
+    private readonly spaceService;
+    private readonly teamService;
+    private readonly terminal;
+    private readonly tokenStore;
+    constructor(deps: SpaceSwitchUseCaseDependencies);
+    protected promptForSpaceSelection(spaces: Space[]): Promise<Space | undefined>;
+    protected promptForTeamSelection(teams: Team[]): Promise<Team | undefined>;
+    run(): Promise<void>;
+}

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

@@ -0,0 +1,110 @@
+import { BRV_DIR, PROJECT_CONFIG_FILE } from '../../constants.js';
+import { BrvConfig } from '../../core/domain/entities/brv-config.js';
+export class SpaceSwitchUseCase {
+    projectConfigStore;
+    spaceService;
+    teamService;
+    terminal;
+    tokenStore;
+    constructor(deps) {
+        this.projectConfigStore = deps.projectConfigStore;
+        this.spaceService = deps.spaceService;
+        this.teamService = deps.teamService;
+        this.terminal = deps.terminal;
+        this.tokenStore = deps.tokenStore;
+    }
+    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 "/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 "/login" first.');
+            return;
+        }
+        if (!token.isValid()) {
+            this.terminal.log('Authentication token expired. Please run "/login" again.');
+            return;
+        }
+        // Fetch all teams
+        this.terminal.actionStart('Fetching all teams');
+        const teamResult = await this.teamService.getTeams(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.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;
+        // Update configuration
+        const newConfig = new BrvConfig({
+            ...currentConfig,
+            createdAt: new Date().toISOString(),
+            spaceId: selectedSpace.id,
+            spaceName: selectedSpace.name,
+            teamId: selectedTeam.id,
+            teamName: selectedTeam.name,
+        });
+        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}`);
+    }
+}

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

@@ -0,0 +1,75 @@
+import { type ConnectionResult } from '@campfirein/brv-transport-client';
+import type { ITokenStore } from '../../core/interfaces/auth/i-token-store.js';
+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 { ITrackingService } from '../../core/interfaces/services/i-tracking-service.js';
+import type { IProjectConfigStore } from '../../core/interfaces/storage/i-project-config-store.js';
+import type { IStatusUseCase } from '../../core/interfaces/usecase/i-status-use-case.js';
+/** Type for transport connection function (for DI/testing) */
+export type TransportConnector = (fromDir?: string) => Promise<ConnectionResult>;
+/**
+ * Structured status data for JSON output.
+ */
+export interface StatusData {
+    authStatus: 'expired' | 'logged_in' | 'not_logged_in' | 'unknown';
+    cliVersion: string;
+    contextTreeChanges?: {
+        added: string[];
+        deleted: string[];
+        modified: string[];
+    };
+    contextTreeStatus: 'has_changes' | 'no_changes' | 'not_initialized' | 'unknown';
+    currentDirectory: string;
+    mcpStatus: 'connected' | 'crashed' | 'error' | 'no_instance' | 'not_responsive';
+    projectInitialized: boolean;
+    spaceName?: string;
+    teamName?: string;
+    userEmail?: string;
+}
+export interface StatusUseCaseOptions {
+    contextTreeService: IContextTreeService;
+    contextTreeSnapshotService: IContextTreeSnapshotService;
+    projectConfigStore: IProjectConfigStore;
+    terminal: ITerminal;
+    tokenStore: ITokenStore;
+    trackingService: ITrackingService;
+    /** Optional transport connector for dependency injection (defaults to connectToTransport) */
+    transportConnector?: TransportConnector;
+}
+export declare class StatusUseCase implements IStatusUseCase {
+    private readonly contextTreeService;
+    private readonly contextTreeSnapshotService;
+    private readonly projectConfigStore;
+    private readonly terminal;
+    private readonly tokenStore;
+    private readonly trackingService;
+    private readonly transportConnector;
+    constructor(options: StatusUseCaseOptions);
+    run(options: {
+        cliVersion: string;
+        format?: 'json' | 'text';
+    }): Promise<void>;
+    /**
+     * Checks the MCP connection status by:
+     * 1. Discovering running brv instance and connecting via transport
+     * 2. Verifying bidirectional communication with ping
+     */
+    private checkMcpStatus;
+    /**
+     * Check MCP status and return structured data.
+     */
+    private checkMcpStatusData;
+    /**
+     * Collect all status data into a structured object for JSON output.
+     */
+    private collectStatusData;
+    /**
+     * Output status data as JSON.
+     */
+    private outputJsonStatus;
+    /**
+     * Original text format output.
+     */
+    private runTextFormat;
+}