byterover-cli 0.2.1 → 0.3.1

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,30 +1,90 @@
 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 { ICogitPullService } from '../core/interfaces/i-cogit-pull-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 { IContextTreeWriterService } from '../core/interfaces/i-context-tree-writer-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): Promise<boolean>;
+    protected confirmReInitialization(config: BrvConfig | LegacyProjectConfigInfo): Promise<boolean>;
     protected createServices(): {
-        playbookService: IPlaybookService;
+        cogitPullService: ICogitPullService;
+        contextTreeService: IContextTreeService;
+        contextTreeSnapshotService: IContextTreeSnapshotService;
+        contextTreeWriterService: IContextTreeWriterService;
         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>;
+    protected syncFromRemoteOrInitialize(params: {
+        cogitPullService: ICogitPullService;
+        contextTreeService: IContextTreeService;
+        contextTreeSnapshotService: IContextTreeSnapshotService;
+        contextTreeWriterService: IContextTreeWriterService;
+        projectConfig: {
+            spaceId: string;
+            teamId: string;
+        };
+        token: AuthToken;
+    }): Promise<void>;
+    private logSuccess;
 }

package/dist/commands/init.js

@@ -1,18 +1,29 @@
-import { confirm, select } from '@inquirer/prompts';
+import { confirm, search, select } from '@inquirer/prompts';
 import { Command, Flags, ux } from '@oclif/core';
-import { rm } from 'node:fs/promises';
+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, DEFAULT_BRANCH, 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 { HttpCogitPullService } from '../infra/cogit/http-cogit-pull-service.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 { FileContextTreeWriterService } from '../infra/context-tree/file-context-tree-writer-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 %>',
@@ -25,6 +36,17 @@ export default class Init extends Command {
             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...');
@@ -35,18 +57,24 @@ export default class Init extends Command {
         }
         catch (error) {
             ux.action.stop('✗');
-            this.error(`Failed to remove ${BRV_DIR}/: ${error instanceof Error ? error.message : 'Unknown error'}`);
+            throw new Error(`Failed to remove ${BRV_DIR}/: ${error instanceof Error ? error.message : 'Unknown error'}`);
         }
     }
     async confirmReInitialization(config) {
-        this.log('\n Project is already initialized');
+        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 ACE playbook');
+        this.log('  - Create a fresh configuration and Context Tree');
         this.log('  - Regenerate rule instructions\n');
         return confirm({
             default: false,
@@ -57,9 +85,19 @@ export default class Init extends Command {
         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);
+        const contextTreeSnapshotService = new FileContextTreeSnapshotService();
         return {
-            playbookService: new FilePlaybookService(),
+            cogitPullService: new HttpCogitPullService({
+                apiBaseUrl: envConfig.cogitApiBaseUrl,
+            }),
+            contextTreeService: new FileContextTreeService(),
+            contextTreeSnapshotService,
+            contextTreeWriterService: new FileContextTreeWriterService({ snapshotService: contextTreeSnapshotService }),
             projectConfigStore: new ProjectConfigStore(),
+            ruleWriterService: new RuleWriterService(fileService, ruleTemplateService),
             spaceService: new HttpSpaceService({
                 apiBaseUrl: envConfig.apiBaseUrl,
             }),
@@ -70,6 +108,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) => ({
@@ -98,84 +285,112 @@ 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() {
-        const { flags } = await this.parse(Init);
         try {
-            const { playbookService, projectConfigStore, spaceService, teamService, tokenStore, trackingService } = this.createServices();
-            const alreadyInitialized = await projectConfigStore.exists();
-            if (alreadyInitialized) {
-                const currentConfig = await projectConfigStore.read();
-                if (currentConfig === undefined) {
-                    this.error('Configuration file exists but cannot be read. Please check .brv/config.json');
-                }
-                if (!flags.force) {
-                    const confirmed = await this.confirmReInitialization(currentConfig);
-                    if (!confirmed) {
-                        this.log('\nCancelled. Project configuration unchanged.');
-                        return;
-                    }
-                }
-                try {
+            const { flags } = await this.parse(Init);
+            const { cogitPullService, contextTreeService, contextTreeSnapshotService, contextTreeWriterService, 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');
                 }
-                catch (error) {
-                    this.error(`Failed to clean up existing data: ${error instanceof Error ? error.message : 'Unknown error'}`);
+                else {
+                    this.log('\nCancelled. Project configuration unchanged.');
+                    return;
                 }
-                this.log('\n'); // Spacing before continuing with init flow
             }
             this.log('Initializing ByteRover project...\n');
-            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.');
-            }
-            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;
-            }
-            this.log();
-            const selectedTeam = await this.promptForTeamSelection(teams);
-            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');
+                }
             }
+            // Sync from remote or initialize context tree with templates
+            await this.syncFromRemoteOrInitialize({
+                cogitPullService,
+                contextTreeService,
+                contextTreeSnapshotService,
+                contextTreeWriterService,
+                projectConfig: { spaceId: selectedSpace.id, teamId: selectedTeam.id },
+                token: authToken,
+            });
             this.log();
-            const selectedSpace = await this.promptForSpaceSelection(spaces);
-            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);
-            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'}`);
-            }
             this.log(`\nGenerate rule instructions for coding agents to work with ByteRover correctly`);
             this.log();
-            await this.config.runCommand('gen-rules');
+            await this.generateRulesForAgent(ruleWriterService, selectedAgent);
+            await trackingService.track('rule:generate');
             await trackingService.track('space:init');
-            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'}`);
         }
     }
+    async syncFromRemoteOrInitialize(params) {
+        // Pull from remote - fail if network/API error
+        this.log('\nSyncing from ByteRover...');
+        try {
+            const coGitSnapshot = await params.cogitPullService.pull({
+                accessToken: params.token.accessToken,
+                branch: DEFAULT_BRANCH,
+                sessionKey: params.token.sessionKey,
+                spaceId: params.projectConfig.spaceId,
+                teamId: params.projectConfig.teamId,
+            });
+            // Check if space is "empty" (no files, or only README.md placeholder)
+            // CoGit follows Git semantics - empty repos have a README.md placeholder
+            const isEmptySpace = coGitSnapshot.files.length === 0 ||
+                (coGitSnapshot.files.length === 1 && coGitSnapshot.files[0].path === '/README.md');
+            if (isEmptySpace) {
+                // Remote is empty - ignore placeholder, create templates with empty snapshot
+                await this.initializeMemoryContextDir('context tree', () => params.contextTreeService.initialize());
+                await params.contextTreeSnapshotService.initEmptySnapshot();
+                this.log('✓ Context tree initialized');
+            }
+            else {
+                // Remote has real data - sync it to local
+                await params.contextTreeWriterService.sync({ files: [...coGitSnapshot.files] });
+                await params.contextTreeSnapshotService.saveSnapshot();
+                this.log(`✓ Synced ${coGitSnapshot.files.length} context files from remote`);
+            }
+        }
+        catch (error) {
+            throw new Error(`Failed to sync from ByteRover: ${error instanceof Error ? error.message : 'Unknown error'}. Please try again.`);
+        }
+    }
+    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