byterover-cli 1.5.0 → 1.7.0

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

@@ -0,0 +1,105 @@
+import type { BatchOperation, IKeyStorage, StorageKey } from '../../core/interfaces/i-key-storage.js';
+/**
+ * Configuration for SQLite key storage
+ */
+export interface SqliteKeyStorageConfig {
+    /**
+     * Database file path (relative or absolute).
+     * Defaults to 'context.db'
+     */
+    dbPath?: string;
+    /**
+     * Enable in-memory mode for testing.
+     * Defaults to false.
+     */
+    inMemory?: boolean;
+    /**
+     * Storage directory for the database file.
+     * Defaults to process.cwd()/.brv/blobs
+     */
+    storageDir?: string;
+}
+/**
+ * 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 declare class SqliteKeyStorage implements IKeyStorage {
+    private db;
+    private readonly dbPath;
+    private initialized;
+    private readonly inMemory;
+    private readonly storageDir;
+    constructor(config?: SqliteKeyStorageConfig);
+    /**
+     * Execute batch operations atomically.
+     * All operations succeed or fail together.
+     */
+    batch(operations: BatchOperation[]): Promise<void>;
+    /**
+     * Close the database connection.
+     */
+    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 database and runs migrations.
+     */
+    initialize(): Promise<void>;
+    /**
+     * List all keys matching a prefix.
+     */
+    list(prefix: StorageKey): Promise<StorageKey[]>;
+    /**
+     * 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 key path string back to StorageKey.
+     * Converts "message:session123:msg456" to ["message", "session123", "msg456"]
+     */
+    private deserializeKey;
+    /**
+     * Ensure storage has been initialized.
+     */
+    private ensureInitialized;
+    /**
+     * Serialize a StorageKey to a string path.
+     * Converts ["message", "session123", "msg456"] to "message:session123:msg456"
+     */
+    private serializeKey;
+}
+/**
+ * Factory function to create SqliteKeyStorage with common defaults.
+ */
+export declare function createKeyStorage(config?: SqliteKeyStorageConfig): SqliteKeyStorage;

package/dist/agent/infra/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', 'blobs');
+        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/agent/infra/storage/tool-part-factory.d.ts

@@ -0,0 +1,116 @@
+/**
+ * Factory for creating and managing tool parts with state machine.
+ *
+ * This module provides utilities for:
+ * - Creating tool parts in pending state
+ * - Transitioning tool parts through their lifecycle (pending → running → completed/error)
+ * - Marking tool parts as compacted for pruning
+ *
+ * Based on OpenCode's tool state machine pattern.
+ */
+import type { StoredPart, StoredToolState } from '../../core/domain/storage/message-storage-types.js';
+import type { AttachmentPart } from '../../core/interfaces/message-types.js';
+/**
+ * Options for creating a completed tool state.
+ */
+export interface ToolCompletionOptions {
+    /** Attachments produced by the tool (images, files) */
+    attachments?: AttachmentPart[];
+    /** Additional metadata about the execution */
+    metadata?: Record<string, unknown>;
+    /** Human-readable title for display */
+    title?: string;
+}
+/**
+ * Factory for creating and managing tool parts with state machine.
+ *
+ * Tool parts track the full lifecycle of a tool call:
+ * 1. Pending: Tool call received from LLM, not yet started
+ * 2. Running: Execution has started
+ * 3. Completed: Execution finished successfully with output
+ * 4. Error: Execution failed with error message
+ *
+ * This enables:
+ * - Real-time UI feedback during tool execution
+ * - Better conversation history representation
+ * - Efficient compaction (mark individual outputs as compacted)
+ */
+export declare const ToolPartFactory: {
+    /**
+     * Create a new tool part in pending state.
+     *
+     * @param messageId - ID of the message this part belongs to
+     * @param callId - Unique identifier for this tool call
+     * @param toolName - Name of the tool being called
+     * @param input - Parsed input arguments
+     * @returns StoredPart with pending tool state
+     */
+    createPending(messageId: string, callId: string, toolName: string, input: Record<string, unknown>): StoredPart;
+    /**
+     * Mark a tool part as compacted.
+     * Clears the output while preserving the state structure.
+     *
+     * @param part - The tool part to mark as compacted
+     * @returns Updated StoredPart with compactedAt timestamp
+     */
+    markCompacted(part: StoredPart): StoredPart;
+    /**
+     * Convert a StoredPart's tool state to the format used in message-types.ts.
+     * Useful for reconstructing InternalMessage from stored parts.
+     *
+     * @param toolState - The stored tool state
+     * @returns Tool state in the format expected by ToolPart
+     */
+    toToolPartState(toolState: StoredToolState): {
+        attachments?: AttachmentPart[];
+        compactedAt?: number;
+        input: Record<string, unknown>;
+        metadata?: Record<string, unknown>;
+        output: string;
+        status: "completed";
+        time: {
+            end: number;
+            start: number;
+        };
+        title?: string;
+    } | {
+        error: string;
+        input: Record<string, unknown>;
+        status: "error";
+        time: {
+            end: number;
+            start: number;
+        };
+    } | {
+        input: Record<string, unknown>;
+        startedAt: number;
+        status: "running";
+    } | {
+        input: Record<string, unknown>;
+        status: "pending";
+    };
+    /**
+     * Transition a tool part to completed state.
+     *
+     * @param part - The tool part to update
+     * @param output - Tool output content
+     * @param options - Additional options (title, metadata, attachments)
+     * @returns Updated StoredPart with completed state
+     */
+    transitionToCompleted(part: StoredPart, output: string, options?: ToolCompletionOptions): StoredPart;
+    /**
+     * Transition a tool part to error state.
+     *
+     * @param part - The tool part to update
+     * @param error - Error message
+     * @returns Updated StoredPart with error state
+     */
+    transitionToError(part: StoredPart, error: string): StoredPart;
+    /**
+     * Transition a tool part to running state.
+     *
+     * @param part - The tool part to update
+     * @returns Updated StoredPart with running state
+     */
+    transitionToRunning(part: StoredPart): StoredPart;
+};

