byterover-cli 2.0.0 → 2.1.0

package/dist/agent/infra/sandbox/tools-sdk.js

@@ -1,3 +1,6 @@
+import { ContextTreeStore } from '../map/context-tree-store.js';
+import { executeLlmMapMemory } from '../map/llm-map-memory.js';
+import { chunk, dedup, detectMessageBoundaries, groupBySubject, recon, recordProgress, } from './curation-helpers.js';
 /**
  * Creates a Tools SDK instance for sandbox code execution.
  *
@@ -8,7 +11,8 @@
  * @returns ToolsSDK instance ready to be injected into sandbox context
  */
 export function createToolsSDK(options) {
-    const { curateService, fileSystem, parentSessionId, sandboxService, searchKnowledgeService, sessionManager } = options;
+    const { commandType, contentGenerator, curateService, fileSystem, parentSessionId, sandboxService, searchKnowledgeService, sessionManager } = options;
+    const isReadOnly = commandType === 'query';
     return {
         async agentQuery(prompt, options) {
             if (!sessionManager || !parentSessionId) {
@@ -37,6 +41,9 @@ export function createToolsSDK(options) {
             }
         },
         async curate(operations, options) {
+            if (isReadOnly) {
+                throw new Error('curate() is disabled in read-only (query) mode');
+            }
             if (!curateService) {
                 return {
                     applied: [{
@@ -56,6 +63,47 @@ export function createToolsSDK(options) {
             }
             return curateService.curate(operations, options);
         },
+        curation: {
+            chunk,
+            dedup,
+            detectMessageBoundaries,
+            groupBySubject,
+            async mapExtract(context, options) {
+                if (commandType !== 'curate') {
+                    throw new Error('mapExtract only available in curate mode');
+                }
+                if (!contentGenerator) {
+                    throw new Error('mapExtract not available — no content generator configured');
+                }
+                const chunks = chunk(context, { size: options.chunkSize ?? 8000 });
+                const items = chunks.chunks.map((c, i) => ({ chunk: c, index: i, totalChunks: chunks.totalChunks }));
+                // Construct ContextTreeStore with adapter tokenizer (zero-divergence)
+                const tauHard = Math.floor((options.maxContextTokens ?? 100_000) * 0.5);
+                const contextTreeStore = new ContextTreeStore({
+                    generator: contentGenerator,
+                    tauHard,
+                    tokenizer: { countTokens: (text) => contentGenerator.estimateTokensSync(text) },
+                });
+                const result = await executeLlmMapMemory({
+                    concurrency: options.concurrency ?? 8,
+                    contextTreeStore,
+                    generator: contentGenerator,
+                    items,
+                    prompt: options.prompt,
+                    taskId: options.taskId,
+                });
+                // Throw when all chunks fail — no facts to work with
+                if (result.succeeded === 0 && result.total > 0) {
+                    throw new Error(`mapExtract failed: all ${result.total} chunks failed extraction`);
+                }
+                const facts = result.results
+                    .filter((r) => r !== null)
+                    .flat();
+                return { facts, failed: result.failed, succeeded: result.succeeded, total: result.total };
+            },
+            recon,
+            recordProgress,
+        },
         async detectDomains(domains) {
             if (!curateService) {
                 return {
@@ -105,6 +153,9 @@ export function createToolsSDK(options) {
             return searchKnowledgeService.search(query, options);
         },
         async writeFile(filePath, content, options) {
+            if (isReadOnly) {
+                throw new Error('writeFile() is disabled in read-only (query) mode');
+            }
             return fileSystem.writeFile(filePath, content, {
                 createDirs: options?.createDirs ?? false,
             });

package/dist/agent/infra/session/session-manager.d.ts

@@ -31,8 +31,14 @@ export interface SessionMetadata {
 /**
  * Options for SessionManager constructor
  */
+export type SessionRemovalReason = 'deleted' | 'ended' | 'ttl_expired';
 export interface SessionManagerOptions {
     config?: SessionManagerConfig;
+    /**
+     * Optional lifecycle callback fired after a session is removed from memory maps.
+     * Used by CipherAgent to synchronize external registries (e.g., nesting registry).
+     */
+    onSessionRemoved?: (sessionId: string, reason: SessionRemovalReason) => void;
 }
 /**
  * Session manager.
@@ -46,6 +52,7 @@ export declare class SessionManager {
     private readonly config;
     private readonly httpConfig;
     private readonly llmConfig;
+    private readonly onSessionRemoved?;
     private pendingCreations;
     /** Agent name for each session (e.g., 'plan', 'query', 'curate') */
     private readonly sessionAgentNames;
@@ -145,7 +152,7 @@ export declare class SessionManager {
      * @param id - Session ID to end
      * @returns True if session existed and was ended
      */
-    endSession(id: string): Promise<boolean>;
+    endSession(id: string, reason?: SessionRemovalReason): Promise<boolean>;
     /**
      * Get a session by ID.
      *

package/dist/agent/infra/session/session-manager.js

@@ -19,6 +19,7 @@ export class SessionManager {
     config;
     httpConfig;
     llmConfig;
+    onSessionRemoved;
     pendingCreations = new Map();
     /** Agent name for each session (e.g., 'plan', 'query', 'curate') */
     sessionAgentNames = new Map();
@@ -54,6 +55,7 @@ export class SessionManager {
         this.sharedServices = sharedServices;
         this.httpConfig = httpConfig;
         this.llmConfig = llmConfig;
+        this.onSessionRemoved = options?.onSessionRemoved;
         this.config = {
             maxSessions: options?.config?.maxSessions ?? 100,
             sessionTTL: options?.config?.sessionTTL ?? 3_600_000, // 1 hour
@@ -199,7 +201,16 @@ export class SessionManager {
         this.sessionAgentNames.delete(id);
         this.sessionParentIds.delete(id);
         // Remove from memory
-        return this.sessions.delete(id);
+        const deleted = this.sessions.delete(id);
+        if (deleted) {
+            try {
+                this.onSessionRemoved?.(id, 'deleted');
+            }
+            catch {
+                // Fail-open: session deletion must not fail due to callback errors
+            }
+        }
+        return deleted;
     }
     /**
      * Stop cleanup timer and dispose of all resources.
@@ -235,7 +246,7 @@ export class SessionManager {
      * @param id - Session ID to end
      * @returns True if session existed and was ended
      */
-    async endSession(id) {
+    async endSession(id, reason = 'ended') {
         const session = this.sessions.get(id);
         if (!session) {
             return false;
@@ -252,7 +263,16 @@ export class SessionManager {
         this.sessionAgentNames.delete(id);
         this.sessionParentIds.delete(id);
         // Remove from memory only - history remains in storage
-        return this.sessions.delete(id);
+        const ended = this.sessions.delete(id);
+        if (ended) {
+            try {
+                this.onSessionRemoved?.(id, reason);
+            }
+            catch {
+                // Fail-open: session ending must not fail due to callback errors
+            }
+        }
+        return ended;
     }
     /**
      * Get a session by ID.
@@ -349,7 +369,7 @@ export class SessionManager {
             const lastActivity = this.sessionLastActivity.get(id) ?? 0;
             if (now - lastActivity > this.config.sessionTTL) {
                 // eslint-disable-next-line no-await-in-loop
-                await this.endSession(id); // Preserve history
+                await this.endSession(id, 'ttl_expired'); // Preserve history
                 cleaned++;
             }
         }

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

@@ -0,0 +1,142 @@
+import type { BatchOperation, IKeyStorage, StorageKey } from '../../core/interfaces/i-key-storage.js';
+/**
+ * Configuration for file-based key storage.
+ */
+export interface FileKeyStorageConfig {
+    /**
+     * Enable in-memory mode for testing.
+     * Uses a Map instead of the filesystem — no I/O, fast unit tests.
+     * Defaults to false.
+     */
+    inMemory?: boolean;
+    /**
+     * Storage directory for the keystore.
+     * Required when inMemory is false.
+     */
+    storageDir?: string;
+}
+/**
+ * File-based key storage implementation.
+ *
+ * Stores key-value pairs as individual JSON files on the filesystem.
+ * Composite keys map to directory paths:
+ *   ["message", sessionId, msgId] → {storageDir}/keystore/message/{sessionId}/{msgId}.json
+ *
+ * Features:
+ * - One file per entity (O(1) read/write/delete)
+ * - Atomic writes via write-to-temp + rename
+ * - Reader-writer locks for concurrent access (reuses global RWLock)
+ * - In-memory mode for fast unit tests
+ * - Hierarchical prefix listing via readdir
+ */
+export declare class FileKeyStorage implements IKeyStorage {
+    private readonly baseDir;
+    private initialized;
+    private readonly inMemory;
+    private memoryStore;
+    private readonly storageDir;
+    constructor(config?: FileKeyStorageConfig);
+    /**
+     * Execute batch operations.
+     * Operations are executed sequentially with write-temp-rename per operation.
+     * Best-effort: not ACID across multiple files, but each individual
+     * file write is atomic via rename.
+     */
+    batch(operations: BatchOperation[]): Promise<void>;
+    /**
+     * Close the storage. No-op for file-based storage.
+     */
+    close(): void;
+    /**
+     * Delete a value by its composite key.
+     */
+    delete(key: StorageKey): Promise<boolean>;
+    /**
+     * Check if a key exists.
+     */
+    exists(key: StorageKey): Promise<boolean>;
+    /**
+     * Get a value by its composite key.
+     */
+    get<T>(key: StorageKey): Promise<T | undefined>;
+    /**
+     * Initialize the storage backend.
+     * Creates the base keystore directory.
+     */
+    initialize(): Promise<void>;
+    /**
+     * 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.
+     */
+    set<T>(key: StorageKey, value: T): Promise<void>;
+    /**
+     * Atomic update with optimistic locking.
+     */
+    update<T>(key: StorageKey, updater: (current: T | undefined) => T): Promise<T>;
+    /**
+     * Deserialize a colon-separated string back to a StorageKey.
+     */
+    private deserializeKey;
+    private ensureInitialized;
+    /**
+     * Convert a StorageKey to a filesystem path.
+     * ["message", "abc", "msg1"] → {baseDir}/message/abc/msg1.json
+     */
+    private keyToPath;
+    /**
+     * List keys from disk by scanning the prefix directory.
+     */
+    private listFromDisk;
+    /**
+     * List keys from in-memory store matching a prefix.
+     */
+    private listInMemory;
+    /**
+     * List keys with values from disk.
+     */
+    private listWithValuesFromDisk;
+    /**
+     * List keys with values from in-memory store.
+     */
+    private listWithValuesInMemory;
+    /**
+     * Read the stored envelope for a key. Returns undefined if not found.
+     */
+    private readEnvelope;
+    /**
+     * Remove a file for the given key. Returns true if it existed.
+     */
+    private removeFile;
+    /**
+     * Recursively scan a directory to collect all storage keys.
+     */
+    private scanDirectory;
+    /**
+     * Serialize a StorageKey to a string for in-memory store lookups.
+     * Uses ':' separator (same as lockKeyFromStorageKey).
+     */
+    private serializeKey;
+    /**
+     * Validate key segments.
+     */
+    private validateKey;
+    /**
+     * Write an envelope to disk using atomic write-to-temp + rename.
+     */
+    private writeEnvelope;
+}
+/**
+ * Factory function to create FileKeyStorage with common defaults.
+ */
+export declare function createFileKeyStorage(config?: FileKeyStorageConfig): FileKeyStorage;