byterover-cli 0.1.0

package/dist/commands/complete.js

@@ -0,0 +1,340 @@
+import { Args, Command, Flags } from '@oclif/core';
+import { basename } from 'node:path';
+import { CuratorOutput } from '../core/domain/entities/curator-output.js';
+import { DeltaBatch } from '../core/domain/entities/delta-batch.js';
+import { ExecutorOutput } from '../core/domain/entities/executor-output.js';
+import { ReflectorOutput } from '../core/domain/entities/reflector-output.js';
+import { AcePromptTemplates } from '../infra/ace/ace-prompt-templates.js';
+import { FileDeltaStore } from '../infra/ace/file-delta-store.js';
+import { FileExecutorOutputStore } from '../infra/ace/file-executor-output-store.js';
+import { FilePlaybookStore } from '../infra/ace/file-playbook-store.js';
+import { FileReflectionStore } from '../infra/ace/file-reflection-store.js';
+import { FilePlaybookService } from '../infra/playbook/file-playbook-service.js';
+export default class Complete extends Command {
+    /* eslint-disable perfectionist/sort-objects */
+    static args = {
+        hint: Args.string({
+            description: 'Short hint for naming output files (e.g., "user-auth", "bug-fix")',
+            required: true,
+        }),
+        reasoning: Args.string({
+            description: 'Detailed reasoning and approach for completing the task',
+            required: true,
+        }),
+        finalAnswer: Args.string({
+            description: 'The final answer/solution to the task',
+            required: true,
+        }),
+    };
+    /* eslint-enable perfectionist/sort-objects */
+    static description = 'Complete ACE workflow: save executor output, generate reflection, and update playbook in one command';
+    static examples = [
+        String.raw `<%= config.bin %> <%= command.id %> "user-auth" "Implemented OAuth2 flow" "Auth works" --tool-usage "Read:src/auth.ts,Edit:src/auth.ts,Bash:npm test" --feedback "All tests passed"`,
+        String.raw `<%= config.bin %> <%= command.id %> "validation-fix" "Analyzed validator" "Fixed bug" --tool-usage "Grep:pattern:\"validate\",Read:src/validator.ts" --bullet-ids "bullet-123" --feedback "Tests passed"`,
+        String.raw `<%= config.bin %> <%= command.id %> "auth-update" "Improved error handling" "Better errors" --tool-usage "Edit:src/auth.ts" --feedback "Tests passed" --update-bullet "bullet-5"`,
+    ];
+    static flags = {
+        'bullet-ids': Flags.string({
+            char: 'b',
+            default: '',
+            description: 'Comma-separated list of playbook bullet IDs referenced',
+        }),
+        feedback: Flags.string({
+            char: 'f',
+            description: 'Environment feedback about task execution (e.g., "Tests passed", "Build failed")',
+            required: true,
+        }),
+        'tool-usage': Flags.string({
+            char: 't',
+            description: 'Comma-separated list of tool calls with arguments (format: "ToolName:argument", e.g., "Read:src/file.ts,Bash:npm test")',
+            required: true,
+        }),
+        'update-bullet': Flags.string({
+            char: 'u',
+            description: 'Bullet ID to update with new knowledge (if not provided, adds new bullet)',
+        }),
+    };
+    createServices() {
+        return {
+            deltaStore: new FileDeltaStore(),
+            executorOutputStore: new FileExecutorOutputStore(),
+            playbookService: new FilePlaybookService(),
+            promptBuilder: new AcePromptTemplates(),
+            reflectionStore: new FileReflectionStore(),
+        };
+    }
+    async run() {
+        const { args, flags } = await this.parse(Complete);
+        try {
+            const { deltaStore, executorOutputStore, playbookService, promptBuilder, reflectionStore } = this.createServices();
+            // Parse comma-separated lists
+            const bulletIds = this.parseBulletIds(flags['bullet-ids']);
+            const toolUsage = this.parseToolUsage(flags['tool-usage']);
+            // Phase 1: Executor
+            const saveResult = await this.saveExecutorOutput(executorOutputStore, args, bulletIds, toolUsage);
+            // Phase 2: Reflector
+            const { reflection, reflectionFilePath, tagsApplied } = await this.generateReflectionAndApplyTags({ playbookService, promptBuilder, reflectionStore }, saveResult.executorOutput, flags.feedback);
+            // Phase 3: Curator
+            const { curatorOutput, deltaFilePath } = await this.generateCurationAndApplyDelta({ deltaStore, playbookService, promptBuilder }, reflection, saveResult.executorOutput, flags);
+            // Display final summary
+            this.displayFinalSummary({
+                curatorOutput,
+                deltaFilePath,
+                executorPath: saveResult.filePath,
+                hint: args.hint,
+                reflectionFilePath,
+                tagsApplied,
+            });
+        }
+        catch (error) {
+            this.error(error instanceof Error ? error.message : 'Failed to complete ACE workflow');
+        }
+    }
+    /**
+     * Displays a formatted summary of the completed ACE workflow.
+     * Shows file paths, delta operations breakdown, and success confirmation.
+     *
+     * @param summary - Summary data containing all workflow outputs
+     * @param summary.curatorOutput - The curator output containing delta operations
+     * @param summary.deltaFilePath - Path to the saved delta file
+     * @param summary.executorPath - Path to the saved executor output file
+     * @param summary.hint - The hint used for naming output files
+     * @param summary.reflectionFilePath - Path to the saved reflection file
+     * @param summary.tagsApplied - Number of tags applied to the playbook
+     */
+    displayFinalSummary(summary) {
+        const { delta } = summary.curatorOutput;
+        const operationsByType = delta.getOperationsByType();
+        this.log('='.repeat(80));
+        this.log('✅ ACE WORKFLOW COMPLETED SUCCESSFULLY!');
+        this.log('='.repeat(80));
+        this.log('');
+        this.log('Summary:');
+        this.log(`  Hint: ${summary.hint}`);
+        this.log(`  Executor output: ${summary.executorPath}`);
+        this.log(`  Reflection: ${summary.reflectionFilePath}`);
+        this.log(`  Delta: ${summary.deltaFilePath}`);
+        this.log(`  Tags applied: ${summary.tagsApplied}`);
+        this.log('');
+        this.log('Delta operations:');
+        if (delta.isEmpty()) {
+            this.log('  - No operations (empty delta batch)');
+        }
+        else {
+            if (operationsByType.ADD) {
+                this.log(`  - ADD: ${operationsByType.ADD.length}`);
+            }
+            if (operationsByType.UPDATE) {
+                this.log(`  - UPDATE: ${operationsByType.UPDATE.length}`);
+            }
+            if (operationsByType.REMOVE) {
+                this.log(`  - REMOVE: ${operationsByType.REMOVE.length}`);
+            }
+            this.log(`  Total operations: ${delta.getOperationCount()}`);
+        }
+        this.log('');
+        this.log('🎉 Playbook has been updated with new knowledge!');
+    }
+    /**
+     * Extracts file paths from tool usage strings and formats them with project name prefix.
+     * Converts tool usage entries like "Read:src/file.ts" to "projectName/src/file.ts".
+     * Filters out non-file-like arguments (e.g., "Bash:npm test" is excluded).
+     *
+     * @param toolUsage - Array of tool usage strings (e.g., ["Read:src/file.ts", "Edit:src/other.ts"])
+     * @returns Array of formatted file paths with project name prefix
+     */
+    extractFilePaths(toolUsage) {
+        const cwd = process.cwd();
+        const projectName = basename(cwd);
+        return toolUsage
+            .map((usage) => {
+            const parts = usage.split(':');
+            if (parts.length <= 1)
+                return null;
+            const filePath = parts[1].trim();
+            // Filter out non-file-like paths (must contain / or . to be considered a file path)
+            if (!filePath.includes('/') && !filePath.includes('.')) {
+                return null;
+            }
+            // Remove leading ./ if present
+            const cleanPath = filePath.replace(/^\.\//, '');
+            // Combine project name with file path
+            const fullPath = `${projectName}/${cleanPath}`;
+            return fullPath;
+        })
+            .filter(Boolean);
+    }
+    /**
+     * Phase 3: Generates curation and applies delta operations to the playbook.
+     * Creates delta operations (ADD or UPDATE) based on reflection insights and applies them to the playbook.
+     *
+     * @param services - The service instances
+     * @param services.deltaStore - Delta store for persisting deltas
+     * @param services.playbookService - Playbook service for applying deltas
+     * @param services.promptBuilder - Prompt builder for curation prompts
+     * @param reflection - The reflection output from Phase 2
+     * @param executorOutput - The executor output from Phase 1
+     * @param flags - Command flags containing optional update-bullet ID
+     * @returns Object containing curator output and delta file path
+     */
+    async generateCurationAndApplyDelta(services, reflection, executorOutput, flags) {
+        this.log('🎨 Phase 3: Generating curation prompt...');
+        // Note: We load playbook temporarily just for validation
+        // The actual delta application will be done by playbookService
+        const tempStore = new FilePlaybookStore();
+        const updatedPlaybook = await tempStore.load();
+        if (!updatedPlaybook) {
+            this.error('Failed to reload playbook');
+        }
+        // Generate curation prompt (directly call promptBuilder instead of use case)
+        // Note: The prompt is generated but not currently used in this auto-generation flow
+        // In a full implementation, this would be sent to an LLM for processing
+        // services.promptBuilder.buildCuratorPrompt(reflection, updatedPlaybook, questionContext)
+        // Determine operation type based on --update-bullet flag
+        const updateBulletId = flags['update-bullet'];
+        let operationType = 'ADD';
+        // Validate bullet exists if UPDATE mode
+        if (updateBulletId) {
+            const bullet = updatedPlaybook.getBullet(updateBulletId);
+            if (!bullet) {
+                this.error(`Bullet with ID "${updateBulletId}" not found in playbook. Cannot update non-existent bullet.`);
+            }
+            operationType = 'UPDATE';
+            this.log(`  ℹ️  Updating existing bullet: ${updateBulletId}`);
+        }
+        else {
+            this.log('  ℹ️  Adding new bullet to playbook...');
+        }
+        // Auto-generate curator delta
+        const relatedFiles = this.extractFilePaths(executorOutput.toolUsage);
+        const curatorJson = {
+            operations: [
+                {
+                    bulletId: updateBulletId,
+                    content: reflection.keyInsight,
+                    metadata: {
+                        relatedFiles,
+                        tags: ['auto-generated'],
+                        timestamp: new Date().toISOString(),
+                    },
+                    section: 'Lessons Learned',
+                    type: operationType,
+                },
+            ],
+            reasoning: operationType === 'UPDATE'
+                ? `Updating bullet ${updateBulletId} with new insight: ${reflection.keyInsight}`
+                : `Adding key insight from task: ${reflection.keyInsight}`,
+        };
+        // Parse and save delta batch using service
+        const deltaBatch = DeltaBatch.fromJson(curatorJson);
+        const curatorOutput = new CuratorOutput(deltaBatch);
+        const deltaFilePath = await services.deltaStore.save(deltaBatch, reflection.hint);
+        // Apply delta operations using playbook service
+        const { operationsApplied } = await services.playbookService.applyDelta({ delta: curatorOutput.delta });
+        this.log(`  ✓ Delta saved: ${deltaFilePath}`);
+        this.log(`  ✓ Delta operations applied to playbook (${operationsApplied} operations)`);
+        this.log('');
+        return { curatorOutput, deltaFilePath };
+    }
+    /**
+     * Phase 2: Generates reflection based on executor output and applies tags to the playbook.
+     * Auto-generates reflection analysis from feedback and applies bullet tags to relevant playbook sections.
+     *
+     * @param services - The service instances
+     * @param services.playbookService - Playbook service for applying reflection tags
+     * @param services.promptBuilder - Prompt builder for reflection prompts
+     * @param services.reflectionStore - Reflection store for persisting reflections
+     * @param executorOutput - The executor output from Phase 1
+     * @param feedback - Environment feedback about task execution (e.g., "Tests passed", "Build failed")
+     * @returns Object containing reflection output, file path, and number of tags applied
+     */
+    async generateReflectionAndApplyTags(services, executorOutput, feedback) {
+        this.log('🤔 Phase 2: Generating reflection...');
+        // Note: We don't need to load playbook here anymore as applyReflectionTags handles it internally
+        // Generate reflection prompt (directly call promptBuilder instead of use case)
+        // Note: The prompt is generated but not currently used in this auto-generation flow
+        // In a full implementation, this would be sent to an LLM for processing
+        // const task = executorOutput.reasoning.split('\n')[0] || 'Task from executor'
+        // services.promptBuilder.buildReflectorPrompt(executorOutput, task, feedback, playbook, groundTruth)
+        // Auto-generate reflection based on feedback
+        this.log('  ℹ️  Auto-generating reflection based on feedback...');
+        const reflectionJson = {
+            bulletTags: [],
+            correctApproach: executorOutput.reasoning,
+            errorIdentification: feedback.toLowerCase().includes('fail') || feedback.toLowerCase().includes('error')
+                ? `Issues identified: ${feedback}`
+                : 'No critical errors identified',
+            hint: executorOutput.hint,
+            keyInsight: executorOutput.finalAnswer,
+            reasoning: `Analysis: ${feedback}. Approach: ${executorOutput.reasoning}`,
+            rootCauseAnalysis: feedback.toLowerCase().includes('fail') || feedback.toLowerCase().includes('error')
+                ? `Root cause requires investigation: ${feedback}`
+                : 'Successful execution without errors',
+        };
+        // Parse and save reflection using service
+        const reflection = ReflectorOutput.fromJson(reflectionJson);
+        const reflectionFilePath = await services.reflectionStore.save(reflection);
+        // Apply tags to playbook using playbook service
+        const { tagsApplied } = await services.playbookService.applyReflectionTags({ reflection });
+        this.log(`  ✓ Reflection saved: ${reflectionFilePath}`);
+        this.log(`  ✓ Tags applied to playbook: ${tagsApplied}`);
+        this.log('');
+        return { reflection, reflectionFilePath, tagsApplied };
+    }
+    /**
+     * Parses comma-separated bullet IDs string into an array of trimmed IDs.
+     * Empty strings and whitespace-only entries are filtered out.
+     *
+     * @param bulletIdsStr - Comma-separated string of bullet IDs (e.g., "bullet-1, bullet-2")
+     * @returns Array of trimmed bullet ID strings (empty array if input is empty string)
+     */
+    parseBulletIds(bulletIdsStr) {
+        return bulletIdsStr
+            .split(',')
+            .map((id) => id.trim())
+            .filter((id) => id.length > 0);
+    }
+    /**
+     * Parses comma-separated tool usage string into an array of trimmed entries.
+     * Empty strings and whitespace-only entries are filtered out.
+     *
+     * @param toolUsageStr - Comma-separated string of tool usage (e.g., "Read:file.ts, Edit:other.ts")
+     * @returns Array of trimmed tool usage strings
+     */
+    parseToolUsage(toolUsageStr) {
+        return toolUsageStr
+            .split(',')
+            .map((tool) => tool.trim())
+            .filter((tool) => tool.length > 0);
+    }
+    /**
+     * Phase 1: Saves executor output to a file.
+     * Creates an ExecutorOutput entity from command arguments and persists it using the executor output store service.
+     *
+     * @param executorOutputStore - The executor output store service
+     * @param args - Command arguments
+     * @param args.hint - Short hint for naming output files
+     * @param args.reasoning - Detailed reasoning and approach for completing the task
+     * @param args.finalAnswer - The final answer/solution to the task
+     * @param bulletIds - Array of playbook bullet IDs referenced during task execution
+     * @param toolUsage - Array of tool usage strings (e.g., ["Read:src/file.ts", "Bash:npm test"])
+     * @returns Object containing the executor output entity and file path where it was saved
+     */
+    async saveExecutorOutput(executorOutputStore, args, bulletIds, toolUsage) {
+        this.log('🚀 Starting ACE workflow...');
+        this.log('');
+        this.log('📝 Phase 1: Saving executor output...');
+        const executorOutput = new ExecutorOutput({
+            bulletIds,
+            finalAnswer: args.finalAnswer,
+            hint: args.hint,
+            reasoning: args.reasoning,
+            toolUsage,
+        });
+        // Save executor output using service
+        const filePath = await executorOutputStore.save(executorOutput);
+        this.log(`  ✓ Executor output saved: ${filePath}`);
+        this.log('');
+        return { executorOutput, filePath };
+    }
+}

package/dist/commands/gen-rules.d.ts

@@ -0,0 +1,26 @@
+import { Command } from '@oclif/core';
+import { type Agent } from '../core/domain/entities/agent.js';
+import { type IRuleWriterService } from '../core/interfaces/i-rule-writer-service.js';
+import { ITrackingService } from '../core/interfaces/i-tracking-service.js';
+export default class GenRules extends Command {
+    static description: string;
+    static examples: string[];
+    protected createServices(): {
+        ruleWriterService: IRuleWriterService;
+        trackingService: ITrackingService;
+    };
+    /**
+     * 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.
+     * @param agent The agent for which the rule file exists
+     * @returns True if the user confirms overwrite, false otherwise
+     */
+    protected promptForOverwriteConfirmation(agent: Agent): Promise<boolean>;
+    run(): Promise<void>;
+}

package/dist/commands/gen-rules.js

@@ -0,0 +1,89 @@
+import { confirm, search } from '@inquirer/prompts';
+import { Command } 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';
+import { RuleTemplateService } from '../infra/rule/rule-template-service.js';
+import { RuleWriterService } from '../infra/rule/rule-writer-service.js';
+import { KeychainTokenStore } from '../infra/storage/keychain-token-store.js';
+import { FsTemplateLoader } from '../infra/template/fs-template-loader.js';
+import { MixpanelTrackingService } from '../infra/tracking/mixpanel-tracking-service.js';
+/**
+ * Array of all agents with name and value properties.
+ * Useful for UI components like select dropdowns.
+ */
+const AGENTS = AGENT_VALUES.map((agent) => ({
+    name: agent,
+    value: agent,
+}));
+export default class GenRules extends Command {
+    static description = 'Generate rule instructions for coding agents to work with ByteRover correctly';
+    static examples = ['<%= config.bin %> <%= command.id %>'];
+    createServices() {
+        const fileService = new FsFileService();
+        const templateLoader = new FsTemplateLoader(fileService);
+        const templateService = new RuleTemplateService(templateLoader);
+        return {
+            ruleWriterService: new RuleWriterService(fileService, templateService),
+            trackingService: new MixpanelTrackingService(new KeychainTokenStore()),
+        };
+    }
+    /**
+     * Prompts the user to select an agent.
+     * This method is protected to allow test overrides.
+     * @returns The selected agent
+     */
+    async promptForAgentSelection() {
+        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.
+     * @param agent The agent for which the rule file exists
+     * @returns True if the user confirms overwrite, false otherwise
+     */
+    async promptForOverwriteConfirmation(agent) {
+        return confirm({
+            default: true,
+            message: `Rule file already exists for ${agent}. Overwrite?`,
+        });
+    }
+    async run() {
+        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}`);
+                }
+                else {
+                    this.log(`Skipping rule file generation for ${answer}`);
+                }
+            }
+            else {
+                // Non-recoverable error
+                this.error(`Failed to generate rule file: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+    }
+}

package/dist/commands/init.d.ts

@@ -0,0 +1,24 @@
+import { Command } from '@oclif/core';
+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 { IProjectConfigStore } from '../core/interfaces/i-project-config-store.js';
+import type { ISpaceService } from '../core/interfaces/i-space-service.js';
+import type { ITeamService } from '../core/interfaces/i-team-service.js';
+import type { ITokenStore } from '../core/interfaces/i-token-store.js';
+import { ITrackingService } from '../core/interfaces/i-tracking-service.js';
+export default class Init extends Command {
+    static description: string;
+    static examples: string[];
+    protected createServices(): {
+        playbookService: IPlaybookService;
+        projectConfigStore: IProjectConfigStore;
+        spaceService: ISpaceService;
+        teamService: ITeamService;
+        tokenStore: ITokenStore;
+        trackingService: ITrackingService;
+    };
+    protected promptForSpaceSelection(spaces: Space[]): Promise<Space>;
+    protected promptForTeamSelection(teams: Team[]): Promise<Team>;
+    run(): Promise<void>;
+}

package/dist/commands/init.js

@@ -0,0 +1,135 @@
+import { select } from '@inquirer/prompts';
+import { Command, ux } from '@oclif/core';
+import { getCurrentConfig } from '../config/environment.js';
+import { BrConfig } from '../core/domain/entities/br-config.js';
+import { ProjectConfigStore } from '../infra/config/file-config-store.js';
+import { FilePlaybookService } from '../infra/playbook/file-playbook-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 { MixpanelTrackingService } from '../infra/tracking/mixpanel-tracking-service.js';
+export default class Init extends Command {
+    static description = 'Initialize a project with ByteRover (creates .br/config.json with team/space selection and initializes ACE playbook)';
+    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 %>',
+    ];
+    createServices() {
+        const envConfig = getCurrentConfig();
+        const tokenStore = new KeychainTokenStore();
+        const trackingService = new MixpanelTrackingService(tokenStore);
+        return {
+            playbookService: new FilePlaybookService(),
+            projectConfigStore: new ProjectConfigStore(),
+            spaceService: new HttpSpaceService({
+                apiBaseUrl: envConfig.apiBaseUrl,
+            }),
+            teamService: new HttpTeamService({
+                apiBaseUrl: envConfig.apiBaseUrl,
+            }),
+            tokenStore,
+            trackingService,
+        };
+    }
+    async promptForSpaceSelection(spaces) {
+        const selectedSpaceId = await 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.error('Space selection failed');
+        }
+        return selectedSpace;
+    }
+    async promptForTeamSelection(teams) {
+        const selectedTeamId = await 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.error('Team selection failed');
+        }
+        return selectedTeam;
+    }
+    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;
+            }
+            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 "br login" first.');
+            }
+            if (!token.isValid()) {
+                this.error('Authentication token expired. Please run "br 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.error('No teams found. Please create a team in the ByteRover dashboard first.');
+            }
+            // 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.error(`No spaces found in team "${selectedTeam.getDisplayName()}". Please create a space in the ByteRover dashboard first.`);
+            }
+            // 6. Prompt for space selection
+            this.log();
+            const selectedSpace = await this.promptForSpaceSelection(spaces);
+            // 7. Create and save configuration
+            const config = BrConfig.fromSpace(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 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: .br/config.json`);
+        }
+        catch (error) {
+            this.error(error instanceof Error ? error.message : 'Initialization failed');
+        }
+    }
+}

package/dist/commands/login.d.ts

@@ -0,0 +1,22 @@
+import { Command } from '@oclif/core';
+import type { IAuthService } from '../core/interfaces/i-auth-service.js';
+import type { IBrowserLauncher } from '../core/interfaces/i-browser-launcher.js';
+import type { ICallbackHandler } from '../core/interfaces/i-callback-handler.js';
+import type { IOidcDiscoveryService } from '../core/interfaces/i-oidc-discovery-service.js';
+import type { ITokenStore } from '../core/interfaces/i-token-store.js';
+import type { IUserService } from '../core/interfaces/i-user-service.js';
+import { ITrackingService } from '../core/interfaces/i-tracking-service.js';
+export default class Login extends Command {
+    static description: string;
+    static examples: string[];
+    protected createAuthService(discoveryService: IOidcDiscoveryService): Promise<IAuthService>;
+    protected createServices(): {
+        browserLauncher: IBrowserLauncher;
+        callbackHandler: ICallbackHandler;
+        discoveryService: IOidcDiscoveryService;
+        tokenStore: ITokenStore;
+        trackingService: ITrackingService;
+        userService: IUserService;
+    };
+    run(): Promise<void>;
+}