package/dist/agent/infra/system-prompt/contributors/agent-prompt-contributor.d.ts

@@ -0,0 +1,59 @@
+import type { ContributorContext, SystemPromptContributor } from '../../../core/domain/system-prompt/types.js';
+/**
+ * Options for agent prompt contributor configuration.
+ */
+export interface AgentPromptContributorOptions {
+    /** Base path for resolving relative file paths */
+    basePath?: string;
+    /** Whether to cache file contents (default: true) */
+    cache?: boolean;
+}
+/**
+ * Agent prompt contributor that loads agent-specific prompts from YAML files.
+ *
+ * This contributor reads the agent's prompt configuration from the agent registry
+ * and loads the corresponding YAML prompt file. It supports:
+ * - Loading prompts from the agent's `promptFile` configuration
+ * - Falling back to inline `prompt` if no promptFile is specified
+ * - Caching loaded prompts for performance
+ *
+ * The agent name is typically passed via the ContributorContext.
+ */
+export declare class AgentPromptContributor implements SystemPromptContributor {
+    readonly id: string;
+    readonly priority: number;
+    private readonly basePath;
+    private readonly cache;
+    private readonly useCache;
+    /**
+     * Creates a new agent prompt contributor.
+     *
+     * @param id - Unique identifier for this contributor
+     * @param priority - Execution priority (lower = first)
+     * @param options - Configuration options
+     */
+    constructor(id: string, priority: number, options?: AgentPromptContributorOptions);
+    /**
+     * Loads and returns the agent-specific prompt content.
+     *
+     * The agent name should be provided in the context. If no agent name
+     * is specified, or the agent has no prompt configured, returns an empty string.
+     *
+     * @param context - Contributor context with agent name
+     * @returns Agent prompt content string
+     */
+    getContent(context: ContributorContext): Promise<string>;
+    /**
+     * Invalidate the cache for a specific file.
+     *
+     * @param filepath - Path to the file to invalidate
+     */
+    invalidateCache(filepath?: string): void;
+    /**
+     * Load prompt content from a YAML file.
+     *
+     * @param filepath - Path to the YAML prompt file
+     * @returns Prompt content string
+     */
+    private loadPromptFile;
+}