byterover-cli 1.7.2 → 2.0.0

package/dist/agent/infra/storage/message-storage-service.js

@@ -88,23 +88,23 @@ export class MessageStorageService {
         if (!session) {
             return false;
         }
-        // Delete all messages and their parts
+        const ops = [];
+        // Collect all message keys and their part keys
         const messageKeys = await this.keyStorage.list(this.messagePrefix(sessionId));
         for (const messageKey of messageKeys) {
             const messageId = messageKey[2];
-            // Delete all parts for this message
             // eslint-disable-next-line no-await-in-loop
             const partKeys = await this.keyStorage.list(this.partPrefix(messageId));
             for (const partKey of partKeys) {
-                // eslint-disable-next-line no-await-in-loop
-                await this.keyStorage.delete(partKey);
+                ops.push({ key: partKey, type: 'delete' });
             }
-            // Delete the message
-            // eslint-disable-next-line no-await-in-loop
-            await this.keyStorage.delete(messageKey);
+            ops.push({ key: messageKey, type: 'delete' });
         }
         // Delete the session record
-        return this.keyStorage.delete(this.sessionKey(sessionId));
+        ops.push({ key: this.sessionKey(sessionId), type: 'delete' });
+        // Atomic delete of everything
+        await this.keyStorage.batch(ops);
+        return true;
     }
     /**
      * Get the session record, if it exists.
@@ -196,29 +196,53 @@ export class MessageStorageService {
             return { hitCompactionBoundary: false, messages: [] };
         }
         const stopAtCompaction = options?.stopAtCompaction ?? true;
-        const messages = [];
+        // Bulk-load all messages for this session in one query
+        const allMessageEntries = await this.keyStorage.listWithValues(this.messagePrefix(sessionId));
+        const messageMap = new Map();
+        for (const entry of allMessageEntries) {
+            messageMap.set(entry.value.id, entry.value);
+        }
+        // Traverse linked list in-memory from newest to oldest
+        const orderedMessages = [];
         let hitCompactionBoundary = false;
-        // Traverse from newest to oldest
         let currentMessageId = session.newestMessageId;
         while (currentMessageId) {
-            // eslint-disable-next-line no-await-in-loop
-            const storedMsg = await this.keyStorage.get(this.messageKey(sessionId, currentMessageId));
+            const storedMsg = messageMap.get(currentMessageId);
             if (!storedMsg)
                 break;
-            // Load parts for this message
-            // eslint-disable-next-line no-await-in-loop
-            const parts = await this.loadParts(storedMsg);
-            const messageWithParts = { ...storedMsg, parts };
             // Check for compaction boundary
             if (stopAtCompaction && storedMsg.compactionBoundary) {
-                // Include the compaction boundary message itself
-                messages.unshift(messageWithParts);
+                orderedMessages.unshift(storedMsg);
                 hitCompactionBoundary = true;
                 break;
             }
-            messages.unshift(messageWithParts);
+            orderedMessages.unshift(storedMsg);
             currentMessageId = storedMsg.prevMessageId;
         }
+        // Bulk-load parts per message (one query per message instead of one per part)
+        const messages = [];
+        for (const msg of orderedMessages) {
+            if (msg.partIds.length === 0) {
+                messages.push({ ...msg, parts: [] });
+                continue;
+            }
+            // One query for all parts of this message
+            // eslint-disable-next-line no-await-in-loop
+            const partEntries = await this.keyStorage.listWithValues(this.partPrefix(msg.id));
+            const partMap = new Map();
+            for (const entry of partEntries) {
+                partMap.set(entry.value.id, entry.value);
+            }
+            // Maintain order from partIds
+            const parts = [];
+            for (const partId of msg.partIds) {
+                const part = partMap.get(partId);
+                if (part) {
+                    parts.push(part);
+                }
+            }
+            messages.push({ ...msg, parts });
+        }
         return { hitCompactionBoundary, messages };
     }
     /**
@@ -371,12 +395,100 @@ export class MessageStorageService {
      * More efficient than calling saveMessage multiple times.
      */
     async saveMessages(sessionId, messages) {
+        if (messages.length === 0)
+            return [];
+        // For single messages, delegate to saveMessage (avoids double-read overhead)
+        if (messages.length === 1) {
+            return [await this.saveMessage(sessionId, messages[0])];
+        }
+        const now = Date.now();
+        const ops = [];
         const results = [];
+        // Get or create session (1 read)
+        let session = await this.getSession(sessionId);
+        if (!session) {
+            session = {
+                createdAt: now,
+                messageCount: 0,
+                sessionId,
+                updatedAt: now,
+            };
+        }
+        // Read previous newest message to update its nextMessageId (1 read)
+        const originalPrevId = session.newestMessageId;
+        if (originalPrevId) {
+            const prevMsg = await this.keyStorage.get(this.messageKey(sessionId, originalPrevId));
+            if (prevMsg) {
+                ops.push({
+                    key: this.messageKey(sessionId, originalPrevId),
+                    type: 'set',
+                    value: { ...prevMsg, nextMessageId: undefined, updatedAt: now },
+                });
+            }
+        }
+        // Build all stored messages and parts in memory
+        let prevId = originalPrevId;
         for (const message of messages) {
-            // eslint-disable-next-line no-await-in-loop
-            const stored = await this.saveMessage(sessionId, message);
-            results.push(stored);
+            const messageId = randomUUID();
+            const { content, parts } = this.extractParts(message, messageId, now);
+            const storedMessage = {
+                content,
+                createdAt: now,
+                id: messageId,
+                name: message.name,
+                partIds: parts.map((p) => p.id),
+                prevMessageId: prevId,
+                reasoning: message.reasoning,
+                role: message.role,
+                sessionId,
+                thought: message.thought,
+                thoughtSummary: message.thoughtSummary,
+                toolCallId: message.toolCallId,
+                toolCalls: message.toolCalls,
+                updatedAt: now,
+            };
+            // Add part ops
+            for (const part of parts) {
+                ops.push({
+                    key: this.partKey(messageId, part.id),
+                    type: 'set',
+                    value: part,
+                });
+            }
+            results.push(storedMessage);
+            prevId = messageId;
+        }
+        // Chain messages: set nextMessageId pointers between consecutive messages
+        for (let i = 0; i < results.length - 1; i++) {
+            results[i].nextMessageId = results[i + 1].id;
+        }
+        // Patch the previous newest message to point to the first new message
+        if (originalPrevId && ops.length > 0 && ops[0].type === 'set') {
+            ;
+            ops[0].value.nextMessageId = results[0].id;
+        }
+        // Add all message ops
+        for (const storedMessage of results) {
+            ops.push({
+                key: this.messageKey(sessionId, storedMessage.id),
+                type: 'set',
+                value: storedMessage,
+            });
+        }
+        // Update session record
+        session.newestMessageId = results.at(-1).id;
+        if (!session.oldestMessageId) {
+            session.oldestMessageId = results[0].id;
         }
+        session.messageCount += messages.length;
+        session.updatedAt = now;
+        ops.push({
+            key: this.sessionKey(sessionId),
+            type: 'set',
+            value: session,
+        });
+        // Execute all ops atomically (1 batch)
+        await this.keyStorage.batch(ops);
         return results;
     }
     /**

package/dist/agent/infra/storage/sqlite-key-storage.d.ts

@@ -76,6 +76,14 @@ export declare class SqliteKeyStorage implements IKeyStorage {
      * List all keys matching a prefix.
      */
     list(prefix: StorageKey): Promise<StorageKey[]>;
