byterover-cli 0.3.2 → 0.3.4

package/dist/commands/cipher-agent/run.d.ts

@@ -1,5 +1,6 @@
 import { Command } from '@oclif/core';
 import type { IProjectConfigStore } from '../../core/interfaces/i-project-config-store.js';
+import { CipherAgent } from '../../infra/cipher/cipher-agent.js';
 export default class CipherAgentRun extends Command {
     static args: {
         prompt: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
@@ -41,7 +42,7 @@ export default class CipherAgentRun extends Command {
      * @param agent - CipherAgent instance
      * @returns Most recent session ID or undefined if no sessions found
      */
-    protected getMostRecentSessionId(agent: import('../../infra/cipher/cipher-agent.js').CipherAgent): Promise<string | undefined>;
+    protected getMostRecentSessionId(agent: CipherAgent): Promise<string | undefined>;
     run(): Promise<void>;
     /**
      * Validate that a session exists in storage.
@@ -50,7 +51,7 @@ export default class CipherAgentRun extends Command {
      * @param sessionId - Session ID to validate
      * @returns True if session exists
      */
-    protected validateSessionExists(agent: import('../../infra/cipher/cipher-agent.js').CipherAgent, sessionId: string): Promise<boolean>;
+    protected validateSessionExists(agent: CipherAgent, sessionId: string): Promise<boolean>;
     /**
      * Create LLM configuration from flags and environment
      *

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

@@ -1,7 +1,10 @@
 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';
+import type { Agent } from '../core/domain/entities/agent.js';
+import type { IFileService } from '../core/interfaces/i-file-service.js';
+import type { IRuleTemplateService } from '../core/interfaces/i-rule-template-service.js';
+import type { ITrackingService } from '../core/interfaces/i-tracking-service.js';
+import { LegacyRuleDetector } from '../infra/rule/legacy-rule-detector.js';
+type CleanupStrategy = 'automatic' | 'manual';
 export default class GenRules extends Command {
     static description: string;
     static examples: string[];
@@ -9,7 +12,9 @@ export default class GenRules extends Command {
         agent: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
     };
     protected createServices(): {
-        ruleWriterService: IRuleWriterService;
+        fileService: IFileService;
+        legacyRuleDetector: LegacyRuleDetector;
+        templateService: IRuleTemplateService;
         trackingService: ITrackingService;
     };
     /**
@@ -18,6 +23,20 @@ export default class GenRules extends Command {
      * @returns The selected agent
      */
     protected promptForAgentSelection(): Promise<Agent>;
+    /**
+     * Prompts the user to choose cleanup strategy for legacy rules.
+     * This method is protected to allow test overrides.
+     * @returns The chosen cleanup strategy
+     */
+    protected promptForCleanupStrategy(): Promise<CleanupStrategy>;
+    /**
+     * Prompts the user to create a new rule file.
+     * This method is protected to allow test overrides.
+     * @param agent The agent for which the rule file doesn't exist
+     * @param filePath The path where the file would be created
+     * @returns True if the user wants to create the file, false otherwise
+     */
+    protected promptForFileCreation(agent: Agent, filePath: string): Promise<boolean>;
     /**
      * Prompts the user to confirm overwriting an existing rule file.
      * This method is protected to allow test overrides.
@@ -26,4 +45,23 @@ export default class GenRules extends Command {
      */
     protected promptForOverwriteConfirmation(agent: Agent): Promise<boolean>;
     run(): Promise<void>;
+    /**
+     * Appends ByteRover rules to a file that has no ByteRover content.
+     */
+    private appendRulesToFile;
+    /**
+     * Creates a new rule file with ByteRover rules.
+     */
+    private createNewRuleFile;
+    /**
+     * Handles legacy rules cleanup with user choice of automatic or manual.
+     */
+    private handleLegacyRulesCleanup;
+    private performAutomaticCleanup;
+    private performManualCleanup;
+    /**
+     * Replaces existing ByteRover rules (with boundary markers) with new rules.
+     */
+    private replaceExistingRules;
 }
+export {};

package/dist/commands/gen-rules.js

@@ -1,10 +1,11 @@
-import { confirm, search } from '@inquirer/prompts';
+import { confirm, search, select } from '@inquirer/prompts';
 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';
+import { AGENT_RULE_CONFIGS } from '../infra/rule/agent-rule-config.js';
+import { BRV_RULE_MARKERS, BRV_RULE_TAG } from '../infra/rule/constants.js';
+import { LegacyRuleDetector } from '../infra/rule/legacy-rule-detector.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';
@@ -30,7 +31,9 @@ export default class GenRules extends Command {
         const templateLoader = new FsTemplateLoader(fileService);
         const templateService = new RuleTemplateService(templateLoader);
         return {
-            ruleWriterService: new RuleWriterService(fileService, templateService),
+            fileService,
+            legacyRuleDetector: new LegacyRuleDetector(),
+            templateService,
             trackingService: new MixpanelTrackingService(new KeychainTokenStore()),
         };
     }
@@ -51,6 +54,41 @@ export default class GenRules extends Command {
         });
         return answer;
     }
