byterover-cli 0.3.4 → 0.4.0

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

@@ -0,0 +1,404 @@
+var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
+        env.stack.push({ value: value, dispose: dispose, async: async });
+    }
+    else if (async) {
+        env.stack.push({ async: true });
+    }
+    return value;
+};
+var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
+    return function (env) {
+        function fail(e) {
+            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        var r, s = 0;
+        function next() {
+            while (r = env.stack.pop()) {
+                try {
+                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                    if (r.dispose) {
+                        var result = r.dispose.call(r.value);
+                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+                    }
+                    else s |= 1;
+                }
+                catch (e) {
+                    fail(e);
+                }
+            }
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    };
+})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});
+import Database from 'better-sqlite3';
+import * as fs from 'node:fs/promises';
+import { join } from 'node:path';
+import { lockKeyFromStorageKey, RWLock } from '../llm/context/rw-lock.js';
+/**
+ * SQLite-based key storage implementation.
+ *
+ * Stores key-value pairs where keys are hierarchical (StorageKey = string[])
+ * and values are JSON-serializable objects.
+ *
+ * Key path structure:
+ * - ["session", sessionId] → Session metadata
+ * - ["message", sessionId, messageId] → Individual message
+ * - ["part", messageId, partId] → Message part (tool output, file, etc.)
+ *
+ * Schema:
+ * - key_store: key_path (primary), value (JSON blob), created_at, updated_at
+ *
+ * Features:
+ * - Hierarchical key organization with prefix-based listing
+ * - Reader-writer locks for concurrent access
+ * - Atomic batch operations
+ * - ACID transactions via SQLite
+ */
+export class SqliteKeyStorage {
+    db = null;
+    dbPath;
+    initialized = false;
+    inMemory;
+    storageDir;
+    constructor(config) {
+        this.inMemory = config?.inMemory ?? false;
+        this.storageDir = config?.storageDir ?? join(process.cwd(), '.brv');
+        this.dbPath = this.inMemory ? ':memory:' : join(this.storageDir, config?.dbPath ?? 'context.db');
+    }
+    /**
+     * Execute batch operations atomically.
+     * All operations succeed or fail together.
+     */
+    async batch(operations) {
+        const env_1 = { stack: [], error: void 0, hasError: false };
+        try {
+            this.ensureInitialized();
+            if (operations.length === 0) {
+                return;
+            }
+            // Acquire write lock for all affected keys
+            const lockKey = 'batch:global';
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            const _lock = __addDisposableResource(env_1, await RWLock.write(lockKey), false);
+            const runBatch = this.db.transaction(() => {
+                for (const op of operations) {
+                    const keyPath = this.serializeKey(op.key);
+                    if (op.type === 'set') {
+                        const now = Date.now();
+                        const valueJson = JSON.stringify(op.value);
+                        // Check if exists to preserve created_at
+                        const existing = this.db.prepare('SELECT created_at FROM key_store WHERE key_path = ?').get(keyPath);
+                        this.db.prepare(`
+            INSERT INTO key_store (key_path, value, created_at, updated_at)
+            VALUES (?, ?, ?, ?)
+            ON CONFLICT(key_path) DO UPDATE SET
+              value = excluded.value,
+              updated_at = excluded.updated_at
+          `).run(keyPath, Buffer.from(valueJson), existing?.created_at ?? now, now);
+                    }
+                    else if (op.type === 'delete') {
+                        this.db.prepare('DELETE FROM key_store WHERE key_path = ?').run(keyPath);
+                    }
+                }
+            });
+            try {
+                runBatch();
+            }
+            catch (error) {
+                throw new Error(`Batch operation failed: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+        catch (e_1) {
+            env_1.error = e_1;
+            env_1.hasError = true;
+        }
+        finally {
+            __disposeResources(env_1);
+        }
+    }
+    /**
+     * Close the database connection.
+     */
+    close() {
+        if (this.db) {
+            this.db.close();
+            this.db = null;
+            this.initialized = false;
+        }
+    }
+    /**
+     * Delete a value by its composite key.
+     */
+    async delete(key) {
+        const env_2 = { 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_2, await RWLock.write(lockKey), false);
+            try {
+                const result = this.db.prepare('DELETE FROM key_store WHERE key_path = ?').run(keyPath);
+                return result.changes > 0;
+            }
+            catch (error) {
+                throw new Error(`Failed to delete key ${keyPath}: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+        catch (e_2) {
+            env_2.error = e_2;
+            env_2.hasError = true;
+        }
+        finally {
+            __disposeResources(env_2);
+        }
+    }
+    /**
+     * Check if a key exists.
+     */
+    async exists(key) {
+        const env_3 = { 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_3, await RWLock.read(lockKey), false);
+            const row = this.db.prepare('SELECT 1 FROM key_store WHERE key_path = ?').get(keyPath);
+            return row !== undefined;
+        }
+        catch (e_3) {
+            env_3.error = e_3;
+            env_3.hasError = true;
+        }
+        finally {
+            __disposeResources(env_3);
+        }
+    }
+    /**
+     * Get a value by its composite key.
+     */
+    async get(key) {
+        const env_4 = { 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_4, await RWLock.read(lockKey), false);
+            try {
+                const row = this.db.prepare('SELECT value FROM key_store WHERE key_path = ?').get(keyPath);
+                if (!row) {
+                    return undefined;
+                }
+                return JSON.parse(row.value.toString('utf8'));
+            }
+            catch (error) {
+                throw new Error(`Failed to get key ${keyPath}: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+        catch (e_4) {
+            env_4.error = e_4;
+            env_4.hasError = true;
+        }
+        finally {
+            __disposeResources(env_4);
+        }
+    }
+    /**
+     * Initialize the storage backend.
+     * Creates the database and runs migrations.
+     */
+    async initialize() {
+        if (this.initialized) {
+            return;
+        }
+        try {
+            // Ensure storage directory exists (skip for in-memory)
+            if (!this.inMemory) {
+                await fs.mkdir(this.storageDir, { recursive: true });
+            }
+            // Open/create database
+            this.db = new Database(this.dbPath);
+            // Enable WAL mode for better concurrent performance
+            this.db.pragma('journal_mode = WAL');
+            // Create key_store table
+            this.db.exec(`
+        CREATE TABLE IF NOT EXISTS key_store (
+          key_path TEXT PRIMARY KEY,
+          value BLOB NOT NULL,
+          created_at INTEGER NOT NULL,
+          updated_at INTEGER NOT NULL
+        )
+      `);
+            // Create index for prefix-based listing
+            this.db.exec(`CREATE INDEX IF NOT EXISTS idx_key_store_prefix ON key_store(key_path)`);
+            this.initialized = true;
+        }
+        catch (error) {
+            throw new Error(`Failed to initialize SQLite key storage: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    /**
+     * List all keys matching a prefix.
+     */
+    async list(prefix) {
+        const env_5 = { 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_5, await RWLock.read(lockKey), false);
+            try {
+                // Use LIKE with prefix pattern for efficient prefix matching
+                const rows = this.db.prepare('SELECT key_path FROM key_store WHERE key_path LIKE ? ORDER BY key_path').all(`${prefixPath}%`);
+                return rows.map((row) => this.deserializeKey(row.key_path));
+            }
+            catch (error) {
+                throw new Error(`Failed to list keys with prefix ${prefixPath}: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+        catch (e_5) {
+            env_5.error = e_5;
+            env_5.hasError = true;
+        }
+        finally {
+            __disposeResources(env_5);
+        }
+    }
+    /**
+     * Set a value at a composite key.
+     */
+    async set(key, value) {
+        const env_6 = { 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 now = Date.now();
+            const valueJson = JSON.stringify(value);
+            try {
+                // Check if exists to preserve created_at
+                const existing = this.db.prepare('SELECT created_at FROM key_store WHERE key_path = ?').get(keyPath);
+                this.db.prepare(`
+        INSERT INTO key_store (key_path, value, created_at, updated_at)
+        VALUES (?, ?, ?, ?)
+        ON CONFLICT(key_path) DO UPDATE SET
+          value = excluded.value,
+          updated_at = excluded.updated_at
+      `).run(keyPath, Buffer.from(valueJson), existing?.created_at ?? now, now);
+            }
+            catch (error) {
+                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;
+        }
+        finally {
+            __disposeResources(env_6);
+        }
+    }
+    /**
+     * Atomic update with optimistic locking.
+     */
+    async update(key, updater) {
+        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_7, 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);
+                const currentValue = row ? JSON.parse(row.value.toString('utf8')) : undefined;
+                // Apply updater function
+                const newValue = updater(currentValue);
+                // Write new value
+                const now = Date.now();
+                const valueJson = JSON.stringify(newValue);
+                this.db.prepare(`
+        INSERT INTO key_store (key_path, value, created_at, updated_at)
+        VALUES (?, ?, ?, ?)
+        ON CONFLICT(key_path) DO UPDATE SET
+          value = excluded.value,
+          updated_at = excluded.updated_at
+      `).run(keyPath, Buffer.from(valueJson), row?.created_at ?? now, now);
+                return newValue;
+            }
+            catch (error) {
+                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;
+        }
+        finally {
+            __disposeResources(env_7);
+        }
+    }
+    /**
+     * Deserialize a key path string back to StorageKey.
+     * Converts "message:session123:msg456" to ["message", "session123", "msg456"]
+     */
+    deserializeKey(keyPath) {
+        return keyPath.split(':');
+    }
+    /**
+     * Ensure storage has been initialized.
+     */
+    ensureInitialized() {
+        if (!this.initialized || !this.db) {
+            throw new Error('SqliteKeyStorage not initialized. Call initialize() first.');
+        }
+    }
+    /**
+     * Serialize a StorageKey to a string path.
+     * Converts ["message", "session123", "msg456"] to "message:session123:msg456"
+     */
+    serializeKey(key) {
+        if (key.length === 0) {
+            throw new Error('Storage key cannot be empty');
+        }
+        // Validate key segments don't contain the separator
+        for (const segment of key) {
+            if (segment.includes(':')) {
+                throw new Error(`Key segment cannot contain ':': ${segment}`);
+            }
+        }
+        return key.join(':');
+    }
+}
+/**
+ * Factory function to create SqliteKeyStorage with common defaults.
+ */
+export function createKeyStorage(config) {
+    return new SqliteKeyStorage(config);
+}

package/dist/infra/cipher/system-prompt/simple-prompt-factory.d.ts

@@ -19,6 +19,7 @@ export interface BuildContext {
         conversationId?: string;
         title?: string;
     };
+    fileReferenceInstructions?: string;
     memoryManager?: MemoryManager;
     mode?: 'autonomous' | 'default' | 'query';
 }

package/dist/infra/cipher/system-prompt/simple-prompt-factory.js

@@ -137,6 +137,13 @@ export class SimplePromptFactory {
                     }
                 }
             }
+            // Append file reference instructions after companion prompts (for curate command)
+            if (context.commandType === 'curate' && context.fileReferenceInstructions) {
+                finalPrompt = finalPrompt + '\n\n' + context.fileReferenceInstructions;
+                if (this.verbose) {
+                    console.log(`[PromptDebug:SimpleFactory] Appended file reference instructions: ${context.fileReferenceInstructions.length} chars`);
+                }
+            }
         }
         if (this.verbose) {
             console.log(`[PromptDebug:SimpleFactory] Final prompt: ${finalPrompt.length} chars`);

package/dist/infra/cipher/tools/default-policy-rules.js

@@ -80,7 +80,7 @@ export const DEFAULT_POLICY_RULES = [
         decision: 'ALLOW',
         name: 'allow-write-tools',
         reason: 'Write operations allowed in autonomous mode',
-        toolPattern: /^(write_file|edit_file|write_memory|edit_memory|delete_memory|create_knowledge_topic)$/,
+        toolPattern: /^(write_file|edit_file|write_memory|edit_memory|delete_memory|create_knowledge_topic |curate)$/,
     },
     /**
      * Allow bash execution (autonomous mode, with DENY rules above as safety net).

package/dist/infra/cipher/tools/implementations/curate-tool.d.ts

@@ -0,0 +1,10 @@
+import type { Tool } from '../../../../core/domain/cipher/tools/types.js';
+/**
+ * Creates the curate tool.
+ *
+ * This tool manages knowledge topics with atomic operations (ADD, UPDATE, MERGE, DELETE).
+ * It applies patterns from the ACE Curator for intelligent knowledge curation.
+ *
+ * @returns Configured curate tool
+ */
+export declare function createCurateTool(): Tool;