+    /**
+     * List all key-value pairs matching a prefix.
+     * More efficient than list() followed by individual get() calls.
+     */
+    listWithValues<T>(prefix: StorageKey): Promise<Array<{
+        key: StorageKey;
+        value: T;
+    }>>;
     /**
      * Set a value at a composite key.
      */

package/dist/agent/infra/storage/sqlite-key-storage.js

@@ -82,7 +82,10 @@ export class SqliteKeyStorage {
     storageDir;
     constructor(config) {
         this.inMemory = config?.inMemory ?? false;
-        this.storageDir = config?.storageDir ?? join(process.cwd(), '.brv', 'blobs');
+        this.storageDir = config?.storageDir ?? '';
+        if (!this.inMemory && !this.storageDir) {
+            throw new Error('SqliteKeyStorage: storageDir is required when inMemory is false');
+        }
         this.dbPath = this.inMemory ? ':memory:' : join(this.storageDir, config?.dbPath ?? 'context.db');
     }
     /**
@@ -287,17 +290,48 @@ export class SqliteKeyStorage {
             __disposeResources(env_5);
         }
     }
+    /**
+     * List all key-value pairs matching a prefix.
+     * More efficient than list() followed by individual get() calls.
+     */
+    async listWithValues(prefix) {
+        const env_6 = { stack: [], error: void 0, hasError: false };
+        try {
+            this.ensureInitialized();
+            const prefixPath = this.serializeKey(prefix);
+            const lockKey = lockKeyFromStorageKey(prefix);
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            const _lock = __addDisposableResource(env_6, await RWLock.read(lockKey), false);
+            try {
+                const rows = this.db.prepare('SELECT key_path, value FROM key_store WHERE key_path LIKE ? ORDER BY key_path').all(`${prefixPath}%`);
+                return rows.map((row) => ({
+                    key: this.deserializeKey(row.key_path),
+                    value: JSON.parse(row.value.toString('utf8')),
+                }));
+            }
+            catch (error) {
+                throw new Error(`Failed to list keys with values for prefix ${prefixPath}: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+        catch (e_6) {
+            env_6.error = e_6;
+            env_6.hasError = true;
+        }
+        finally {
+            __disposeResources(env_6);
+        }
+    }
     /**
      * Set a value at a composite key.
      */
     async set(key, value) {
-        const env_6 = { stack: [], error: void 0, hasError: false };
+        const env_7 = { stack: [], error: void 0, hasError: false };
         try {
             this.ensureInitialized();
             const keyPath = this.serializeKey(key);
             const lockKey = lockKeyFromStorageKey(key);
             // eslint-disable-next-line @typescript-eslint/no-unused-vars
-            const _lock = __addDisposableResource(env_6, await RWLock.write(lockKey), false);
+            const _lock = __addDisposableResource(env_7, await RWLock.write(lockKey), false);
             const now = Date.now();
             const valueJson = JSON.stringify(value);
             try {
@@ -315,25 +349,25 @@ export class SqliteKeyStorage {
                 throw new Error(`Failed to set key ${keyPath}: ${error instanceof Error ? error.message : String(error)}`);
             }
         }
-        catch (e_6) {
-            env_6.error = e_6;
-            env_6.hasError = true;
+        catch (e_7) {
+            env_7.error = e_7;
+            env_7.hasError = true;
         }
         finally {
-            __disposeResources(env_6);
+            __disposeResources(env_7);
         }
     }
     /**
      * Atomic update with optimistic locking.
      */
     async update(key, updater) {
-        const env_7 = { stack: [], error: void 0, hasError: false };
+        const env_8 = { stack: [], error: void 0, hasError: false };
         try {
             this.ensureInitialized();
             const keyPath = this.serializeKey(key);
             const lockKey = lockKeyFromStorageKey(key);
             // eslint-disable-next-line @typescript-eslint/no-unused-vars
-            const _lock = __addDisposableResource(env_7, await RWLock.write(lockKey), false);
+            const _lock = __addDisposableResource(env_8, await RWLock.write(lockKey), false);
             try {
                 // Read current value
                 const row = this.db.prepare('SELECT value, created_at FROM key_store WHERE key_path = ?').get(keyPath);
@@ -356,12 +390,12 @@ export class SqliteKeyStorage {
                 throw new Error(`Failed to update key ${keyPath}: ${error instanceof Error ? error.message : String(error)}`);
             }
         }
-        catch (e_7) {
-            env_7.error = e_7;
-            env_7.hasError = true;
+        catch (e_8) {
+            env_8.error = e_8;
+            env_8.hasError = true;
         }
         finally {
-            __disposeResources(env_7);
+            __disposeResources(env_8);
         }
     }
     /**

package/dist/agent/infra/system-prompt/contributors/context-tree-structure-contributor.js

@@ -92,7 +92,7 @@ export class ContextTreeStructureContributor {
         if (truncatedCount.value > 0) {
             parts.push('', `[${truncatedCount.value} additional entries not shown]`);
         }
-        parts.push('', '## Structure Guide', '- Each top-level folder is a **domain** (dynamically created based on content)', '- Inside domains are **topics** as `.md` files or subfolders with `context.md`', '- `context.md` files contain the curated knowledge content', '', '## Dynamic Domains', '- Domains are created dynamically based on the semantics of curated content', '- Domain names should be descriptive, use snake_case (e.g., `authentication`, `api_design`)', '- Before creating a new domain, check if existing domains could accommodate the content', '', '## Usage', '- **Query commands**: Search ONLY within this context tree structure', '- **Curate commands**: Check existing domains/topics before creating new ones', '</context-tree-structure>');
+        parts.push('', '## Structure Guide', '- Each top-level folder is a **domain** (dynamically created based on content)', '- Inside domains are **topics** as `.md` files or subfolders with `context.md`', '- `context.md` files contain the curated knowledge content', '', '## Dynamic Domains', '- Domains are created dynamically based on the semantics of curated content', '- Domain names should be descriptive, use snake_case (e.g., `architecture`, `market_trends`, `risk_analysis`)', '- Before creating a new domain, check if existing domains could accommodate the content', '', '## Usage', '- **Query commands**: Search ONLY within this context tree structure', '- **Curate commands**: Check existing domains/topics before creating new ones', '</context-tree-structure>');
         return parts.join('\n');
     }
     /**
@@ -106,8 +106,8 @@ export class ContextTreeStructureContributor {
             'The context tree at `.brv/context-tree/` exists but contains no curated content yet.',
             '',
             '**For curate commands**: Create new domains and topics dynamically based on content.',
-            '- Choose semantically meaningful domain names (e.g., `authentication`, `api_design`, `data_models`)',
-            '- Use snake_case format for domain names',
+            '- Choose semantically meaningful domain names that represent broad knowledge categories',
+            '- Use snake_case format for domain names (e.g., `data_models`, `trading_strategies`, `personal_notes`)',
             '**For query commands**: No context is available to search.',
             '</context-tree-structure>',
         ].join('\n');

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

@@ -24,6 +24,14 @@ const CodeExecInputSchema = z
         .enum(['javascript', 'typescript'])
         .optional()
         .describe('Language: "javascript" or "typescript" (default: auto-detect)'),
+    /**
+     * If true, stdout is suppressed from the result (stderr still returned).
+     * Use for variable assignments or mutations where output is not needed.
+     */
+    silent: z
+        .boolean()
+        .optional()
+        .describe('If true, stdout is suppressed from the result. Use for variable assignments where output is not needed.'),
     /**
      * Timeout in milliseconds (max: 300000, default: 30000 = 30 seconds).
      */
@@ -54,7 +62,7 @@ export function createCodeExecTool(sandboxService) {
     return {
         description: 'Execute JavaScript or TypeScript code in a sandboxed REPL environment.',
         async execute(input, context) {
-            const { code, context: contextPayload, language, timeout } = input;
+            const { code, context: contextPayload, language, silent, timeout } = input;
             // Get sessionId from execution context (automatic - no user input needed)
             const sessionId = context?.sessionId ?? 'default';
             // Stream initial status via metadata callback if available
@@ -65,11 +73,42 @@ export function createCodeExecTool(sandboxService) {
                     progress: 0,
                 });
             }
+            // Cap stdout per command type to prevent context overflow
+            // curate: 5K (heavy processing, context in variables), query: 8K (results in variables)
+            const maxStdoutChars = context?.commandType === 'curate' ? 5000
+                : context?.commandType === 'query' ? 8000
+                    : undefined;
             const result = await sandboxService.executeCode(code, sessionId, {
                 contextPayload,
                 language,
+                maxStdoutChars,
                 timeout,
             });
+            // Auto-redirect large outputs to sandbox variable for RLM commands.
+            // This prevents large tool results from bloating conversation history.
+            const AUTO_REDIRECT_THRESHOLD = 2000;
+            if (!silent
+                && result.stdout.length > AUTO_REDIRECT_THRESHOLD
+                && (context?.commandType === 'curate' || context?.commandType === 'query')) {
+                const overflowVar = `__stdout_${Date.now()}`;
+                sandboxService.setSandboxVariable(sessionId, overflowVar, result.stdout);
+                // Stream completion via metadata callback if available
+                if (context?.metadata) {
+                    context.metadata({
+                        description: result.stderr ? 'Execution completed with errors' : 'Execution completed (output stored in variable)',
+                        output: `[Output stored in ${overflowVar}]` + (result.stderr ? `\n[stderr]\n${result.stderr}` : ''),
+                        progress: 100,
+                    });
+                }
+                return {
+                    executionTime: result.executionTime,
+                    finalResult: result.finalResult,
+                    locals: result.locals,
+                    returnValue: result.returnValue,
+                    stderr: result.stderr,
+                    stdout: `[Output (${result.stdout.length} chars) stored in variable: ${overflowVar}. Access via code_exec.]`,
+                };
+            }
             // Stream completion via metadata callback if available
             if (context?.metadata) {
                 context.metadata({
@@ -79,11 +118,13 @@ export function createCodeExecTool(sandboxService) {
                 });
             }
             return {
+                ...(result.curateResults ? { curateResults: result.curateResults } : {}),
                 executionTime: result.executionTime,
+                finalResult: result.finalResult,
                 locals: result.locals,
                 returnValue: result.returnValue,
                 stderr: result.stderr,
-                stdout: result.stdout,
+                stdout: silent ? '' : result.stdout,
             };
         },
         id: ToolName.CODE_EXEC,