+    /**
+     * Prompts the user to choose cleanup strategy for legacy rules.
+     * This method is protected to allow test overrides.
+     * @returns The chosen cleanup strategy
+     */
+    async promptForCleanupStrategy() {
+        return select({
+            choices: [
+                {
+                    description: 'New rules will be added with boundary markers. You manually remove old sections at your convenience.',
+                    name: 'Manual cleanup (recommended)',
+                    value: 'manual',
+                },
+                {
+                    description: '⚠️  We will remove all detected old sections. May cause content loss if detection is imperfect. A backup will be created.',
+                    name: 'Automatic cleanup',
+                    value: 'automatic',
+                },
+            ],
+            message: 'How would you like to proceed?',
+        });
+    }
+    /**
+     * Prompts the user to create a new rule file.
+     * This method is protected to allow test overrides.
+     * @param agent The agent for which the rule file doesn't exist
+     * @param filePath The path where the file would be created
+     * @returns True if the user wants to create the file, false otherwise
+     */
+    async promptForFileCreation(agent, filePath) {
+        return confirm({
+            default: true,
+            message: `Rule file '${filePath}' doesn't exist. Create it with ByteRover rules?`,
+        });
+    }
     /**
      * Prompts the user to confirm overwriting an existing rule file.
      * This method is protected to allow test overrides.
@@ -64,45 +102,203 @@ export default class GenRules extends Command {
         });
     }
     async run() {
-        const { flags } = await this.parse(GenRules);
-        const { ruleWriterService, trackingService } = this.createServices();
-        try {
-            // 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 {
-                    // Non-recoverable error - throw to let oclif handle display
-                    this.error(`Failed to generate rule file: ${error instanceof Error ? error.message : String(error)}`);
-                }
+        const { fileService, legacyRuleDetector, templateService, trackingService } = this.createServices();
+        await trackingService.track('rule:generate');
+        const selectedAgent = await this.promptForAgentSelection();
+        const { filePath, writeMode } = AGENT_RULE_CONFIGS[selectedAgent];
+        this.log(`Generating rules for: ${selectedAgent}`);
+        // STEP 1: Check if file exists
+        const fileExists = await fileService.exists(filePath);
+        if (!fileExists) {
+            // Scenario A: File doesn't exist
+            const shouldCreate = await this.promptForFileCreation(selectedAgent, filePath);
+            if (!shouldCreate) {
+                this.log(`Skipped rule file creation for ${selectedAgent}`);
+                return;
             }
+            await this.createNewRuleFile({
+                agent: selectedAgent,
+                filePath,
+                fileService,
+                templateService,
+            });
+            return;
+        }
+        // STEP 2: File exists - read content
+        const content = await fileService.read(filePath);
+        // STEP 3: Check for LEGACY rules (priority: clean these up first)
+        const hasFooterTag = content.includes(`${BRV_RULE_TAG} ${selectedAgent}`);
+        const hasBoundaryMarkers = content.includes(BRV_RULE_MARKERS.START) && content.includes(BRV_RULE_MARKERS.END);
+        const hasLegacyRules = hasFooterTag && !hasBoundaryMarkers;
+        if (hasLegacyRules) {
+            // Scenario B: Legacy rules detected - handle cleanup
+            await this.handleLegacyRulesCleanup({
+                agent: selectedAgent,
+                content,
+                filePath,
+                fileService,
+                legacyRuleDetector,
+                templateService,
+            });
+            return;
         }
-        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.');
+        // STEP 4: Check for NEW rules (boundary markers)
+        if (hasBoundaryMarkers) {
+            // Scenario C: New rules exist - prompt for overwrite
+            const shouldOverwrite = await this.promptForOverwriteConfirmation(selectedAgent);
+            if (!shouldOverwrite) {
+                this.log(`Skipped rule file update for ${selectedAgent}`);
                 return;
             }
-            // For other errors, throw to let oclif handle display
-            this.error(error instanceof Error ? error.message : 'An error occurred');
+            await this.replaceExistingRules({
+                agent: selectedAgent,
+                content,
+                filePath,
+                fileService,
+                templateService,
+                writeMode,
+            });
+            return;
+        }
+        // STEP 5: No ByteRover content - append rules
+        await this.appendRulesToFile({
+            agent: selectedAgent,
+            filePath,
+            fileService,
+            templateService,
+            writeMode,
+        });
+    }
+    /**
+     * Appends ByteRover rules to a file that has no ByteRover content.
+     */
+    async appendRulesToFile(params) {
+        const { agent, filePath, fileService, templateService, writeMode } = params;
+        const ruleContent = await templateService.generateRuleContent(agent);
+        // For dedicated ByteRover files, overwrite; for shared instruction files, append
+        const mode = writeMode === 'overwrite' ? 'overwrite' : 'append';
+        await fileService.write(ruleContent, filePath, mode);
+        this.log(`✅ Successfully added rule file for ${agent}`);
+    }
+    /**
+     * Creates a new rule file with ByteRover rules.
+     */
+    async createNewRuleFile(params) {
+        const { agent, filePath, fileService, templateService } = params;
+        const ruleContent = await templateService.generateRuleContent(agent);
+        await fileService.write(ruleContent, filePath, 'overwrite');
+        this.log(`✅ Successfully created rule file for ${agent} at ${filePath}`);
+    }
+    /**
+     * Handles legacy rules cleanup with user choice of automatic or manual.
+     */
+    async handleLegacyRulesCleanup(params) {
+        const { agent, content, filePath, fileService, legacyRuleDetector, templateService } = params;
+        const detectionResult = legacyRuleDetector.detectLegacyRules(content, agent);
+        const { reliableMatches, uncertainMatches } = detectionResult;
+        this.log(`\n⚠️  Detected ${reliableMatches.length + uncertainMatches.length} old ByteRover rule section(s) in ${filePath}:\n`);
+        if (reliableMatches.length > 0) {
+            this.log('Reliable matches:');
+            for (const [index, match] of reliableMatches.entries()) {
+                this.log(`  Section ${index + 1}: lines ${match.startLine}-${match.endLine}`);
+            }
+            this.log();
+        }
+        if (uncertainMatches.length > 0) {
+            this.log('  ⚠️  Uncertain matches (cannot determine start):');
+            for (const match of uncertainMatches) {
+                this.log(`  Footer found at line ${match.footerLine}`);
+                this.log(`  Reason: ${match.reason}`);
+            }
+            this.log();
+            this.log('⚠️  Due to uncertain matches, only manual cleanup is available.\n');
+            await this.performManualCleanup({
+                agent,
+                filePath,
+                fileService,
+                reliableMatches,
+                templateService,
+                uncertainMatches,
+            });
+            return;
+        }
+        const selectedStrategy = await this.promptForCleanupStrategy();
+        await (selectedStrategy === 'manual'
+            ? this.performManualCleanup({
+                agent,
+                filePath,
+                fileService,
+                reliableMatches,
+                templateService,
+                uncertainMatches,
+            })
+            : this.performAutomaticCleanup({
+                agent,
+                filePath,
+                fileService,
+                reliableMatches,
+                templateService,
+            }));
+    }
+    async performAutomaticCleanup(params) {
+        const { agent, filePath, fileService, reliableMatches, templateService } = params;
+        const backupPath = await fileService.createBackup(filePath);
+        this.log(`📦 Backup created: ${backupPath}`);
+        let content = await fileService.read(filePath);
+        // Remove all reliable matches (in reverse order to preserve line numbers)
+        const sortedMatches = [...reliableMatches].sort((a, b) => b.startLine - a.startLine);
+        for (const match of sortedMatches) {
+            content = content.replace(match.content, '');
+        }
+        // Write cleaned content
+        await fileService.write(content, filePath, 'overwrite');
+        // Append new rules
+        const ruleContent = await templateService.generateRuleContent(agent);
+        await fileService.write(ruleContent, filePath, 'append');
+        this.log(`✅ Removed ${reliableMatches.length} old ByteRover section(s)`);
+        this.log(`✅ Added new rules with boundary markers`);
+        this.log(`\nYou can safely delete the backup file once verified.`);
+    }
+    async performManualCleanup(params) {
+        const { agent, filePath, fileService, reliableMatches, templateService, uncertainMatches } = params;
+        const ruleContent = await templateService.generateRuleContent(agent);
+        await fileService.write(ruleContent, filePath, 'append');
+        this.log(`✅ New ByteRover rules added with boundary markers\n`);
+        this.log('Please manually remove old sections:');
+        for (const [index, match] of reliableMatches.entries()) {
+            this.log(`  - Section ${index + 1}: lines ${match.startLine}-${match.endLine} in ${filePath}`);
+        }
+        for (const match of uncertainMatches) {
+            this.log(`  - Section ending at line ${match.footerLine} in ${filePath}`);
+        }
+        this.log('\nKeep only the section between:');
+        this.log('  <!-- BEGIN BYTEROVER RULES -->');
+        this.log('  <!-- END BYTEROVER RULES -->');
+    }
+    /**
+     * Replaces existing ByteRover rules (with boundary markers) with new rules.
+     */
+    async replaceExistingRules(params) {
+        const { agent, content, filePath, fileService, templateService, writeMode } = params;
+        const ruleContent = await templateService.generateRuleContent(agent);
+        if (writeMode === 'overwrite') {
+            // For dedicated ByteRover files, just overwrite the entire file
+            await fileService.write(ruleContent, filePath, 'overwrite');
+        }
+        else {
+            // For shared instruction files, replace the section between markers
+            const startMarker = BRV_RULE_MARKERS.START;
+            const endMarker = BRV_RULE_MARKERS.END;
+            const startIndex = content.indexOf(startMarker);
+            const endIndex = content.indexOf(endMarker, startIndex);
+            if (startIndex === -1 || endIndex === -1) {
+                this.error('Could not find boundary markers in the file');
+            }
+            const before = content.slice(0, startIndex);
+            const after = content.slice(endIndex + endMarker.length);
+            const newContent = before + ruleContent + after;
+            await fileService.write(newContent, filePath, 'overwrite');
         }
+        this.log(`✅ Successfully updated rule file for ${agent}`);
     }
 }

