byterover-cli 0.3.4 → 0.4.0

package/dist/infra/usecase/curate-use-case.js

@@ -0,0 +1,283 @@
+import { randomUUID } from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
+import open from 'open';
+import { CONTEXT_TREE_DOMAINS } from '../../config/context-tree-domains.js';
+import { BRV_DIR, CONTEXT_FILE, CONTEXT_TREE_DIR } from '../../constants.js';
+import { validateFileForCurate } from '../../utils/file-validator.js';
+import { getAgentStorage } from '../cipher/storage/agent-storage.js';
+import { WorkspaceNotInitializedError } from '../cipher/validation/workspace-validator.js';
+// Full path to context tree
+const CONTEXT_TREE_PATH = path.join(BRV_DIR, CONTEXT_TREE_DIR);
+export class CurateUseCase {
+    projectConfigStore;
+    terminal;
+    tokenStore;
+    trackingService;
+    constructor(options) {
+        this.projectConfigStore = options.projectConfigStore;
+        this.terminal = options.terminal;
+        this.tokenStore = options.tokenStore;
+        this.trackingService = options.trackingService;
+    }
+    /**
+     * Create topic folder with context.md file
+     * @param targetPath - The parent path where the topic folder will be created
+     * @param topicName - The name of the topic folder to create
+     * @returns The path to the created context.md file
+     */
+    createTopicWithContextFile(targetPath, topicName) {
+        const topicPath = path.join(targetPath, topicName);
+        const contextFilePath = path.join(topicPath, CONTEXT_FILE);
+        // Create the topic directory
+        fs.mkdirSync(topicPath, { recursive: true });
+        // Create the context.md file with initial content
+        const initialContent = `# ${topicName}\n\n<!-- Add your context here -->\n`;
+        fs.writeFileSync(contextFilePath, initialContent, 'utf8');
+        return contextFilePath;
+    }
+    /**
+     * Generate a unique session ID for the autonomous agent.
+     * Uses crypto.randomUUID() for guaranteed uniqueness (122 bits of entropy).
+     */
+    generateSessionId() {
+        return randomUUID();
+    }
+    /**
+     * Navigate through the context tree using file selector
+     * Returns the selected path relative to context-tree root
+     */
+    async navigateContextTree() {
+        const contextTreePath = path.resolve(process.cwd(), CONTEXT_TREE_PATH);
+        // Ensure context tree directory exists
+        if (!fs.existsSync(contextTreePath)) {
+            fs.mkdirSync(contextTreePath, { recursive: true });
+        }
+        // Ensure predefined domains exist as directories
+        for (const domain of CONTEXT_TREE_DOMAINS) {
+            const domainPath = path.join(contextTreePath, domain.name);
+            if (!fs.existsSync(domainPath)) {
+                fs.mkdirSync(domainPath, { recursive: true });
+            }
+        }
+        while (true) {
+            try {
+                // eslint-disable-next-line no-await-in-loop
+                const selectedItem = await this.terminal.fileSelector({
+                    allowCancel: true,
+                    basePath: contextTreePath,
+                    filter: (item) => item.isDirectory,
+                    message: 'Target context location:',
+                    pageSize: 15,
+                    theme: {
+                        labels: {
+                            messages: {
+                                cancel: 'Selection cancelled.',
+                                empty: 'No sub-folders. Press Enter to add content here.',
+                            },
+                        },
+                    },
+                    type: 'directory',
+                });
+                // User cancelled
+                if (!selectedItem) {
+                    return null;
+                }
+                // Restrict navigation to stay within the context tree
+                const normalizedItemPath = path.resolve(selectedItem.path);
+                const isValid = normalizedItemPath.startsWith(contextTreePath);
+                if (isValid) {
+                    // Valid selection - proceed
+                    return selectedItem.path;
+                }
+                // Invalid selection - retry
+                this.terminal.log('Invalid selection. Please choose a valid location within the context tree.');
+            }
+            catch {
+                // Error occurred
+                return null;
+            }
+        }
+    }
+    /**
+     * Open a file in the default editor
+     * @param filePath - The path to the file to open
+     */
+    async openFile(filePath) {
+        await open(filePath);
+    }
+    /**
+     * Prompt user to enter topic name with validation
+     * @param targetPath - The path where the topic folder will be created
+     * @returns The topic name or null if cancelled
+     */
+    async promptForTopicName(targetPath) {
+        try {
+            const topicName = await this.terminal.input({
+                message: 'New topic name:',
+                validate: (value) => this.validateTopicName(value, targetPath),
+            });
+            return topicName.trim();
+        }
+        catch {
+            return null;
+        }
+    }
+    async run(options) {
+        // Determine mode: autonomous if context is provided
+        return options.context ? this.runAutonomous(options.context, options) : this.runInteractive();
+    }
+    /**
+     * Handle workspace not initialized error
+     */
+    handleWorkspaceError(_error) {
+        const message = 'Project not initialized. Please run "brv init" to select your team and workspace.';
+        this.terminal.log(message);
+    }
+    /**
+     * Process file paths from --files flag
+     * @param filePaths - Array of file paths (relative or absolute)
+     * @returns Formatted instructions for the agent to read the specified files, or undefined if validation fails
+     */
+    processFileReferences(filePaths) {
+        const MAX_FILES = 5;
+        if (!filePaths || filePaths.length === 0) {
+            return '';
+        }
+        // Validate max files and truncate if needed
+        if (filePaths.length > MAX_FILES) {
+            const ignored = filePaths.slice(MAX_FILES);
+            this.terminal.log(`\n⚠️  Only the first ${MAX_FILES} files will be processed. Ignoring: ${ignored.join(', ')}\n`);
+            filePaths = filePaths.slice(0, MAX_FILES);
+        }
+        // Get project root (current directory with .brv)
+        const projectRoot = process.cwd();
+        // Validate each file and collect errors
+        const validPaths = [];
+        const errors = [];
+        for (const filePath of filePaths) {
+            const result = validateFileForCurate(filePath, projectRoot);
+            if (result.valid && result.normalizedPath) {
+                validPaths.push(result.normalizedPath);
+            }
+            else {
+                errors.push(`  ✗ ${result.error}`);
+            }
+        }
+        // If there are any validation errors, show them and return undefined
+        if (errors.length > 0) {
+            this.terminal.log('\n❌ File validation failed:\n');
+            this.terminal.log(errors.join('\n'));
+            this.terminal.log('');
+            this.terminal.log('Invalid files provided. Please fix the errors above and try again.');
+            return undefined;
+        }
+        // Format instructions for the agent
+        const instructions = [
+            '\n## IMPORTANT: Critical Files to Read (--files flag)',
+            '',
+            'The user has explicitly specified these files as critical context that MUST be read before creating knowledge topics:',
+            '',
+            ...validPaths.map((p) => `- ${p}`),
+            '',
+            '**MANDATORY INSTRUCTIONS:**',
+            '- You MUST use the `read_file` tool to read ALL of these files IN PARALLEL (in a single iteration) before proceeding to create knowledge topics',
+            '- These files contain essential context that will help you create comprehensive and accurate knowledge topics',
+            '- Read them in parallel to maximize efficiency - they do not depend on each other',
+            '- After reading all files, proceed with the normal workflow: detect domains, find existing knowledge, and create/update topics',
+            '',
+        ];
+        return instructions.join('\n');
+    }
+    /**
+     * Run in autonomous mode - push to queue for background processing
+     */
+    async runAutonomous(content, options) {
+        try {
+            // Get authentication token
+            const token = await this.tokenStore.load();
+            if (!token) {
+                this.terminal.log('Authentication required. Please run "brv login" first.');
+                return;
+            }
+            // Load project config
+            const brvConfig = await this.projectConfigStore.read();
+            // Validate workspace is initialized
+            if (!brvConfig) {
+                throw new WorkspaceNotInitializedError('Project not initialized. Please run "brv init" to select your team and workspace.', '.brv');
+            }
+            // Process file references if provided (validates and creates instructions)
+            const fileReferenceInstructions = this.processFileReferences(options.files ?? []);
+            if (fileReferenceInstructions === undefined) {
+                // Validation failed, error already displayed
+                return;
+            }
+            // Initialize storage and create execution (auto-detects .brv/blobs)
+            const storage = await getAgentStorage();
+            // Create execution with status='queued'
+            storage.createExecution('curate', JSON.stringify({
+                content,
+                fileReferenceInstructions,
+                flags: { apiKey: options.apiKey, model: options.model, verbose: options.verbose },
+            }));
+            // Simple output for agents - just confirm saved
+            this.terminal.log('✓ Context queued for processing.');
+            // Track the event
+            await this.trackingService.track('mem:curate');
+        }
+        catch (error) {
+            if (error instanceof WorkspaceNotInitializedError) {
+                this.handleWorkspaceError(error);
+                return;
+            }
+            // Display error
+            this.terminal.error(error instanceof Error ? error.message : 'Runtime error occurred');
+        }
+    }
+    /**
+     * Run in interactive mode with manual prompts
+     */
+    async runInteractive() {
+        try {
+            // Navigate to target location in context tree
+            const targetPath = await this.navigateContextTree();
+            if (!targetPath) {
+                this.terminal.log('\nOperation cancelled.');
+                return;
+            }
+            // Prompt for topic name with validation
+            const topicName = await this.promptForTopicName(targetPath);
+            if (!topicName) {
+                this.terminal.log('\nOperation cancelled.');
+                return;
+            }
+            // Create the topic folder with context.md
+            const contextFilePath = this.createTopicWithContextFile(targetPath, topicName);
+            this.terminal.log(`\nCreated: ${path.relative(process.cwd(), contextFilePath)}`);
+            // Track the event
+            this.trackingService.track('mem:curate');
+            // Auto-open context.md in default editor
+            this.terminal.log('Opening context.md for editing...');
+            await this.openFile(contextFilePath);
+        }
+        catch (error) {
+            this.terminal.error(error instanceof Error ? error.message : 'Unexpected error occurred');
+        }
+    }
+    validateTopicName(value, targetPath) {
+        const trimmed = value.trim();
+        if (!trimmed) {
+            return 'Topic name cannot be empty';
+        }
+        // Only allow letters, numbers, and hyphens
+        if (!/^[a-zA-Z0-9-]+$/.test(trimmed)) {
+            return 'Topic name can only contain letters (a-z, A-Z), numbers (0-9), and hyphens (-)';
+        }
+        // Check if folder already exists
+        const topicPath = path.join(targetPath, trimmed);
+        if (fs.existsSync(topicPath)) {
+            return `Topic "${trimmed}" already exists at this location`;
+        }
+        return true;
+    }
+}

