byterover-cli 0.2.0 → 0.3.0

package/dist/commands/gen-rules.js

@@ -1,5 +1,5 @@
 import { confirm, search } from '@inquirer/prompts';
-import { Command } from '@oclif/core';
+import { Command, Flags } from '@oclif/core';
 import { AGENT_VALUES } from '../core/domain/entities/agent.js';
 import { RuleExistsError } from '../core/domain/errors/rule-error.js';
 import { FsFileService } from '../infra/file/fs-file-service.js';
@@ -19,6 +19,12 @@ const AGENTS = AGENT_VALUES.map((agent) => ({
 export default class GenRules extends Command {
     static description = 'Generate rule instructions for coding agents to work with ByteRover correctly';
     static examples = ['<%= config.bin %> <%= command.id %>'];
+    static flags = {
+        agent: Flags.string({
+            char: 'a',
+            description: 'Agent to generate rules for (optional, will prompt if not provided)',
+        }),
+    };
     createServices() {
         const fileService = new FsFileService();
         const templateLoader = new FsTemplateLoader(fileService);
@@ -58,32 +64,45 @@ export default class GenRules extends Command {
         });
     }
     async run() {
+        const { flags } = await this.parse(GenRules);
         const { ruleWriterService, trackingService } = this.createServices();
-        // Track rule generation
-        await trackingService.track('rule:generate');
-        // Interactive selection with search
-        const answer = await this.promptForAgentSelection();
-        this.log(`Generating rules for: ${answer}`);
         try {
-            await ruleWriterService.writeRule(answer, false);
-            this.log(`✅ Successfully generated rule file for ${answer}`);
-        }
-        catch (error) {
-            if (error instanceof RuleExistsError) {
-                const overwrite = await this.promptForOverwriteConfirmation(answer);
-                if (overwrite) {
-                    // Retry with forced=true
-                    await ruleWriterService.writeRule(answer, true);
-                    this.log(`✅ Successfully generated rule file for ${answer}`);
+            // Track rule generation
+            await trackingService.track('rule:generate');
+            // Use provided agent or prompt for selection
+            const answer = flags.agent ? flags.agent : await this.promptForAgentSelection();
+            this.log(`Generating rules for: ${answer}`);
+            try {
+                await ruleWriterService.writeRule(answer, false);
+                this.log(`✅ Successfully generated rule file for ${answer}`);
+            }
+            catch (error) {
+                if (error instanceof RuleExistsError) {
+                    const overwrite = await this.promptForOverwriteConfirmation(answer);
+                    if (overwrite) {
+                        // Retry with forced=true
+                        await ruleWriterService.writeRule(answer, true);
+                        this.log(`✅ Successfully generated rule file for ${answer}`);
+                    }
+                    else {
+                        this.log(`Skipping rule file generation for ${answer}`);
+                    }
                 }
                 else {
-                    this.log(`Skipping rule file generation for ${answer}`);
+                    // Non-recoverable error - throw to let oclif handle display
+                    this.error(`Failed to generate rule file: ${error instanceof Error ? error.message : String(error)}`);
                 }
             }
-            else {
-                // Non-recoverable error
-                this.error(`Failed to generate rule file: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        catch (error) {
+            // Handle user cancelling any prompt (Ctrl+C or closing stdin)
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            if (errorMessage.includes('User force closed') || errorMessage.includes('force closed')) {
+                this.log('Cancelled.');
+                return;
             }
+            // For other errors, throw to let oclif handle display
+            this.error(error instanceof Error ? error.message : 'An error occurred');
         }
     }
 }

package/dist/commands/init.d.ts

@@ -1,24 +1,75 @@
 import { Command } from '@oclif/core';
+import type { AuthToken } from '../core/domain/entities/auth-token.js';
 import type { Space } from '../core/domain/entities/space.js';
 import type { Team } from '../core/domain/entities/team.js';
-import type { IPlaybookService } from '../core/interfaces/i-playbook-service.js';
+import type { IContextTreeService } from '../core/interfaces/i-context-tree-service.js';
+import type { IContextTreeSnapshotService } from '../core/interfaces/i-context-tree-snapshot-service.js';
 import type { IProjectConfigStore } from '../core/interfaces/i-project-config-store.js';
+import type { IRuleWriterService } from '../core/interfaces/i-rule-writer-service.js';
 import type { ISpaceService } from '../core/interfaces/i-space-service.js';
 import type { ITeamService } from '../core/interfaces/i-team-service.js';
 import type { ITokenStore } from '../core/interfaces/i-token-store.js';
+import { type Agent } from '../core/domain/entities/agent.js';
+import { BrvConfig } from '../core/domain/entities/brv-config.js';
 import { ITrackingService } from '../core/interfaces/i-tracking-service.js';
+/**
+ * Represents a legacy config that exists but has version issues.
+ * Used to display config info during re-initialization prompt.
+ */
+export type LegacyProjectConfigInfo = {
+    /**
+     * undefined = missing, string = mismatched
+     */
+    currentVersion: string | undefined;
+    spaceName: string;
+    teamName: string;
+    type: 'legacy';
+};
 export default class Init extends Command {
     static description: string;
     static examples: string[];
+    static flags: {
+        force: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    protected aceDirectoryExists(baseDir?: string): Promise<boolean>;
+    protected cleanupBeforeReInitialization(): Promise<void>;
+    protected confirmReInitialization(config: BrvConfig | LegacyProjectConfigInfo): Promise<boolean>;
     protected createServices(): {
-        playbookService: IPlaybookService;
+        contextTreeService: IContextTreeService;
+        contextTreeSnapshotService: IContextTreeSnapshotService;
         projectConfigStore: IProjectConfigStore;
+        ruleWriterService: IRuleWriterService;
         spaceService: ISpaceService;
         teamService: ITeamService;
         tokenStore: ITokenStore;
         trackingService: ITrackingService;
     };
+    protected detectWorkspacesForAgent(agent: Agent): {
+        chatLogPath: string;
+        cwd: string;
+    };
+    protected ensureAuthenticated(tokenStore: ITokenStore): Promise<AuthToken>;
+    protected fetchAndSelectSpace(spaceService: ISpaceService, token: AuthToken, team: Team): Promise<Space | undefined>;
+    protected fetchAndSelectTeam(teamService: ITeamService, token: AuthToken): Promise<Team | undefined>;
+    protected generateRulesForAgent(ruleWriterService: IRuleWriterService, agent: Agent): Promise<void>;
+    protected getExistingConfig(projectConfigStore: IProjectConfigStore): Promise<BrvConfig | LegacyProjectConfigInfo | undefined>;
+    protected initializeMemoryContextDir(name: string, initFn: () => Promise<string>): Promise<void>;
+    protected isLegacyProjectConfig(config: BrvConfig | LegacyProjectConfigInfo): config is LegacyProjectConfigInfo;
+    protected promptAceDeprecationRemoval(): Promise<boolean>;
+    /**
+     * Prompts the user to select an agent.
+     * This method is protected to allow test overrides.
+     * @returns The selected agent
+     */
+    protected promptForAgentSelection(): Promise<Agent>;
+    /**
+     * Prompts the user to confirm overwriting an existing rule file.
+     * This method is protected to allow test overrides.
+     */
+    protected promptForOverwriteConfirmation(agent: Agent): Promise<boolean>;
     protected promptForSpaceSelection(spaces: Space[]): Promise<Space>;
     protected promptForTeamSelection(teams: Team[]): Promise<Team>;
+    protected removeAceDirectory(baseDir?: string): Promise<void>;
     run(): Promise<void>;
+    private logSuccess;
 }

package/dist/commands/init.js

@@ -1,28 +1,96 @@
-import { select } from '@inquirer/prompts';
-import { Command, ux } from '@oclif/core';
+import { confirm, search, select } from '@inquirer/prompts';
+import { Command, Flags, ux } from '@oclif/core';
+import { access, readFile, rm } from 'node:fs/promises';
+import { join } from 'node:path';
 import { getCurrentConfig } from '../config/environment.js';
-import { BRV_DIR, PROJECT_CONFIG_FILE } from '../constants.js';
+import { ACE_DIR, BRV_CONFIG_VERSION, 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';
+import { BrvConfigVersionError } from '../core/domain/errors/brv-config-version-error.js';
+import { RuleExistsError } from '../core/domain/errors/rule-error.js';
 import { ProjectConfigStore } from '../infra/config/file-config-store.js';
-import { FilePlaybookService } from '../infra/playbook/file-playbook-service.js';
+import { FileContextTreeService } from '../infra/context-tree/file-context-tree-service.js';
+import { FileContextTreeSnapshotService } from '../infra/context-tree/file-context-tree-snapshot-service.js';
+import { FsFileService } from '../infra/file/fs-file-service.js';
+import { RuleTemplateService } from '../infra/rule/rule-template-service.js';
+import { RuleWriterService } from '../infra/rule/rule-writer-service.js';
 import { HttpSpaceService } from '../infra/space/http-space-service.js';
 import { KeychainTokenStore } from '../infra/storage/keychain-token-store.js';
 import { HttpTeamService } from '../infra/team/http-team-service.js';
+import { FsTemplateLoader } from '../infra/template/fs-template-loader.js';
 import { MixpanelTrackingService } from '../infra/tracking/mixpanel-tracking-service.js';
+import { WorkspaceDetectorService } from '../infra/workspace/workspace-detector-service.js';
 export default class Init extends Command {
-    static description = `Initialize a project with ByteRover (creates ${BRV_DIR}/${PROJECT_CONFIG_FILE} with team/space selection and initializes ACE playbook)`;
+    static description = `Initialize a project with ByteRover (creates ${BRV_DIR}/${PROJECT_CONFIG_FILE} with team/space selection and initializes Context Tree)`;
     static examples = [
         '<%= config.bin %> <%= command.id %>',
         '# Re-initialize if config exists (will show current config and exit):\n<%= config.bin %> <%= command.id %>',
         '# Full workflow: login then initialize:\n<%= config.bin %> login\n<%= config.bin %> <%= command.id %>',
     ];
+    static flags = {
+        force: Flags.boolean({
+            char: 'f',
+            default: false,
+            description: 'Force re-initialization without confirmation prompt',
+        }),
+    };
+    async aceDirectoryExists(baseDir) {
+        const dir = baseDir ?? process.cwd();
+        const acePath = join(dir, BRV_DIR, ACE_DIR);
+        try {
+            await access(acePath);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async cleanupBeforeReInitialization() {
+        const brvDir = join(process.cwd(), BRV_DIR);
+        this.log('\n Cleaning up existing ByteRover directory...');
+        ux.action.start(`  Removing ${BRV_DIR}/`);
+        try {
+            await rm(brvDir, { force: true, recursive: true });
+            ux.action.stop('✓');
+        }
+        catch (error) {
+            ux.action.stop('✗');
+            throw new Error(`Failed to remove ${BRV_DIR}/: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
+    async confirmReInitialization(config) {
+        if (this.isLegacyProjectConfig(config)) {
+            const versionStatus = config.currentVersion === undefined ? 'missing' : `${config.currentVersion} → ${BRV_CONFIG_VERSION}`;
+            this.log(`\n⚠️  Project has an outdated configuration (version: ${versionStatus})`);
+        }
+        else {
+            this.log('\n Project is already initialized');
+        }
+        this.log(`  Team: ${config.teamName}`);
+        this.log(`  Space: ${config.spaceName}`);
+        this.log(`  Config: ${join(process.cwd(), BRV_DIR, PROJECT_CONFIG_FILE)}`);
+        this.log('\n Re-initializing will:');
+        this.log(`  - Remove the entire ${BRV_DIR}/ directory and all its contents`);
+        this.log('  - Allow you to select a new team/space');
+        this.log('  - Create a fresh configuration and Context Tree');
+        this.log('  - Regenerate rule instructions\n');
+        return confirm({
+            default: false,
+            message: 'Continue with re-initialization?',
+        });
+    }
     createServices() {
         const envConfig = getCurrentConfig();
         const tokenStore = new KeychainTokenStore();
         const trackingService = new MixpanelTrackingService(tokenStore);
+        const fileService = new FsFileService();
+        const templateLoader = new FsTemplateLoader(fileService);
+        const ruleTemplateService = new RuleTemplateService(templateLoader);
         return {
-            playbookService: new FilePlaybookService(),
+            contextTreeService: new FileContextTreeService(),
+            contextTreeSnapshotService: new FileContextTreeSnapshotService(),
             projectConfigStore: new ProjectConfigStore(),
+            ruleWriterService: new RuleWriterService(fileService, ruleTemplateService),
             spaceService: new HttpSpaceService({
                 apiBaseUrl: envConfig.apiBaseUrl,
             }),
@@ -33,6 +101,155 @@ export default class Init extends Command {
             trackingService,
         };
     }
+    detectWorkspacesForAgent(agent) {
+        const detector = new WorkspaceDetectorService();
+        const result = detector.detectWorkspaces(agent);
+        return {
+            chatLogPath: result.chatLogPath,
+            cwd: result.cwd,
+        };
+    }
+    async ensureAuthenticated(tokenStore) {
+        const token = await tokenStore.load();
+        if (token === undefined) {
+            this.error('Not authenticated. Please run "brv login" first.');
+        }
+        if (!token.isValid()) {
+            this.error('Authentication token expired. Please run "brv login" again.');
+        }
+        return token;
+    }
+    async fetchAndSelectSpace(spaceService, token, team) {
+        ux.action.start('\nFetching all spaces');
+        const { spaces } = await spaceService.getSpaces(token.accessToken, token.sessionKey, team.id, { fetchAll: true });
+        ux.action.stop();
+        if (spaces.length === 0) {
+            this.log(`No spaces found in team "${team.getDisplayName()}"`);
+            this.log(`Please visit ${getCurrentConfig().webAppUrl} to create your first space for ${team.getDisplayName()}.`);
+            return undefined;
+        }
+        this.log();
+        return this.promptForSpaceSelection(spaces);
+    }
+    async fetchAndSelectTeam(teamService, token) {
+        ux.action.start('Fetching all teams');
+        const { teams } = await teamService.getTeams(token.accessToken, token.sessionKey, { fetchAll: true });
+        ux.action.stop();
+        if (teams.length === 0) {
+            this.log('No teams found.');
+            this.log(`Please visit ${getCurrentConfig().webAppUrl} to create your first team.`);
+            return undefined;
+        }
+        this.log();
+        return this.promptForTeamSelection(teams);
+    }
+    async generateRulesForAgent(ruleWriterService, agent) {
+        this.log(`Generating rules for: ${agent}`);
+        try {
+            await ruleWriterService.writeRule(agent, false);
+            this.log(`✅ Successfully generated rule file for ${agent}`);
+        }
+        catch (error) {
+            if (error instanceof RuleExistsError) {
+                const overwrite = await this.promptForOverwriteConfirmation(agent);
+                if (overwrite) {
+                    await ruleWriterService.writeRule(agent, true);
+                    this.log(`✅ Successfully generated rule file for ${agent}`);
+                }
+                else {
+                    this.log(`Skipping rule file generation for ${agent}`);
+                }
+            }
+            else {
+                throw error;
+            }
+        }
+    }
+    async getExistingConfig(projectConfigStore) {
+        const exists = await projectConfigStore.exists();
+        if (!exists)
+            return undefined;
+        try {
+            const projectConfig = await projectConfigStore.read();
+            if (projectConfig === undefined) {
+                throw new Error('Configuration file exists but cannot be read. Please check .brv/config.json');
+            }
+            return projectConfig;
+        }
+        catch (error) {
+            if (error instanceof BrvConfigVersionError) {
+                // Legacy/outdated config - read raw JSON for display info
+                const configPath = join(process.cwd(), BRV_DIR, PROJECT_CONFIG_FILE);
+                const content = await readFile(configPath, 'utf8');
+                // As type assertion here since rawJson is default to any/unknown anyway
+                const rawJson = JSON.parse(content);
+                return {
+                    currentVersion: error.currentVersion,
+                    spaceName: typeof rawJson.spaceName === 'string' ? rawJson.spaceName : 'Unknown',
+                    teamName: typeof rawJson.teamName === 'string' ? rawJson.teamName : 'Unknown',
+                    type: 'legacy',
+                };
+            }
+            // Re-throw other errors
+            throw error;
+        }
+    }
+    async initializeMemoryContextDir(name, initFn) {
+        this.log(`\nInitializing ${name}...`);
+        try {
+            const path = await initFn();
+            this.log(`✓ ${name} initialized in ${path}`);
+        }
+        catch (error) {
+            this.warn(`${name} initialization skipped: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
+    isLegacyProjectConfig(config) {
+        return 'type' in config && config.type === 'legacy';
+    }
+    async promptAceDeprecationRemoval() {
+        this.log('\n The ACE system is being deprecated.');
+        this.log(' ByteRover is migrating to the new Context Tree system for improved');
+        this.log(' memory organization and retrieval.');
+        this.log('');
+        this.log(' We detected an existing ACE folder at .brv/ace/');
+        this.log(' This folder and all its contents can be safely removed.\n');
+        return confirm({
+            default: true,
+            message: 'Remove the ACE folder and its contents?',
+        });
+    }
+    /**
+     * Prompts the user to select an agent.
+     * This method is protected to allow test overrides.
+     * @returns The selected agent
+     */
+    async promptForAgentSelection() {
+        const AGENTS = AGENT_VALUES.map((agent) => ({
+            name: agent,
+            value: agent,
+        }));
+        const answer = await search({
+            message: 'Which agent you are using (type to search):',
+            async source(input) {
+                if (!input)
+                    return AGENTS;
+                return AGENTS.filter((agent) => agent.name.toLowerCase().includes(input.toLowerCase()) ||
+                    agent.value.toLowerCase().includes(input.toLowerCase()));
+            },
+        });
+        return answer;
+    }
+    /**
+     * Prompts the user to confirm overwriting an existing rule file.
+     * This method is protected to allow test overrides.
+     */
+    async promptForOverwriteConfirmation(agent) {
+        return confirm({
+            default: true,
+            message: `Rule file already exists for ${agent}. Overwrite?`,
+        });
+    }
     async promptForSpaceSelection(spaces) {
         const selectedSpaceId = await select({
             choices: spaces.map((space) => ({
@@ -61,80 +278,76 @@ export default class Init extends Command {
         }
         return selectedTeam;
     }
+    async removeAceDirectory(baseDir) {
+        const dir = baseDir ?? process.cwd();
+        const acePath = join(dir, BRV_DIR, ACE_DIR);
+        await rm(acePath, { force: true, recursive: true });
+    }
     async run() {
         try {
-            const { playbookService, projectConfigStore, spaceService, teamService, tokenStore, trackingService } = this.createServices();
-            // 1. Check if already initialized
-            const isInitialized = await projectConfigStore.exists();
-            if (isInitialized) {
-                this.log('Project is already initialized with ByteRover.');
-                const existingProjectConfig = await projectConfigStore.read();
-                this.log(`Your space for this project is: ${existingProjectConfig?.teamName}/${existingProjectConfig?.spaceName}`);
-                return;
+            const { flags } = await this.parse(Init);
+            const { contextTreeService, contextTreeSnapshotService, projectConfigStore, ruleWriterService, spaceService, teamService, tokenStore, trackingService, } = this.createServices();
+            const authToken = await this.ensureAuthenticated(tokenStore);
+            const existingConfig = await this.getExistingConfig(projectConfigStore);
+            if (existingConfig) {
+                const shouldCleanup = flags.force ? true : await this.confirmReInitialization(existingConfig);
+                if (shouldCleanup) {
+                    await this.cleanupBeforeReInitialization();
+                    this.log('\n');
+                }
+                else {
+                    this.log('\nCancelled. Project configuration unchanged.');
+                    return;
+                }
             }
             this.log('Initializing ByteRover project...\n');
-            // 2. Load and validate authentication token
-            const token = await tokenStore.load();
-            if (token === undefined) {
-                this.error('Not authenticated. Please run "brv login" first.');
-            }
-            if (!token.isValid()) {
-                this.error('Authentication token expired. Please run "brv login" again.');
-            }
-            // 3. Fetch all teams with spinner
-            ux.action.start('Fetching all teams');
-            const teamResult = await teamService.getTeams(token.accessToken, token.sessionKey, { fetchAll: true });
-            ux.action.stop();
-            const { teams } = teamResult;
-            if (teams.length === 0) {
-                this.log('No teams found.');
-                this.log(`Please visit ${getCurrentConfig().webAppUrl} to create your first team.`);
+            const selectedTeam = await this.fetchAndSelectTeam(teamService, authToken);
+            if (!selectedTeam)
                 return;
-            }
-            // 4. Prompt for team selection
-            this.log();
-            const selectedTeam = await this.promptForTeamSelection(teams);
-            // 5. Fetch all spaces for the selected team with spinner
-            ux.action.start('Fetching all spaces');
-            const spaceResult = await spaceService.getSpaces(token.accessToken, token.sessionKey, selectedTeam.id, {
-                fetchAll: true,
-            });
-            ux.action.stop();
-            const { spaces } = spaceResult;
-            if (spaces.length === 0) {
-                this.log(`No spaces found in team "${selectedTeam.getDisplayName()}"`);
-                this.log(`Please visit ${getCurrentConfig().webAppUrl} to create your first space for ${selectedTeam.getDisplayName()}.`);
+            const selectedSpace = await this.fetchAndSelectSpace(spaceService, authToken, selectedTeam);
+            if (!selectedSpace)
                 return;
+            // Handle ACE deprecation - check for existing ACE folder and offer removal
+            const aceExists = await this.aceDirectoryExists();
+            if (aceExists) {
+                const shouldRemoveAce = await this.promptAceDeprecationRemoval();
+                if (shouldRemoveAce) {
+                    await this.removeAceDirectory();
+                    this.log('✓ ACE folder removed');
+                }
             }
-            // 6. Prompt for space selection
+            // ACE is deprecated - only initialize context tree
+            await this.initializeMemoryContextDir('context tree', () => contextTreeService.initialize());
+            // Create initial snapshot for change tracking (includes the template files just created)
+            await contextTreeSnapshotService.saveSnapshot();
+            this.log('✓ Context tree snapshot created');
             this.log();
-            const selectedSpace = await this.promptForSpaceSelection(spaces);
-            // 7. Create and save configuration
-            const config = BrvConfig.fromSpace(selectedSpace);
+            const selectedAgent = await this.promptForAgentSelection();
+            this.log('Detecting workspaces...');
+            const { chatLogPath, cwd } = this.detectWorkspacesForAgent(selectedAgent);
+            this.log(`✓ Detected workspace: ${cwd}`);
+            const config = BrvConfig.fromSpace({
+                chatLogPath,
+                cwd,
+                ide: selectedAgent,
+                space: selectedSpace,
+            });
             await projectConfigStore.write(config);
-            // 8. Initialize ACE playbook
-            this.log('\nInitializing ACE context...');
-            try {
-                const playbookPath = await playbookService.initialize();
-                this.log(`✓ ACE playbook initialized in ${playbookPath}`);
-            }
-            catch (error) {
-                // Warn but don't fail if ACE init fails
-                this.warn(`ACE initialization skipped: ${error instanceof Error ? error.message : 'Unknown error'}`);
-            }
-            // 9. Generate rules
             this.log(`\nGenerate rule instructions for coding agents to work with ByteRover correctly`);
             this.log();
-            await this.config.runCommand('gen-rules');
-            // Track space initialization
+            await this.generateRulesForAgent(ruleWriterService, selectedAgent);
+            await trackingService.track('rule:generate');
             await trackingService.track('space:init');
-            // 10. Display success
-            this.log(`\n✓ Project initialized successfully!`);
-            this.log(`✓ Connected to space: ${selectedSpace.getDisplayName()}`);
-            this.log(`✓ Configuration saved to: ${BRV_DIR}/${PROJECT_CONFIG_FILE}`);
+            this.logSuccess(selectedSpace);
         }
         catch (error) {
-            this.error(error instanceof Error ? error.message : 'Initialization failed');
+            this.error(`Initialization failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
         }
     }
+    logSuccess(space) {
+        this.log(`\n✓ Project initialized successfully!`);
+        this.log(`✓ Connected to space: ${space.getDisplayName()}`);
+        this.log(`✓ Configuration saved to: ${BRV_DIR}/${PROJECT_CONFIG_FILE}`);
+        this.log("NOTE: It's recommended to add .brv/ to your .gitignore file since ByteRover already takes care of memory/context versioning for you.");
+    }
 }

package/dist/commands/login.js

@@ -85,15 +85,20 @@ export default class Login extends Command {
                 this.log('Successfully authenticated!');
             }
             catch (error) {
-                this.error(error instanceof Error ? error.message : 'Authentication failed');
+                // Throw error to let oclif handle display
+                const errorMessage = error instanceof Error ? error.message : 'Authentication failed';
+                this.error(errorMessage);
             }
         }
         catch (error) {
             if (error instanceof DiscoveryError) {
-                this.error(`Failed to configure authentication: ${error.message}\n` +
-                    'Please check your network connection and try again.');
+                const errorMessage = `Failed to configure authentication: ${error.message}\n` +
+                    'Please check your network connection and try again.';
+                this.error(errorMessage);
             }
-            this.error(error instanceof Error ? error.message : 'Authentication failed');
+            // Throw error to let oclif handle display
+            const errorMessage = error instanceof Error ? error.message : 'Authentication failed';
+            this.error(errorMessage);
         }
         finally {
             // Always cleanup server

package/dist/commands/logout.d.ts

@@ -0,0 +1,16 @@
+import { Command } from '@oclif/core';
+import type { ITokenStore } from '../core/interfaces/i-token-store.js';
+import type { ITrackingService } from '../core/interfaces/i-tracking-service.js';
+export default class Logout extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        yes: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    protected confirmLogout(userEmail: string): Promise<boolean>;
+    protected createServices(): {
+        tokenStore: ITokenStore;
+        trackingService: ITrackingService;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/logout.js

@@ -0,0 +1,61 @@
+import { confirm } from '@inquirer/prompts';
+import { Command, Flags } from '@oclif/core';
+import { KeychainTokenStore } from '../infra/storage/keychain-token-store.js';
+import { MixpanelTrackingService } from '../infra/tracking/mixpanel-tracking-service.js';
+export default class Logout extends Command {
+    static description = 'Log out of ByteRover CLI and clear authentication (does not affect local project files)';
+    static examples = ['<%= config.bin %> <%= command.id %>', '<%= config.bin %> <%= command.id %> --yes'];
+    static flags = {
+        yes: Flags.boolean({
+            char: 'y',
+            default: false,
+            description: 'Skip confirmation prompt',
+        }),
+    };
+    async confirmLogout(userEmail) {
+        return confirm({
+            // Pressing 'Enter' = Yes
+            default: true,
+            message: `Logging out ${userEmail}. Are you sure?`,
+        });
+    }
+    createServices() {
+        const tokenStore = new KeychainTokenStore();
+        const trackingService = new MixpanelTrackingService(tokenStore);
+        return {
+            tokenStore,
+            trackingService,
+        };
+    }
+    async run() {
+        const { flags } = await this.parse(Logout);
+        const { tokenStore, trackingService } = this.createServices();
+        try {
+            const token = await tokenStore.load();
+            if (token === undefined) {
+                this.log('You are not currently logged in.');
+                return;
+            }
+            if (!flags.yes) {
+                const confirmed = await this.confirmLogout(token.userEmail);
+                if (!confirmed) {
+                    this.log('Logout cancelled.');
+                    return;
+                }
+            }
+            try {
+                await trackingService.track('auth:signed_out');
+            }
+            catch { }
+            await tokenStore.clear();
+            this.log('Successfully logged out.');
+            this.log("Run 'brv login' to authenticate again.");
+        }
+        catch (error) {
+            if (error instanceof Error && error.message.includes('keychain')) {
+                this.error('Unable to access system keychain. Please check your system permissions and try again.');
+            }
+            this.error(error instanceof Error ? error.message : 'Logout failed');
+        }
+    }
+}