package/dist/commands/init.d.ts

@@ -7,13 +7,16 @@ import type { IContextTreeService } from '../core/interfaces/i-context-tree-serv
 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 { IFileService } from '../core/interfaces/i-file-service.js';
+import { ILegacyRuleDetector } from '../core/interfaces/i-legacy-rule-detector.js';
+import { IRuleTemplateService } from '../core/interfaces/i-rule-template-service.js';
 import { ITrackingService } from '../core/interfaces/i-tracking-service.js';
+type CleanupStrategy = 'automatic' | 'manual';
 /**
  * Represents a legacy config that exists but has version issues.
  * Used to display config info during re-initialization prompt.
@@ -41,10 +44,12 @@ export default class Init extends Command {
         contextTreeService: IContextTreeService;
         contextTreeSnapshotService: IContextTreeSnapshotService;
         contextTreeWriterService: IContextTreeWriterService;
+        fileService: IFileService;
+        legacyRuleDetector: ILegacyRuleDetector;
         projectConfigStore: IProjectConfigStore;
-        ruleWriterService: IRuleWriterService;
         spaceService: ISpaceService;
         teamService: ITeamService;
+        templateService: IRuleTemplateService;
         tokenStore: ITokenStore;
         trackingService: ITrackingService;
     };
@@ -55,10 +60,15 @@ export default class Init extends Command {
     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 generateRulesForAgent(selectedAgent: Agent, fileService: IFileService, templateService: IRuleTemplateService, legacyRuleDetector: ILegacyRuleDetector): 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;
+    /**
+     * Checks if the given path represents a README.md placeholder file.
+     * Handles both legacy paths with leading slash and new paths without.
+     */
+    protected isReadmePlaceholder(path: string): boolean;
     protected promptAceDeprecationRemoval(): Promise<boolean>;
     /**
      * Prompts the user to select an agent.
@@ -66,6 +76,20 @@ export default class Init extends Command {
      * @returns The selected agent
      */
     protected promptForAgentSelection(): Promise<Agent>;