package/dist/{commands/gen-rules.d.ts → infra/usecase/generate-rules-use-case.d.ts}

@@ -1,31 +1,25 @@
-import { Command } from '@oclif/core';
-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';
+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 { ITerminal } from '../../core/interfaces/i-terminal.js';
+import type { ITrackingService } from '../../core/interfaces/i-tracking-service.js';
+import type { IGenerateRulesUseCase } from '../../core/interfaces/usecase/i-generate-rules-use-case.js';
+import { LegacyRuleDetector } from '../rule/legacy-rule-detector.js';
 type CleanupStrategy = 'automatic' | 'manual';
-export default class GenRules extends Command {
-    static description: string;
-    static examples: string[];
-    static flags: {
-        agent: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
-    };
-    protected createServices(): {
-        fileService: IFileService;
-        legacyRuleDetector: LegacyRuleDetector;
-        templateService: IRuleTemplateService;
-        trackingService: ITrackingService;
-    };
+export declare class GenerateRulesUseCase implements IGenerateRulesUseCase {
+    private readonly fileService;
+    private readonly legacyRuleDetector;
+    private readonly templateService;
+    private readonly terminal;
+    private readonly trackingService;
+    constructor(fileService: IFileService, legacyRuleDetector: LegacyRuleDetector, templateService: IRuleTemplateService, terminal: ITerminal, 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 choose cleanup strategy for legacy rules.
-     * This method is protected to allow test overrides.
      * @returns The chosen cleanup strategy
      */
     protected promptForCleanupStrategy(): Promise<CleanupStrategy>;

package/dist/{commands/gen-rules.js → infra/usecase/generate-rules-use-case.js}

@@ -1,14 +1,6 @@
-import { confirm, search, select } from '@inquirer/prompts';
-import { Command, Flags } from '@oclif/core';
-import { AGENT_VALUES } from '../core/domain/entities/agent.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 { 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';
+import { AGENT_VALUES } from '../../core/domain/entities/agent.js';
+import { AGENT_RULE_CONFIGS } from '../rule/agent-rule-config.js';
+import { BRV_RULE_MARKERS, BRV_RULE_TAG } from '../rule/constants.js';
 /**
  * Array of all agents with name and value properties.
  * Useful for UI components like select dropdowns.
@@ -17,50 +9,41 @@ 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 %>'];
-    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);
-        const templateService = new RuleTemplateService(templateLoader);
-        return {
-            fileService,
-            legacyRuleDetector: new LegacyRuleDetector(),
-            templateService,
-            trackingService: new MixpanelTrackingService(new KeychainTokenStore()),
-        };
+export class GenerateRulesUseCase {
+    fileService;
+    legacyRuleDetector;
+    templateService;
+    terminal;
+    trackingService;
+    // eslint-disable-next-line max-params
+    constructor(fileService, legacyRuleDetector, templateService, terminal, trackingService) {
+        this.fileService = fileService;
+        this.legacyRuleDetector = legacyRuleDetector;
+        this.templateService = templateService;
+        this.terminal = terminal;
+        this.trackingService = trackingService;
     }
     /**
      * 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({
+        return this.terminal.search({
             message: 'Which agent you are using (type to search):',
-            async source(input) {
+            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 choose cleanup strategy for legacy rules.
-     * This method is protected to allow test overrides.
      * @returns The chosen cleanup strategy
      */
     async promptForCleanupStrategy() {
-        return select({
+        return this.terminal.select({
             choices: [
                 {
                     description: 'New rules will be added with boundary markers. You manually remove old sections at your convenience.',
@@ -84,7 +67,7 @@ export default class GenRules extends Command {
      * @returns True if the user wants to create the file, false otherwise
      */
     async promptForFileCreation(agent, filePath) {
-        return confirm({
+        return this.terminal.confirm({
             default: true,
             message: `Rule file '${filePath}' doesn't exist. Create it with ByteRover rules?`,
         });
@@ -96,36 +79,35 @@ export default class GenRules extends Command {
      * @returns True if the user confirms overwrite, false otherwise
      */
     async promptForOverwriteConfirmation(agent) {
-        return confirm({
+        return this.terminal.confirm({
             default: true,
             message: `Rule file already exists for ${agent}. Overwrite?`,
         });
     }
     async run() {
-        const { fileService, legacyRuleDetector, templateService, trackingService } = this.createServices();
-        await trackingService.track('rule:generate');
+        await this.trackingService.track('rule:generate');
         const selectedAgent = await this.promptForAgentSelection();
         const { filePath, writeMode } = AGENT_RULE_CONFIGS[selectedAgent];
-        this.log(`Generating rules for: ${selectedAgent}`);
+        this.terminal.log(`Generating rules for: ${selectedAgent}`);
         // STEP 1: Check if file exists
-        const fileExists = await fileService.exists(filePath);
+        const fileExists = await this.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}`);
+                this.terminal.log(`Skipped rule file creation for ${selectedAgent}`);
                 return;
             }
             await this.createNewRuleFile({
                 agent: selectedAgent,
                 filePath,
-                fileService,
-                templateService,
+                fileService: this.fileService,
+                templateService: this.templateService,
             });
             return;
         }
         // STEP 2: File exists - read content
-        const content = await fileService.read(filePath);
+        const content = await this.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);
@@ -136,9 +118,9 @@ export default class GenRules extends Command {
                 agent: selectedAgent,
                 content,
                 filePath,
-                fileService,
-                legacyRuleDetector,
-                templateService,
+                fileService: this.fileService,
+                legacyRuleDetector: this.legacyRuleDetector,
+                templateService: this.templateService,
             });
             return;
         }
@@ -147,15 +129,15 @@ export default class GenRules extends Command {
             // Scenario C: New rules exist - prompt for overwrite
             const shouldOverwrite = await this.promptForOverwriteConfirmation(selectedAgent);
             if (!shouldOverwrite) {
-                this.log(`Skipped rule file update for ${selectedAgent}`);
+                this.terminal.log(`Skipped rule file update for ${selectedAgent}`);
                 return;
             }
             await this.replaceExistingRules({
                 agent: selectedAgent,
                 content,
                 filePath,
-                fileService,
-                templateService,
+                fileService: this.fileService,
+                templateService: this.templateService,
                 writeMode,
             });
             return;
@@ -164,8 +146,8 @@ export default class GenRules extends Command {
         await this.appendRulesToFile({
             agent: selectedAgent,
             filePath,
-            fileService,
-            templateService,
+            fileService: this.fileService,
+            templateService: this.templateService,
             writeMode,
         });
     }
@@ -178,7 +160,7 @@ export default class GenRules extends Command {
         // 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}`);
+        this.terminal.log(`✅ Successfully added rule file for ${agent}`);
     }
     /**
      * Creates a new rule file with ByteRover rules.
@@ -187,7 +169,7 @@ export default class GenRules extends Command {
         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}`);
+        this.terminal.log(`✅ Successfully created rule file for ${agent} at ${filePath}`);
     }
     /**
      * Handles legacy rules cleanup with user choice of automatic or manual.
@@ -196,22 +178,21 @@ export default class GenRules extends Command {
         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`);
+        this.terminal.log(`\n⚠️  Detected ${reliableMatches.length + uncertainMatches.length} old ByteRover rule section(s) in ${filePath}:\n`);
         if (reliableMatches.length > 0) {
-            this.log('Reliable matches:');
+            this.terminal.log('Reliable matches:');
             for (const [index, match] of reliableMatches.entries()) {
-                this.log(`  Section ${index + 1}: lines ${match.startLine}-${match.endLine}`);
+                this.terminal.log(`  Section ${index + 1}: lines ${match.startLine}-${match.endLine}`);
             }
-            this.log();
+            this.terminal.log('');
         }
         if (uncertainMatches.length > 0) {
-            this.log('  ⚠️  Uncertain matches (cannot determine start):');
+            this.terminal.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.terminal.log(`  Footer found at line ${match.footerLine}`);
+                this.terminal.log(`  Reason: ${match.reason}`);
             }
-            this.log();
-            this.log('⚠️  Due to uncertain matches, only manual cleanup is available.\n');
+            this.terminal.log('\n⚠️  Due to uncertain matches, only manual cleanup is available.\n');
             await this.performManualCleanup({
                 agent,
                 filePath,
@@ -243,7 +224,7 @@ export default class GenRules extends Command {
     async performAutomaticCleanup(params) {
         const { agent, filePath, fileService, reliableMatches, templateService } = params;
         const backupPath = await fileService.createBackup(filePath);
-        this.log(`📦 Backup created: ${backupPath}`);
+        this.terminal.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);
@@ -255,25 +236,25 @@ export default class GenRules extends Command {
         // 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.`);
+        this.terminal.log(`✅ Removed ${reliableMatches.length} old ByteRover section(s)`);
+        this.terminal.log(`✅ Added new rules with boundary markers`);
+        this.terminal.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:');
+        this.terminal.log(`✅ New ByteRover rules added with boundary markers\n`);
+        this.terminal.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}`);
+            this.terminal.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.terminal.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 -->');
+        this.terminal.log('\nKeep only the section between:');
+        this.terminal.log('  <!-- BEGIN BYTEROVER RULES -->');
+        this.terminal.log('  <!-- END BYTEROVER RULES -->');
     }
     /**
      * Replaces existing ByteRover rules (with boundary markers) with new rules.
@@ -292,13 +273,13 @@ export default class GenRules extends Command {
             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');
+                this.terminal.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}`);
+        this.terminal.log(`✅ Successfully updated rule file for ${agent}`);
     }
 }