byterover-cli 0.2.1 → 0.3.0

package/dist/commands/clear.js

@@ -1,12 +1,15 @@
 import { confirm } from '@inquirer/prompts';
 import { Args, Command, Flags } from '@oclif/core';
-import { Playbook } from '../core/domain/entities/playbook.js';
-import { FilePlaybookStore } from '../infra/ace/file-playbook-store.js';
+import { rm } from 'node:fs/promises';
+import { join } from 'node:path';
+import { BRV_DIR, CONTEXT_TREE_DIR } from '../constants.js';
+import { FileContextTreeService } from '../infra/context-tree/file-context-tree-service.js';
+import { FileContextTreeSnapshotService } from '../infra/context-tree/file-context-tree-snapshot-service.js';
 export default class Clear extends Command {
     static args = {
         directory: Args.string({ description: 'Project directory (defaults to current directory)', required: false }),
     };
-    static description = 'Clear local ACE context (playbook) managed by ByteRover CLI';
+    static description = 'Reset the context tree to its original state (6 default domains)';
     static examples = [
         '<%= config.bin %> <%= command.id %>',
         '<%= config.bin %> <%= command.id %> --yes',
@@ -23,35 +26,53 @@ export default class Clear extends Command {
     async confirmClear() {
         return confirm({
             default: false,
-            message: 'Are you sure you want to clear the playbook? This action cannot be undone.',
+            message: 'Are you sure you want to reset the context tree? This will remove all existing context and restore default domains.',
         });
     }
+    createServices() {
+        return {
+            contextTreeService: new FileContextTreeService(),
+            contextTreeSnapshotService: new FileContextTreeSnapshotService(),
+        };
+    }
     async run() {
         const { args, flags } = await this.parse(Clear);
         try {
-            // Setup dependencies
-            const playbookStore = new FilePlaybookStore();
-            // Check if playbook exists
-            const exists = await playbookStore.exists(args.directory);
+            const { contextTreeService, contextTreeSnapshotService } = this.createServices();
+            // Check if context tree exists
+            const exists = await contextTreeService.exists(args.directory);
             if (!exists) {
-                this.log('No playbook found. Nothing to clear.');
+                this.log('No context tree found. Nothing to clear.');
                 return;
             }
             // Confirmation prompt (unless --yes flag is used)
             if (!flags.yes) {
                 const confirmed = await this.confirmClear();
                 if (!confirmed) {
-                    this.log('Cancelled. Playbook was not cleared.');
+                    this.log('Cancelled. Context tree was not reset.');
                     return;
                 }
             }
-            // Reset the playbook to empty structure
-            const emptyPlaybook = new Playbook();
-            await playbookStore.save(emptyPlaybook, args.directory);
-            this.log('✓ Playbook cleared successfully.');
+            // Remove existing context tree directory
+            const baseDir = args.directory ?? process.cwd();
+            const contextTreeDir = join(baseDir, BRV_DIR, CONTEXT_TREE_DIR);
+            await rm(contextTreeDir, { force: true, recursive: true });
+            // Re-initialize context tree with default domains
+            await contextTreeService.initialize(args.directory);
+            // Re-initialize empty snapshot
+            await contextTreeSnapshotService.initEmptySnapshot(args.directory);
+            this.log('✓ Context tree reset successfully.');
+            this.log('  6 default domains restored: code_style, design, structure, compliance, testing, bug_fixes');
         }
         catch (error) {
-            this.error(error instanceof Error ? error.message : 'Failed to clear playbook');
+            // Handle user cancelling the 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. Context tree was not reset.');
+                return;
+            }
+            // For other errors, throw to let oclif handle display
+            this.error(error instanceof Error ? error.message : 'Failed to reset context tree');
         }
     }
 }

package/dist/commands/curate.d.ts

@@ -0,0 +1,74 @@
+import { Command } from '@oclif/core';
+import type { IProjectConfigStore } from '../core/interfaces/i-project-config-store.js';
+import type { ITrackingService } from '../core/interfaces/i-tracking-service.js';
+export default class Curate extends Command {
+    static args: {
+        context: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: string[];
+    static flags: {
+        apiKey?: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions> | undefined;
+        model?: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions> | undefined;
+        verbose?: import("@oclif/core/interfaces").BooleanFlag<boolean> | undefined;
+    };
+    catch(error: Error & {
+        oclif?: {
+            exit: number;
+        };
+    }): Promise<void>;
+    protected createServices(): {
+        projectConfigStore: IProjectConfigStore;
+        trackingService: ITrackingService;
+    };
+    /**
+     * 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
+     */
+    protected createTopicWithContextFile(targetPath: string, topicName: string): string;
+    /**
+     * Generate a unique session ID for the autonomous agent.
+     * Uses crypto.randomUUID() for guaranteed uniqueness (122 bits of entropy).
+     */
+    protected generateSessionId(): string;
+    /**
+     * Navigate through the context tree using file selector
+     * Returns the selected path relative to context-tree root
+     */
+    protected navigateContextTree(): Promise<null | string>;
+    /**
+     * Open a file in the default editor
+     * @param filePath - The path to the file to open
+     */
+    protected openFile(filePath: string): Promise<void>;
+    /**
+     * 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
+     */
+    protected promptForTopicName(targetPath: string): Promise<null | string>;
+    run(): Promise<void>;
+    /**
+     * Write content to context tree at given path
+     */
+    protected writeToContextTree(selectedPath: string, content: string): Promise<void>;
+    /**
+     * Handle workspace not initialized error
+     */
+    private handleWorkspaceError;
+    /**
+     * Run in autonomous mode using CipherAgent
+     */
+    private runAutonomous;
+    /**
+     * Run in interactive mode with manual prompts
+     */
+    private runInteractive;
+    /**
+     * Setup event listeners for CipherAgent
+     */
+    private setupEventListeners;
+    private validateTopicName;
+}

package/dist/commands/curate.js

@@ -0,0 +1,396 @@
+import { input } from '@inquirer/prompts';
+import { Args, Command, Flags } from '@oclif/core';
+import chalk from 'chalk';
+import { fileSelector, ItemType } from 'inquirer-file-selector';
+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 { getCurrentConfig, isDevelopment } from '../config/environment.js';
+import { BRV_DIR, CONTEXT_FILE, CONTEXT_TREE_DIR, PROJECT } from '../constants.js';
+import { CipherAgent } from '../infra/cipher/cipher-agent.js';
+import { ExitCode, ExitError, exitWithCode } from '../infra/cipher/exit-codes.js';
+import { WorkspaceNotInitializedError } from '../infra/cipher/validation/workspace-validator.js';
+import { ProjectConfigStore } from '../infra/config/file-config-store.js';
+import { KeychainTokenStore } from '../infra/storage/keychain-token-store.js';
+import { MixpanelTrackingService } from '../infra/tracking/mixpanel-tracking-service.js';
+import { addErrorPrefix } from '../utils/emoji-helpers.js';
+import { formatToolCall, formatToolResult } from '../utils/tool-display-formatter.js';
+// Full path to context tree
+const CONTEXT_TREE_PATH = path.join(BRV_DIR, CONTEXT_TREE_DIR);
+export default class Curate extends Command {
+    static args = {
+        context: Args.string({
+            description: 'Knowledge context: patterns, decisions, errors, or insights (triggers autonomous mode)',
+            required: false,
+        }),
+    };
+    static description = `Curate context to the context tree (interactive or autonomous mode)
+Good:
+- "Auth uses JWT with 24h expiry. Tokens stored in httpOnly cookies via authMiddleware.ts"
+- "API rate limit is 100 req/min per user. Implemented using Redis with sliding window in rateLimiter.ts"
+Bad:
+- "Authentication" or "JWT tokens" (too vague, lacks context)
+- "Rate limiting" (no implementation details or file references)`;
+    static examples = [
+        '# Interactive mode (manually choose domain/topic)',
+        '<%= config.bin %> <%= command.id %>',
+        '',
+        '# Autonomous mode - LLM auto-categorizes your context',
+        '<%= config.bin %> <%= command.id %> "Auth uses JWT with 24h expiry. Tokens stored in httpOnly cookies via authMiddleware.ts"',
+        '',
+        ...(isDevelopment()
+            ? [
+                '# Autonomous mode with OpenRouter (development only)',
+                '<%= config.bin %> <%= command.id %> -k YOUR_API_KEY "React components follow atomic design in src/components/. Atoms in atoms/, molecules in molecules/, organisms in organisms/"',
+                '',
+                '# Autonomous mode with custom model (development only)',
+                '<%= config.bin %> <%= command.id %> -k YOUR_API_KEY -m anthropic/claude-sonnet-4 "API rate limit is 100 req/min per user. Implemented using Redis with sliding window in rateLimiter.ts"',
+            ]
+            : []),
+    ];
+    static flags = {
+        ...(isDevelopment()
+            ? {
+                apiKey: Flags.string({
+                    char: 'k',
+                    description: 'OpenRouter API key (use OpenRouter instead of internal gRPC backend) [Development only]',
+                    env: 'OPENROUTER_API_KEY',
+                }),
+                model: Flags.string({
+                    char: 'm',
+                    description: 'Model to use (default: google/gemini-2.5-pro for OpenRouter, gemini-2.5-pro for gRPC) [Development only]',
+                }),
+                verbose: Flags.boolean({
+                    char: 'v',
+                    default: false,
+                    description: 'Enable verbose debug output [Development only]',
+                }),
+            }
+            : {}),
+    };
+    // Override catch to prevent oclif from logging errors that were already displayed
+    async catch(error) {
+        // Check if error is ExitError (message already displayed by exitWithCode)
+        if (error instanceof ExitError) {
+            return;
+        }
+        // Backwards compatibility: also check oclif.exit property
+        if (error.oclif?.exit !== undefined) {
+            return;
+        }
+        // For other errors, re-throw to let oclif handle them
+        throw error;
+    }
+    createServices() {
+        return {
+            projectConfigStore: new ProjectConfigStore(),
+            trackingService: new MixpanelTrackingService(new KeychainTokenStore()),
+        };
+    }
+    /**
+     * 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 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: ItemType.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.log(chalk.red('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 input({
+                message: 'New topic name:',
+                validate: (value) => this.validateTopicName(value, targetPath),
+            });
+            return topicName.trim();
+        }
+        catch {
+            return null;
+        }
+    }
+    async run() {
+        const { args, flags } = await this.parse(Curate);
+        // Determine mode: autonomous if context is provided via args
+        const contextInput = args.context;
+        // Autonomous mode: use CipherAgent to process context
+        // Interactive mode: manually prompt for domain/topic/context
+        return contextInput ? this.runAutonomous(contextInput, flags) : this.runInteractive();
+    }
+    /**
+     * Write content to context tree at given path
+     */
+    async writeToContextTree(selectedPath, content) {
+        const targetPath = path.join(CONTEXT_TREE_PATH, selectedPath);
+        const contextFilePath = path.join(targetPath, CONTEXT_FILE);
+        // Create directories if they don't exist
+        fs.mkdirSync(targetPath, { recursive: true });
+        // Append or create context file
+        const timestamp = new Date().toISOString();
+        const entry = `\n## Added on ${timestamp}\n\n${content}\n`;
+        const isNewFile = !fs.existsSync(contextFilePath);
+        const title = path.basename(selectedPath); // Use last segment as title
+        if (isNewFile) {
+            fs.writeFileSync(contextFilePath, `# ${title}\n${entry}`, 'utf8');
+        }
+        else {
+            fs.appendFileSync(contextFilePath, entry, 'utf8');
+        }
+        const action = isNewFile ? 'Created' : 'Updated';
+        this.log(`\n✓ ${action}: ${contextFilePath}`);
+    }
+    /**
+     * Handle workspace not initialized error
+     */
+    handleWorkspaceError(_error) {
+        const message = 'Project not initialized. Please run "brv init" to select your team and workspace.';
+        exitWithCode(ExitCode.VALIDATION_ERROR, message);
+    }
+    /**
+     * Run in autonomous mode using CipherAgent
+     */
+    async runAutonomous(content, flags) {
+        const { projectConfigStore, trackingService } = this.createServices();
+        try {
+            // Get authentication token
+            const tokenStore = new KeychainTokenStore();
+            const token = await tokenStore.load();
+            if (!token) {
+                exitWithCode(ExitCode.CONFIG_ERROR, 'Authentication required. Please run "brv login" first.');
+            }
+            // Load project config
+            const brvConfig = await 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');
+            }
+            // Create LLM config
+            const model = flags.model ?? (flags.apiKey ? 'google/gemini-2.5-pro' : 'gemini-2.5-pro');
+            const envConfig = getCurrentConfig();
+            const llmConfig = {
+                accessToken: token.accessToken,
+                fileSystemConfig: { workingDirectory: process.cwd() },
+                grpcEndpoint: envConfig.llmGrpcEndpoint,
+                maxIterations: 10,
+                maxTokens: 8192,
+                model,
+                openRouterApiKey: flags.apiKey,
+                projectId: PROJECT,
+                sessionKey: token.sessionKey,
+                teamId: brvConfig?.teamId ?? '',
+                temperature: 0.7,
+                verbose: flags.verbose ?? false,
+            };
+            // Create and start CipherAgent
+            const agent = new CipherAgent(llmConfig, brvConfig);
+            this.log('Starting autonomous context tree curation...');
+            await agent.start();
+            try {
+                const sessionId = this.generateSessionId();
+                // Setup event listeners
+                this.setupEventListeners(agent, flags.verbose ?? false);
+                // Execute with autonomous mode and add commandType
+                const prompt = `Add the following context to the context tree:\n\n${content}`;
+                const response = await agent.execute(prompt, sessionId, {
+                    executionContext: { commandType: 'curate' },
+                    mode: 'autonomous',
+                });
+                this.log('\nCipherAgent Response:');
+                this.log(response);
+                await trackingService.track('mem:curate');
+            }
+            finally {
+                // console.log('Logic for agent stopping and resource cleanup may go here!')
+            }
+        }
+        catch (error) {
+            if (error instanceof WorkspaceNotInitializedError) {
+                this.handleWorkspaceError(error);
+                return;
+            }
+            // Throw error to let oclif handle exit code
+            this.error(error instanceof Error ? error.message : 'Runtime error occurred', { exit: ExitCode.RUNTIME_ERROR });
+        }
+    }
+    /**
+     * Run in interactive mode with manual prompts
+     */
+    async runInteractive() {
+        const { trackingService } = this.createServices();
+        try {
+            // Navigate to target location in context tree
+            const targetPath = await this.navigateContextTree();
+            if (!targetPath) {
+                this.log('\nOperation cancelled.');
+                return;
+            }
+            // Prompt for topic name with validation
+            const topicName = await this.promptForTopicName(targetPath);
+            if (!topicName) {
+                this.log('\nOperation cancelled.');
+                return;
+            }
+            // Create the topic folder with context.md
+            const contextFilePath = this.createTopicWithContextFile(targetPath, topicName);
+            this.log(`\nCreated: ${contextFilePath}`);
+            // Track the event
+            trackingService.track('mem:curate');
+            // Auto-open context.md in default editor
+            this.log('Opening context.md for editing...');
+            await this.openFile(contextFilePath);
+        }
+        catch (error) {
+            this.error(error instanceof Error ? error.message : 'Unexpected error occurred');
+        }
+    }
+    /**
+     * Setup event listeners for CipherAgent
+     */
+    setupEventListeners(agent, verbose) {
+        if (!agent.agentEventBus) {
+            throw new Error('Agent event bus not initialized');
+        }
+        const eventBus = agent.agentEventBus;
+        if (verbose) {
+            // Verbose mode: show detailed events
+            eventBus.on('llmservice:thinking', () => {
+                this.log('🤔 [Event] LLM is thinking...');
+            });
+            eventBus.on('llmservice:response', (payload) => {
+                this.log(`✅ [Event] LLM Response (${payload.provider}/${payload.model})`);
+            });
+            eventBus.on('llmservice:toolCall', (payload) => {
+                const formattedCall = formatToolCall(payload.toolName, payload.args);
+                this.log(`🔧 [Event] Tool Call: ${formattedCall}`);
+            });
+            eventBus.on('llmservice:toolResult', (payload) => {
+                const resultSummary = formatToolResult(payload.toolName, payload.success, payload.result, payload.error);
+                if (payload.success) {
+                    this.log(`✓ [Event] Tool Success: ${payload.toolName} → ${resultSummary}`);
+                }
+                else {
+                    this.log(`✗ [Event] Tool Error: ${payload.toolName} → ${resultSummary}`);
+                }
+            });
+            eventBus.on('llmservice:error', (payload) => {
+                this.log(`❌ [Event] LLM Error: ${payload.error}`);
+            });
+        }
+        else {
+            // Non-verbose mode: show concise tool progress
+            eventBus.on('llmservice:toolCall', (payload) => {
+                this.log(`🔧 ${payload.toolName} → Executing...`);
+            });
+            eventBus.on('llmservice:toolResult', (payload) => {
+                if (payload.success) {
+                    this.log(`✅ ${payload.toolName} → Complete`);
+                }
+                else {
+                    this.log(`❌ ${payload.toolName} → Failed: ${payload.error ?? 'Unknown error'}`);
+                }
+            });
+            eventBus.on('llmservice:error', (payload) => {
+                this.log(addErrorPrefix(payload.error));
+            });
+        }
+    }
+    validateTopicName(value, targetPath) {
+        const trimmed = value.trim();
+        if (!trimmed) {
+            return 'Topic name cannot be empty';
+        }
+        // Check for invalid characters in folder names (filesystem restrictions)
+        if (/[/\0]/.test(trimmed)) {
+            return 'Topic name cannot contain "/" or null characters';
+        }
+        // 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/foo.d.ts

@@ -0,0 +1,12 @@
+import { Command } from '@oclif/core';
+import { ICodingAgentLogWatcher } from '../core/interfaces/cipher/i-coding-agent-log-watcher.js';
+import { IProjectConfigStore } from '../core/interfaces/i-project-config-store.js';
+export default class Foo extends Command {
+    static description: string;
+    static hidden: boolean;
+    protected createServices(): Promise<{
+        codingAgentLogWatcher: ICodingAgentLogWatcher;
+        projectConfigStore: IProjectConfigStore;
+    }>;
+    run(): Promise<void>;
+}

package/dist/commands/foo.js

@@ -0,0 +1,61 @@
+import { Command } from '@oclif/core';
+import { isDevelopment } from '../config/environment.js';
+import { CodingAgentLogParser } from '../infra/cipher/parsers/coding-agent-log-parser.js';
+import { CodingAgentLogWatcher } from '../infra/cipher/watcher/coding-agent-log-watcher.js';
+import { ProjectConfigStore } from '../infra/config/file-config-store.js';
+import { FileWatcherService } from '../infra/watcher/file-watcher-service.js';
+export default class Foo extends Command {
+    static description = 'Purely for testing CodingAgentLogWatcher [Development only]';
+    static hidden = !isDevelopment();
+    async createServices() {
+        const projectConfigStore = new ProjectConfigStore();
+        const fileWatcherService = new FileWatcherService();
+        const codingAgentLogParser = new CodingAgentLogParser();
+        const codingAgentLogWatcher = new CodingAgentLogWatcher(fileWatcherService, codingAgentLogParser);
+        return {
+            codingAgentLogWatcher,
+            projectConfigStore,
+        };
+    }
+    async run() {
+        if (!isDevelopment()) {
+            this.error('This command is only available in development environment');
+        }
+        const { codingAgentLogWatcher, projectConfigStore } = await this.createServices();
+        const projectConfig = await projectConfigStore.read();
+        if (projectConfig === undefined) {
+            this.error('No project config found. Run "brv init" first.');
+        }
+        // Defensive checking nill
+        if (projectConfig.chatLogPath === undefined) {
+            this.error('No chat log path configured in project config. Run "brv init" first.');
+        }
+        if (projectConfig.ide === undefined) {
+            this.error('No coding agent selected. Run "brv init" first.');
+        }
+        this.log(`Watching ${projectConfig.ide} log files...`);
+        await codingAgentLogWatcher.start({
+            codingAgentInfo: {
+                chatLogPath: projectConfig.chatLogPath,
+                name: projectConfig.ide,
+            },
+            onCleanSession: (cleanSession) => new Promise((resolve) => {
+                this.log(`New Clean Session from ${cleanSession.type}:`);
+                this.log(`Clean Session title: ${cleanSession.title}`);
+                this.log('Clean Session messages:');
+                for (const message of cleanSession.messages) {
+                    this.log(`${JSON.stringify(message, undefined, 2)}]\n`);
+                }
+                this.log(`Clean Session ID: ${cleanSession.id}`);
+                this.log(`Clean Session Metadata: ${JSON.stringify(cleanSession.metadata, undefined, 2)}`);
+                resolve();
+                this.log(`Clean Session timestamp: ${cleanSession.timestamp}`);
+                this.log(`Clean Session workspace paths:`);
+                for (const workspacePath of cleanSession.workspacePaths) {
+                    this.log(`${workspacePath}`);
+                }
+                this.log('\n\n');
+            }),
+        });
+    }
+}

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

@@ -5,6 +5,9 @@ import { ITrackingService } from '../core/interfaces/i-tracking-service.js';
 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(): {
         ruleWriterService: IRuleWriterService;
         trackingService: ITrackingService;