+    /**
+     * Prompts the user to choose cleanup strategy for legacy rules.
+     * This method is protected to allow test overrides.
+     * @returns The chosen cleanup strategy
+     */
+    protected promptForCleanupStrategy(): Promise<CleanupStrategy>;
+    /**
+     * Prompts the user to create a new rule file.
+     * This method is protected to allow test overrides.
+     * @param agent The agent for which the rule file doesn't exist
+     * @param filePath The path where the file would be created
+     * @returns True if the user wants to create the file, false otherwise
+     */
+    protected promptForFileCreation(agent: Agent, filePath: string): Promise<boolean>;
     /**
      * Prompts the user to confirm overwriting an existing rule file.
      * This method is protected to allow test overrides.
@@ -86,5 +110,21 @@ export default class Init extends Command {
         };
         token: AuthToken;
     }): Promise<void>;
+    /**
+     * Appends ByteRover rules to a file that has no ByteRover content.
+     */
+    private appendRulesToFile;
+    /**
+     * Creates a new rule file with ByteRover rules.
+     */
+    private createNewRuleFile;
+    private handleLegacyRulesCleanup;
     private logSuccess;
+    private performAutomaticCleanup;
+    private performManualCleanup;
+    /**
+     * Replaces existing ByteRover rules (with boundary markers) with new rules.
+     */
+    private replaceExistingRules;
 }
+export {};