byterover-cli 0.4.0 → 1.0.0

package/dist/infra/cipher/consumer/execution-consumer.js

@@ -1,7 +1,8 @@
+// TODO(v0.5.0): Remove this file. ExecutionConsumer is replaced by TaskProcessor.
 import { randomUUID } from 'node:crypto';
 import { getCurrentConfig } from '../../../config/environment.js';
 import { PROJECT } from '../../../constants.js';
-import { CipherAgent } from '../cipher-agent.js';
+import { CipherAgent } from '../agent/index.js';
 import { closeAgentStorage, getAgentStorage, getAgentStorageSync } from '../storage/agent-storage.js';
 // Heartbeat interval for consumer liveness detection (10 seconds)
 const HEARTBEAT_INTERVAL_MS = 1000;
@@ -176,17 +177,23 @@ export class ExecutionConsumer {
         // console.log(`[Consumer] Stopped (${this.consumerId.slice(0, 8)})`)
     }
     /**
-     * Execute a curate job
+     * Execute a curate job using the Plan Agent for orchestration.
+     *
+     * The Plan Agent orchestrates the curation workflow by:
+     * 1. Analyzing the user's request
+     * 2. Delegating to Query subagent to find existing context
+     * 3. Delegating to Curate subagent to create/update topics
      */
     async executeCurate(execution) {
         const storage = getAgentStorageSync();
-        // Parse input
+        // Parse input - support both JSON format (legacy/v2) and plain text
         let input;
         try {
             input = JSON.parse(execution.input);
         }
         catch {
-            throw new Error('Invalid curate input: failed to parse JSON');
+            // Plain text format - wrap in CurateInput
+            input = { content: execution.input };
         }
         if (!input.content) {
             throw new Error('Invalid curate input: missing content');
@@ -195,45 +202,76 @@ export class ExecutionConsumer {
         if (!this.authToken) {
             throw new Error('No auth token available. Consumer needs authentication.');
         }
-        // Create LLM config
+        // Create LLM config with Plan Agent settings
+        // Plan Agent has read-only permissions and orchestrates via TaskTool
         const model = input.flags?.model ?? (input.flags?.apiKey ? 'google/gemini-2.5-pro' : 'gemini-2.5-pro');
         const envConfig = getCurrentConfig();
         const llmConfig = {
             accessToken: this.authToken.accessToken,
             apiBaseUrl: envConfig.llmApiBaseUrl,
-            fileSystemConfig: { workingDirectory: process.cwd() },
-            maxIterations: 10,
-            maxTokens: 8192,
+            fileSystem: { workingDirectory: process.cwd() },
+            llm: {
+                // Plan Agent uses more iterations to coordinate subagents
+                maxIterations: 15,
+                maxTokens: 8192,
+                temperature: 0.7,
+                verbose: input.flags?.verbose ?? false,
+            },
             model,
             openRouterApiKey: input.flags?.apiKey,
             projectId: PROJECT,
             sessionKey: this.authToken.sessionKey,
             teamId: this.brvConfig?.teamId ?? '',
-            temperature: 0.7,
-            verbose: input.flags?.verbose ?? false,
         };
         // Create and start CipherAgent
+        // Agent creates its default session during start() (Single-Session pattern)
+        // Create and start CipherAgent (will use Plan Agent's tools and prompt)
         const agent = new CipherAgent(llmConfig, this.brvConfig);
         await agent.start();
         try {
-            const sessionId = randomUUID();
             // Setup event listeners for tool call tracking
             this.setupToolCallTracking(agent, execution.id);
-            // Execute with autonomous mode
-            const prompt = `Add the following context to the context tree:\n\n${input.content}`;
-            const response = await agent.execute(prompt, sessionId, {
+            // Build the prompt for the Plan Agent
+            // The Plan Agent will orchestrate Query and Curate subagents via TaskTool
+            const fileReferenceSection = input.fileReferenceInstructions ? `\n${input.fileReferenceInstructions}` : '';
+            const prompt = `You are the Plan Agent orchestrating a context curation workflow.
+
+The user wants to add the following context to the context tree:
+
+---
+${input.content}
+---
+${fileReferenceSection}
+
+## Your Workflow
+
+1. **Query Phase**: Use the \`task\` tool with subagent_type="query" to search for existing related knowledge topics in the context tree. This helps avoid duplicates and understand the current context structure.
+
+2. **Curate Phase**: Based on the query results, use the \`task\` tool with subagent_type="curate" to create or update knowledge topics with the user's context.
+
+## Important Guidelines
+
+- Always query first to understand existing context before curating
+- Provide clear, detailed prompts when delegating to subagents
+- Summarize the results of each phase before proceeding to the next
+
+## Response Format
+
+IMPORTANT: Your final response must be a brief summary (1-2 sentences) of what was done. Do NOT include any file paths, directory paths, or specific location details in your response. The system will automatically display the created/updated file paths separately.`;
+            const response = await agent.execute(prompt, {
                 executionContext: {
+                    // Use 'plan' command type to get Plan Agent's tool set
                     commandType: 'curate',
                     fileReferenceInstructions: input.fileReferenceInstructions,
                 },
-                mode: 'autonomous',
             });
             // Mark completed
             storage.updateExecutionStatus(execution.id, 'completed', response);
             console.log(`[Consumer] Execution ${execution.id} completed`);
         }
         finally {
-            // Agent cleanup (if needed in future)
+            // Stop agent to cleanup resources
+            await agent.stop();
         }
     }
     /**

package/dist/infra/cipher/consumer/index.d.ts

@@ -1,7 +1,7 @@
 /**
  * Consumer Module - Public API for queue processing and UI monitoring
  *
- * Architecture:
+ * Architecture (legacy):
  * - ConsumerService: Singleton background worker (start once in main)
  * - QueuePollingService: UI subscribes here for real-time updates
  * - Both communicate via AgentStorage (SQLite DB)

package/dist/infra/cipher/consumer/index.js

@@ -1,7 +1,8 @@
+// TODO(v0.5.0): Remove this entire module. Replaced by CoreProcess + TaskProcessor + Transport events.
 /**
  * Consumer Module - Public API for queue processing and UI monitoring
  *
- * Architecture:
+ * Architecture (legacy):
  * - ConsumerService: Singleton background worker (start once in main)
  * - QueuePollingService: UI subscribes here for real-time updates
  * - Both communicate via AgentStorage (SQLite DB)

package/dist/infra/cipher/consumer/queue-polling-service.js

@@ -1,3 +1,4 @@
+// TODO(v0.5.0): Remove this file. QueuePollingService is replaced by Transport events.
 import { EventEmitter } from 'node:events';
 import { closeAgentStorage, getAgentStorage, getAgentStorageSync } from '../storage/agent-storage.js';
 // ==================== SERVICE ====================

package/dist/infra/cipher/file-system/binary-utils.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Checks if a file is binary based on extension and content analysis.
+ *
+ * Detection strategy:
+ * 1. Fast path: Check against known binary extensions
+ * 2. Check for null bytes (definitive binary indicator)
+ * 3. Heuristic: If >30% non-printable characters, consider binary
+ *
+ * @param filePath - Path to the file (used for extension check)
+ * @param buffer - Buffer containing first N bytes of the file
+ * @returns true if the file is binary, false otherwise
+ */
+export declare function isBinaryFile(filePath: string, buffer: Buffer): boolean;
+/**
+ * Checks if a file is an image based on its extension.
+ * SVG files are excluded as they are text-based.
+ *
+ * @param filePath - Path to the file
+ * @returns true if the file is an image (excluding SVG)
+ */
+export declare function isImageFile(filePath: string): boolean;
+/**
+ * Checks if a file is a PDF based on its extension.
+ *
+ * @param filePath - Path to the file
+ * @returns true if the file is a PDF
+ */
+export declare function isPdfFile(filePath: string): boolean;
+/**
+ * Gets the MIME type for an image or PDF file.
+ *
+ * @param filePath - Path to the file
+ * @returns MIME type string, or null if not a recognized image/PDF
+ */
+export declare function getMimeType(filePath: string): null | string;
+/**
+ * Checks if a file is a media file (image or PDF) that should be
+ * returned as a base64 attachment instead of text content.
+ *
+ * @param filePath - Path to the file
+ * @returns true if the file should be returned as an attachment
+ */
+export declare function isMediaFile(filePath: string): boolean;

package/dist/infra/cipher/file-system/binary-utils.js

@@ -0,0 +1,164 @@
+import path from 'node:path';
+/**
+ * Known binary file extensions for fast-path detection.
+ * These files are always treated as binary without content inspection.
+ * Sorted alphabetically as required by linter.
+ */
+const BINARY_EXTENSIONS = new Set([
+    '.7z',
+    '.a',
+    '.bin',
+    '.bz2',
+    '.class',
+    '.com',
+    '.dat',
+    '.db',
+    '.dll',
+    '.doc',
+    '.docx',
+    '.dylib',
+    '.exe',
+    '.gz',
+    '.jar',
+    '.lib',
+    '.o',
+    '.obj',
+    '.odp',
+    '.ods',
+    '.odt',
+    '.ppt',
+    '.pptx',
+    '.pyc',
+    '.pyo',
+    '.rar',
+    '.so',
+    '.sqlite',
+    '.sqlite3',
+    '.tar',
+    '.war',
+    '.wasm',
+    '.xls',
+    '.xlsx',
+    '.xz',
+    '.zip',
+]);
+/**
+ * Image file extensions that should be handled specially (base64 encoding).
+ * Sorted alphabetically as required by linter.
+ */
+const IMAGE_EXTENSIONS = new Set(['.bmp', '.gif', '.ico', '.jpeg', '.jpg', '.png', '.tif', '.tiff', '.webp']);
+/**
+ * PDF extension for special handling.
+ */
+const PDF_EXTENSION = '.pdf';
+/**
+ * SVG extension - treat as text, not image.
+ */
+const SVG_EXTENSION = '.svg';
+/**
+ * MIME type mappings for image and PDF files.
+ */
+const MIME_TYPES = {
+    '.bmp': 'image/bmp',
+    '.gif': 'image/gif',
+    '.ico': 'image/x-icon',
+    '.jpeg': 'image/jpeg',
+    '.jpg': 'image/jpeg',
+    '.pdf': 'application/pdf',
+    '.png': 'image/png',
+    '.tif': 'image/tiff',
+    '.tiff': 'image/tiff',
+    '.webp': 'image/webp',
+};
+/**
+ * Threshold for non-printable character ratio to consider a file binary.
+ * If more than 30% of sampled bytes are non-printable, the file is binary.
+ */
+const NON_PRINTABLE_THRESHOLD = 0.3;
+/**
+ * Checks if a file is binary based on extension and content analysis.
+ *
+ * Detection strategy:
+ * 1. Fast path: Check against known binary extensions
+ * 2. Check for null bytes (definitive binary indicator)
+ * 3. Heuristic: If >30% non-printable characters, consider binary
+ *
+ * @param filePath - Path to the file (used for extension check)
+ * @param buffer - Buffer containing first N bytes of the file
+ * @returns true if the file is binary, false otherwise
+ */
+export function isBinaryFile(filePath, buffer) {
+    const ext = path.extname(filePath).toLowerCase();
+    // Fast path: known binary extensions
+    if (BINARY_EXTENSIONS.has(ext)) {
+        return true;
+    }
+    // Skip content check for known text-based formats
+    if (isImageFile(filePath) || isPdfFile(filePath)) {
+        // Images and PDFs are binary but handled specially
+        return true;
+    }
+    // Empty files are not binary
+    if (buffer.length === 0) {
+        return false;
+    }
+    // Content-based detection
+    let nonPrintableCount = 0;
+    for (const byte of buffer) {
+        // Null byte is a definitive binary indicator
+        if (byte === 0) {
+            return true;
+        }
+        // Count non-printable characters
+        // Printable range: tab (9), newline (10), carriage return (13), space (32) to tilde (126)
+        if (byte < 9 || (byte > 13 && byte < 32) || byte > 126) {
+            nonPrintableCount++;
+        }
+    }
+    // If more than 30% non-printable, consider binary
+    return nonPrintableCount / buffer.length > NON_PRINTABLE_THRESHOLD;
+}
+/**
+ * Checks if a file is an image based on its extension.
+ * SVG files are excluded as they are text-based.
+ *
+ * @param filePath - Path to the file
+ * @returns true if the file is an image (excluding SVG)
+ */
+export function isImageFile(filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+    // SVG is text-based, not a binary image
+    if (ext === SVG_EXTENSION) {
+        return false;
+    }
+    return IMAGE_EXTENSIONS.has(ext);
+}
+/**
+ * Checks if a file is a PDF based on its extension.
+ *
+ * @param filePath - Path to the file
+ * @returns true if the file is a PDF
+ */
+export function isPdfFile(filePath) {
+    return path.extname(filePath).toLowerCase() === PDF_EXTENSION;
+}
+/**
+ * Gets the MIME type for an image or PDF file.
+ *
+ * @param filePath - Path to the file
+ * @returns MIME type string, or null if not a recognized image/PDF
+ */
+export function getMimeType(filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+    return MIME_TYPES[ext] ?? null;
+}
+/**
+ * Checks if a file is a media file (image or PDF) that should be
+ * returned as a base64 attachment instead of text content.
+ *
+ * @param filePath - Path to the file
+ * @returns true if the file should be returned as an attachment
+ */
+export function isMediaFile(filePath) {
+    return isImageFile(filePath) || isPdfFile(filePath);
+}

package/dist/infra/cipher/file-system/context-tree-file-system-factory.d.ts

@@ -0,0 +1,9 @@
+import { FileSystemService } from './file-system-service.js';
+/**
+ * Creates a FileSystemService restricted to the context tree directory.
+ * All file operations will be confined to .brv/context-tree/.
+ *
+ * @param baseWorkingDirectory - The project root directory
+ * @returns FileSystemService instance restricted to context-tree
+ */
+export declare function createContextTreeFileSystem(baseWorkingDirectory: string): FileSystemService;

package/dist/infra/cipher/file-system/context-tree-file-system-factory.js

@@ -0,0 +1,24 @@
+import path from 'node:path';
+import { FileSystemService } from './file-system-service.js';
+/**
+ * Creates a FileSystemService restricted to the context tree directory.
+ * All file operations will be confined to .brv/context-tree/.
+ *
+ * @param baseWorkingDirectory - The project root directory
+ * @returns FileSystemService instance restricted to context-tree
+ */
+export function createContextTreeFileSystem(baseWorkingDirectory) {
+    const contextTreePath = path.join(baseWorkingDirectory, '.brv', 'context-tree');
+    return new FileSystemService({
+        // Only allow paths within context tree (relative to working directory)
+        allowedPaths: ['.'],
+        // Use default blocked extensions
+        blockedExtensions: ['.exe', '.dll', '.so', '.dylib'],
+        // Block any attempt to escape via parent directory traversal
+        blockedPaths: ['..', '../'],
+        // Reasonable file size limit
+        maxFileSize: 10 * 1024 * 1024, // 10MB
+        // Restrict working directory to context tree
+        workingDirectory: contextTreePath,
+    });
+}

package/dist/infra/cipher/file-system/file-system-service.d.ts

@@ -1,4 +1,4 @@
-import type { EditFileOptions, EditOperation, EditResult, FileContent, FileSystemConfig, GlobOptions, GlobResult, ReadFileOptions, SearchOptions, SearchResult, WriteFileOptions, WriteResult } from '../../../core/domain/cipher/file-system/types.js';
+import type { EditFileOptions, EditOperation, EditResult, FileContent, FileSystemConfig, GlobOptions, GlobResult, ListDirectoryOptions, ListDirectoryResult, ReadFileOptions, SearchOptions, SearchResult, WriteFileOptions, WriteResult } from '../../../core/domain/cipher/file-system/types.js';
 import type { IFileSystem } from '../../../core/interfaces/cipher/i-file-system.js';
 /**
  * File system service implementation.
@@ -32,8 +32,20 @@ export declare class FileSystemService implements IFileSystem {
      * Initialize the file system service.
      */
     initialize(): Promise<void>;
+    /**
+     * List files and directories in a path.
+     */
+    listDirectory(dirPath: string, options?: ListDirectoryOptions): Promise<ListDirectoryResult>;
     /**
      * Read the contents of a file.
+     *
+     * Features:
+     * - Relative path support (resolved against working directory)
+     * - Image/PDF files returned as base64 attachments
+     * - Binary file detection and rejection
+     * - .env file blocking with whitelist for example files
+     * - XML-wrapped output for clearer LLM parsing
+     * - Preview metadata (first 20 lines)
      */
     readFile(filePath: string, options?: ReadFileOptions): Promise<FileContent>;
     /**
@@ -81,6 +93,10 @@ export declare class FileSystemService implements IFileSystem {
      * Parses output from grep-like commands (filepath:lineNumber:content format).
      */
     private parseGrepOutput;
+    /**
+     * Renders a directory tree as a string.
+     */
+    private renderDirectoryTree;
     /**
      * JavaScript-based content search implementation.
      * Used as fallback when native grep commands are unavailable or when context lines are needed.