byterover-cli 1.7.2 → 1.8.0

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

@@ -47,7 +47,12 @@ export class CurateUseCase {
             }
             return;
         }
-        const resolvedContent = context?.trim() ? context : '';
+        // Provide default context for folder packing when none is provided
+        const resolvedContent = context?.trim()
+            ? context
+            : hasFolders
+                ? 'Analyze this folder and extract all relevant knowledge, patterns, and documentation.'
+                : '';
         let client;
         try {
             client = await this.createClient({ headless, verbose });

package/dist/server/infra/usecase/query-use-case.js

@@ -371,6 +371,16 @@ export class QueryUseCase {
                     if (payload.taskId === taskId && !completed) {
                         completed = true;
                         cleanup();
+                        // Fallback: use payload.result when llmservice:response wasn't received
+                        // (e.g., Tier 2 direct search responses that bypass the LLM)
+                        if (!resultPrinted && payload.result) {
+                            finalResult = payload.result;
+                            resultPrinted = true;
+                            if (format === 'text') {
+                                this.terminal.log('\nResult:');
+                                this.terminal.log(payload.result);
+                            }
+                        }
                         if (format === 'json') {
                             this.outputJsonResult({
                                 result: finalResult,

package/dist/server/utils/file-validator.js

@@ -1,7 +1,74 @@
 import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
-import { isBinaryFile, isImageFile, isPdfFile } from '../../agent/infra/file-system/binary-utils.js';
+import { isBinaryFile, isImageFile, isOfficeFile, isPdfFile } from '../../agent/infra/file-system/binary-utils.js';
+/**
+ * Known text file extensions that should always be treated as text,
+ * bypassing binary content inspection. This prevents false positives
+ * from files with unusual encodings (e.g., UTF-16) or embedded
+ * special characters (e.g., box-drawing characters in .md files).
+ */
+const KNOWN_TEXT_EXTENSIONS = new Set([
+    '.adoc',
+    '.c',
+    '.cfg',
+    '.clj',
+    '.cmake',
+    '.conf',
+    '.cpp',
+    '.cs',
+    '.css',
+    '.csv',
+    '.dart',
+    '.dockerfile',
+    '.env',
+    '.erl',
+    '.ex',
+    '.go',
+    '.graphql',
+    '.groovy',
+    '.h',
+    '.hpp',
+    '.html',
+    '.ini',
+    '.java',
+    '.js',
+    '.json',
+    '.jsonc',
+    '.jsx',
+    '.kt',
+    '.less',
+    '.lua',
+    '.makefile',
+    '.markdown',
+    '.md',
+    '.php',
+    '.pl',
+    '.proto',
+    '.py',
+    '.r',
+    '.rb',
+    '.rs',
+    '.rst',
+    '.sass',
+    '.scala',
+    '.scss',
+    '.sh',
+    '.sql',
+    '.svelte',
+    '.svg',
+    '.swift',
+    '.tf',
+    '.toml',
+    '.ts',
+    '.tsx',
+    '.txt',
+    '.vue',
+    '.xml',
+    '.yaml',
+    '.yml',
+    '.zsh',
+]);
 /**
  * Normalize file path - handles relative, absolute, tilde, symlinks
  * Returns absolute canonical path
@@ -65,6 +132,12 @@ export function validateFileForCurate(filePath, projectRoot) {
         return { error: `Cannot read file: ${filePath}`, valid: false };
     }
     const sampleBuffer = buffer.subarray(0, bytesRead);
+    const ext = path.extname(normalized).toLowerCase();
+    // Fast path: known text extensions bypass binary content inspection.
+    // This prevents false positives from files with unusual encodings (e.g., UTF-16 .md files)
+    if (KNOWN_TEXT_EXTENSIONS.has(ext)) {
+        return { normalizedPath: normalized, valid: true };
+    }
     // Check file type using binary-utils (same logic as read_file tool)
     // Allow image files - read_file returns them as base64 attachments
     if (isImageFile(normalized)) {
@@ -75,6 +148,10 @@ export function validateFileForCurate(filePath, projectRoot) {
     if (isPdfFile(normalized, sampleBuffer)) {
         return { normalizedPath: normalized, valid: true };
     }
+    // Allow Office documents - FileContentReader can parse these for text extraction
+    if (isOfficeFile(normalized)) {
+        return { normalizedPath: normalized, valid: true };
+    }
     // Check if it's a binary file (using same logic as read_file tool)
     if (isBinaryFile(normalized, sampleBuffer)) {
         return { error: `File type not supported: ${filePath}`, valid: false };

package/dist/tui/hooks/use-slash-completion.js

@@ -9,6 +9,20 @@ import { useCommands } from '../contexts/commands-context.js';
 function generateFileSuggestions(searchPattern) {
     try {
         const cwd = process.cwd();
+        const suggestions = [];
+        // Special case: Always suggest ./ as the first option when appropriate
+        // This allows users to curate the entire current directory
+        const normalizedPattern = searchPattern.toLowerCase();
+        const shouldShowCurrentDir = !searchPattern || // Just typed @
+            normalizedPattern === '.' || // Typing @.
+            './'.startsWith(normalizedPattern); // Typing @. (partial match)
+        if (shouldShowCurrentDir) {
+            suggestions.push({
+                description: 'Current directory (will pack all contents)',
+                label: './',
+                value: '@./',
+            });
+        }
         // If pattern ends with /, list contents of that directory
         let searchDir;
         let searchPrefix;
@@ -23,10 +37,9 @@ function generateFileSuggestions(searchPattern) {
         const fullSearchDir = path.resolve(cwd, searchDir);
         // Check if search directory exists and is within cwd
         if (!fs.existsSync(fullSearchDir) || !fullSearchDir.startsWith(cwd)) {
-            return [];
+            return suggestions;
         }
         const entries = fs.readdirSync(fullSearchDir, { withFileTypes: true });
-        const suggestions = [];
         for (const entry of entries) {
             // Skip hidden files
             if (entry.name.startsWith('.'))
@@ -43,14 +56,22 @@ function generateFileSuggestions(searchPattern) {
             }
         }
         // Sort: directories first, then alphabetically
-        suggestions.sort((a, b) => {
+        // Note: ./ is already at the front, so we sort from index 1
+        const hasCurrentDir = suggestions[0]?.label === './';
+        const startIndex = hasCurrentDir ? 1 : 0;
+        const toSort = suggestions.slice(startIndex);
+        toSort.sort((a, b) => {
             const aIsDir = a.label.endsWith('/');
             const bIsDir = b.label.endsWith('/');
             if (aIsDir !== bIsDir)
                 return aIsDir ? -1 : 1;
             return a.label.localeCompare(b.label);
         });
-        return suggestions.slice(0, 20); // Limit to 20 suggestions
+        // Recombine: ./ stays at front, rest are sorted
+        const finalSuggestions = hasCurrentDir
+            ? [suggestions[0], ...toSort]
+            : toSort;
+        return finalSuggestions.slice(0, 20); // Limit to 20 suggestions
     }
     catch {
         return [];

package/oclif.manifest.json

@@ -499,5 +499,5 @@
       ]
     }
   },
-  "version": "1.7.2"
+  "version": "1.8.0"
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "byterover-cli",
   "description": "ByteRover's CLI",
-  "version": "1.7.2",
+  "version": "1.8.0",
   "author": "ByteRover",
   "bin": {
     "brv": "./bin/run.js"

package/dist/agent/infra/tools/implementations/bash-exec-tool.d.ts

@@ -1,13 +0,0 @@
-import type { Tool } from '../../../core/domain/tools/types.js';
-import type { IProcessService } from '../../../core/interfaces/i-process-service.js';
-/**
- * Create bash_exec tool.
- *
- * Executes shell commands with security validation and approval for dangerous commands.
- * Supports both foreground (wait for completion) and background (return immediately) execution.
- * When a metadata callback is provided, streams output updates in real-time.
- *
- * @param processService - Process service for command execution
- * @returns bash_exec tool instance
- */
-export declare function createBashExecTool(processService: IProcessService): Tool;

package/dist/agent/infra/tools/implementations/bash-exec-tool.js

@@ -1,110 +0,0 @@
-import { z } from 'zod';
-import { ToolName } from '../../../core/domain/tools/constants.js';
-/**
- * Input schema for bash_exec tool.
- */
-const BashExecInputSchema = z
-    .object({
-    /**
-     * Shell command to execute.
-     */
-    command: z.string().describe('Shell command to execute'),
-    /**
-     * Working directory for command execution (relative to configured base directory).
-     */
-    cwd: z.string().optional().describe('Working directory for command execution'),
-    /**
-     * Human-readable description of what the command does (5-10 words).
-     */
-    description: z.string().optional().describe('Description of what the command does (5-10 words)'),
-    /**
-     * Execute command in background (returns immediately with process handle).
-     */
-    runInBackground: z
-        .boolean()
-        .optional()
-        .default(false)
-        .describe('Execute command in background'),
-    /**
-     * Timeout in milliseconds (max: 600000, default: 300000 = 5 minutes).
-     */
-    timeout: z
-        .number()
-        .int()
-        .positive()
-        .max(600_000)
-        .optional()
-        .default(300_000)
-        .describe('Timeout in milliseconds (default: 5 minutes)'),
-})
-    .strict();
-/**
- * Create bash_exec tool.
- *
- * Executes shell commands with security validation and approval for dangerous commands.
- * Supports both foreground (wait for completion) and background (return immediately) execution.
- * When a metadata callback is provided, streams output updates in real-time.
- *
- * @param processService - Process service for command execution
- * @returns bash_exec tool instance
- */
-export function createBashExecTool(processService) {
-    return {
-        description: `Execute a shell command and return its output.`,
-        async execute(input, context) {
-            const { command, cwd, description, runInBackground, timeout } = input;
-            // Stream initial status via metadata callback if available
-            if (context?.metadata) {
-                context.metadata({
-                    description: description ?? `Executing: ${command.slice(0, 50)}${command.length > 50 ? '...' : ''}`,
-                    output: '',
-                    progress: 0,
-                });
-            }
-            // Execute command via process service
-            const result = await processService.executeCommand(command, {
-                cwd,
-                description,
-                runInBackground,
-                timeout,
-            });
-            // Return based on execution mode
-            if ('stdout' in result) {
-                // Stream final output via metadata callback if available
-                if (context?.metadata) {
-                    context.metadata({
-                        description: description ?? 'Command completed',
-                        output: result.stdout + (result.stderr ? `\n[stderr]\n${result.stderr}` : ''),
-                        progress: 100,
-                    });
-                }
-                // Foreground execution result
-                return {
-                    duration: result.duration,
-                    exitCode: result.exitCode,
-                    stderr: result.stderr,
-                    stdout: result.stdout,
-                };
-            }
-            // Stream background process info via metadata callback if available
-            if (context?.metadata) {
-                context.metadata({
-                    description: `Background process started: ${result.processId}`,
-                    output: `Process started with PID ${result.pid}`,
-                    progress: 100,
-                });
-            }
-            // Background execution handle
-            return {
-                command: result.command,
-                description: result.description,
-                message: `Process started in background. Use bash_output with processId="${result.processId}" to retrieve output.`,
-                pid: result.pid,
-                processId: result.processId,
-                startedAt: result.startedAt.toISOString(),
-            };
-        },
-        id: ToolName.BASH_EXEC,
-        inputSchema: BashExecInputSchema,
-    };
-}

package/dist/agent/infra/tools/implementations/bash-output-tool.d.ts

@@ -1,12 +0,0 @@
-import type { Tool } from '../../../core/domain/tools/types.js';
-import type { IProcessService } from '../../../core/interfaces/i-process-service.js';
-/**
- * Create bash_output tool.
- *
- * Retrieves output from a background process started by bash_exec.
- * Reading output clears the buffer (destructive read), so output is only returned once.
- *
- * @param processService - Process service for retrieving output
- * @returns bash_output tool instance
- */
-export declare function createBashOutputTool(processService: IProcessService): Tool;

package/dist/agent/infra/tools/implementations/bash-output-tool.js

@@ -1,43 +0,0 @@
-import { z } from 'zod';
-import { ToolName } from '../../../core/domain/tools/constants.js';
-/**
- * Input schema for bash_output tool.
- */
-const BashOutputInputSchema = z
-    .object({
-    /**
-     * Unique process identifier from bash_exec.
-     */
-    processId: z.string().describe('Unique process identifier from bash_exec'),
-})
-    .strict();
-/**
- * Create bash_output tool.
- *
- * Retrieves output from a background process started by bash_exec.
- * Reading output clears the buffer (destructive read), so output is only returned once.
- *
- * @param processService - Process service for retrieving output
- * @returns bash_output tool instance
- */
-export function createBashOutputTool(processService) {
-    return {
-        description: `Retrieve output from a background process started by bash_exec.`,
-        async execute(input, _context) {
-            const { processId } = input;
-            // Get output from process service
-            const output = await processService.getProcessOutput(processId);
-            // Return output with status
-            return {
-                duration: output.duration,
-                exitCode: output.exitCode,
-                processId,
-                status: output.status,
-                stderr: output.stderr,
-                stdout: output.stdout,
-            };
-        },
-        id: ToolName.BASH_OUTPUT,
-        inputSchema: BashOutputInputSchema,
-    };
-}

package/dist/agent/infra/tools/implementations/batch-tool.d.ts

@@ -1,12 +0,0 @@
-import type { Tool } from '../../../core/domain/tools/types.js';
-import type { ToolProviderGetter } from '../tool-provider-getter.js';
-/**
- * Create batch tool.
- *
- * Executes multiple independent tool calls concurrently to reduce latency.
- * Best used for gathering context (reads, searches, listings).
- *
- * @param getToolProvider - Lazy getter for tool provider (avoids circular dependency)
- * @returns batch tool instance
- */
-export declare function createBatchTool(getToolProvider: ToolProviderGetter): Tool;

package/dist/agent/infra/tools/implementations/batch-tool.js

@@ -1,142 +0,0 @@
-import { z } from 'zod';
-import { ToolName } from '../../../core/domain/tools/constants.js';
-/**
- * Tools that are not allowed in batch execution.
- * - batch: No nesting of batch calls
- * - edit_file: Sequential edits for proper conflict handling
- * - write_todos: Lightweight, call directly
- */
-const DISALLOWED_TOOLS = new Set(['batch', 'edit_file', 'write_todos']);
-/**
- * Maximum number of tool calls allowed in a single batch.
- */
-const MAX_BATCH_SIZE = 10;
-/**
- * Input schema for batch tool.
- */
-const BatchInputSchema = z
-    .object({
-    /**
-     * Array of tool calls to execute in parallel.
-     */
-    toolCalls: z
-        .array(z.object({
-        /**
-         * Parameters for the tool.
-         */
-        parameters: z.record(z.unknown()).describe('Parameters for the tool'),
-        /**
-         * The name of the tool to execute.
-         */
-        tool: z.string().describe('The name of the tool to execute'),
-    }))
-        .min(1, 'Provide at least one tool call')
-        .describe('Array of tool calls to execute in parallel'),
-})
-    .strict();
-/**
- * Create batch tool.
- *
- * Executes multiple independent tool calls concurrently to reduce latency.
- * Best used for gathering context (reads, searches, listings).
- *
- * @param getToolProvider - Lazy getter for tool provider (avoids circular dependency)
- * @returns batch tool instance
- */
-export function createBatchTool(getToolProvider) {
-    return {
-        description: 'Execute multiple independent tool calls concurrently.',
-        async execute(input, context) {
-            const { toolCalls } = input;
-            const toolProvider = getToolProvider();
-            // Limit to MAX_BATCH_SIZE
-            const activeCalls = toolCalls.slice(0, MAX_BATCH_SIZE);
-            const discardedCalls = toolCalls.slice(MAX_BATCH_SIZE);
-            /**
-             * Execute a single tool call and return the result.
-             */
-            const executeCall = async (call) => {
-                const startTime = Date.now();
-                // Check if tool is disallowed in batch
-                if (DISALLOWED_TOOLS.has(call.tool)) {
-                    return {
-                        durationMs: Date.now() - startTime,
-                        error: `Tool '${call.tool}' is not allowed in batch. Disallowed tools: ${[...DISALLOWED_TOOLS].join(', ')}`,
-                        success: false,
-                        tool: call.tool,
-                    };
-                }
-                // Check if tool exists
-                if (!toolProvider.hasTool(call.tool)) {
-                    const availableTools = toolProvider.getToolNames().filter((name) => !DISALLOWED_TOOLS.has(name));
-                    return {
-                        durationMs: Date.now() - startTime,
-                        error: `Tool '${call.tool}' not found. Available tools: ${availableTools.join(', ')}`,
-                        success: false,
-                        tool: call.tool,
-                    };
-                }
-                try {
-                    const result = await toolProvider.executeTool(call.tool, call.parameters, context?.sessionId, context);
-                    return {
-                        durationMs: Date.now() - startTime,
-                        result,
-                        success: true,
-                        tool: call.tool,
-                    };
-                }
-                catch (error) {
-                    return {
-                        durationMs: Date.now() - startTime,
-                        error: error instanceof Error ? error.message : String(error),
-                        success: false,
-                        tool: call.tool,
-                    };
-                }
-            };
-            // Execute all calls in parallel
-            const results = await Promise.all(activeCalls.map((call) => executeCall(call)));
-            // Add discarded calls as errors
-            for (const call of discardedCalls) {
-                results.push({
-                    durationMs: 0,
-                    error: `Maximum of ${MAX_BATCH_SIZE} tools allowed in batch`,
-                    success: false,
-                    tool: call.tool,
-                });
-            }
-            const successful = results.filter((r) => r.success).length;
-            const failed = results.length - successful;
-            // Stream progress update
-            if (context?.metadata) {
-                context.metadata({
-                    description: 'Batch execution complete',
-                    output: `${successful}/${results.length} tools executed successfully`,
-                    progress: 100,
-                });
-            }
-            // Build output message
-            const outputMessage = failed > 0
-                ? `Executed ${successful}/${results.length} tools successfully. ${failed} failed.`
-                : `All ${successful} tools executed successfully.\n\nKeep using the batch tool for optimal performance!`;
-            return {
-                metadata: {
-                    details: results.map((r) => ({ success: r.success, tool: r.tool })),
-                    failed,
-                    successful,
-                    tools: toolCalls.map((c) => c.tool),
-                    totalCalls: results.length,
-                },
-                results: results.map((r) => ({
-                    durationMs: r.durationMs,
-                    success: r.success,
-                    tool: r.tool,
-                    ...(r.success ? { result: r.result } : { error: r.error }),
-                })),
-                summary: outputMessage,
-            };
-        },
-        id: ToolName.BATCH,
-        inputSchema: BatchInputSchema,
-    };
-}

package/dist/agent/infra/tools/implementations/create-knowledge-topic-tool.d.ts

@@ -1,11 +0,0 @@
-import type { Tool } from '../../../core/domain/tools/types.js';
-/**
- * Creates the create knowledge topic tool.
- *
- * Creates organized knowledge topics within domain folders, where each topic and subtopic
- * has its own folder containing a context.md file with relevant snippets. This tool should
- * be used after detecting domains to organize the extracted knowledge into a structured hierarchy.
- *
- * @returns Configured create knowledge topic tool
- */
-export declare function createCreateKnowledgeTopicTool(): Tool;