byterover-cli 2.0.0 → 2.1.0

package/dist/agent/infra/storage/dual-format-history-storage.d.ts

@@ -1,83 +0,0 @@
-import type { SessionMetadata } from '../../core/domain/storage/history-types.js';
-import type { IHistoryStorage } from '../../core/interfaces/i-history-storage.js';
-import type { InternalMessage } from '../../core/interfaces/message-types.js';
-import type { BlobHistoryStorage } from './blob-history-storage.js';
-import type { GranularHistoryStorage } from './granular-history-storage.js';
-/**
- * Dual-format history storage that routes between blob and granular storage.
- *
- * This router implements the "no migration" strategy:
- * - NEW sessions → GranularHistoryStorage (message-per-key with streaming)
- * - EXISTING sessions → BlobHistoryStorage (legacy single-blob format)
- *
- * Format detection:
- * - Granular format: has a session record at ["session", sessionId]
- * - Blob format: has a blob at "session-{sessionId}"
- * - New session: neither exists, uses granular format
- *
- * This allows seamless coexistence of both formats without migration.
- */
-export declare class DualFormatHistoryStorage implements IHistoryStorage {
-    private readonly blobStorage;
-    private readonly granularStorage;
-    constructor(blobStorage: BlobHistoryStorage, granularStorage: GranularHistoryStorage);
-    /**
-     * Append a single message to the session history.
-     * Routes to appropriate storage based on session format.
-     * New sessions use granular format.
-     */
-    appendMessage(sessionId: string, message: InternalMessage): Promise<void>;
-    /**
-     * Delete all history for a session.
-     * Deletes from both storages to ensure complete cleanup.
-     */
-    deleteHistory(sessionId: string): Promise<void>;
-    /**
-     * Check if history exists for a session in either format.
-     */
-    exists(sessionId: string): Promise<boolean>;
-    /**
-     * Get the underlying granular storage for advanced operations.
-     * Returns undefined if session is not in granular format.
-     */
-    getGranularStorage(sessionId: string): Promise<GranularHistoryStorage | undefined>;
-    /**
-     * Get metadata for a session from appropriate storage.
-     */
-    getSessionMetadata(sessionId: string): Promise<SessionMetadata | undefined>;
-    /**
-     * Check if a session uses granular format.
-     * Useful for consumers that want to use granular-specific features.
-     */
-    isGranularFormat(sessionId: string): Promise<boolean>;
-    /**
-     * List all session IDs from both storage formats.
-     */
-    listSessions(): Promise<string[]>;
-    /**
-     * Load conversation history for a session.
-     * Routes to appropriate storage based on session format.
-     */
-    loadHistory(sessionId: string): Promise<InternalMessage[] | undefined>;
-    /**
-     * Save conversation history for a session.
-     * Routes to appropriate storage based on session format.
-     *
-     * New sessions use granular format.
-     * Existing sessions stay in their original format.
-     */
-    saveHistory(sessionId: string, messages: InternalMessage[]): Promise<void>;
-    /**
-     * Detect which storage format a session uses.
-     *
-     * Priority:
-     * 1. Granular format (check first as it's the newer format)
-     * 2. Blob format (legacy)
-     * 3. None (new session)
-     */
-    private detectFormat;
-}
-/**
- * Factory function to create DualFormatHistoryStorage.
- */
-export declare function createDualFormatHistoryStorage(blobStorage: BlobHistoryStorage, granularStorage: GranularHistoryStorage): DualFormatHistoryStorage;

package/dist/agent/infra/storage/dual-format-history-storage.js

@@ -1,165 +0,0 @@
-/**
- * Dual-format history storage that routes between blob and granular storage.
- *
- * This router implements the "no migration" strategy:
- * - NEW sessions → GranularHistoryStorage (message-per-key with streaming)
- * - EXISTING sessions → BlobHistoryStorage (legacy single-blob format)
- *
- * Format detection:
- * - Granular format: has a session record at ["session", sessionId]
- * - Blob format: has a blob at "session-{sessionId}"
- * - New session: neither exists, uses granular format
- *
- * This allows seamless coexistence of both formats without migration.
- */
-export class DualFormatHistoryStorage {
-    blobStorage;
-    granularStorage;
-    constructor(blobStorage, granularStorage) {
-        this.blobStorage = blobStorage;
-        this.granularStorage = granularStorage;
-    }
-    /**
-     * Append a single message to the session history.
-     * Routes to appropriate storage based on session format.
-     * New sessions use granular format.
-     */
-    async appendMessage(sessionId, message) {
-        const format = await this.detectFormat(sessionId);
-        if (format === 'granular') {
-            return this.granularStorage.appendMessage(sessionId, message);
-        }
-        if (format === 'blob') {
-            return this.blobStorage.appendMessage(sessionId, message);
-        }
-        // New session - use granular format
-        return this.granularStorage.appendMessage(sessionId, message);
-    }
-    /**
-     * Delete all history for a session.
-     * Deletes from both storages to ensure complete cleanup.
-     */
-    async deleteHistory(sessionId) {
-        const format = await this.detectFormat(sessionId);
-        if (format === 'granular') {
-            await this.granularStorage.deleteHistory(sessionId);
-        }
-        else if (format === 'blob') {
-            await this.blobStorage.deleteHistory(sessionId);
-        }
-        // For 'none', nothing to delete
-    }
-    /**
-     * Check if history exists for a session in either format.
-     */
-    async exists(sessionId) {
-        const format = await this.detectFormat(sessionId);
-        return format !== 'none';
-    }
-    /**
-     * Get the underlying granular storage for advanced operations.
-     * Returns undefined if session is not in granular format.
-     */
-    async getGranularStorage(sessionId) {
-        const format = await this.detectFormat(sessionId);
-        if (format === 'granular' || format === 'none') {
-            return this.granularStorage;
-        }
-        return undefined;
-    }
-    /**
-     * Get metadata for a session from appropriate storage.
-     */
-    async getSessionMetadata(sessionId) {
-        const format = await this.detectFormat(sessionId);
-        if (format === 'granular') {
-            return this.granularStorage.getSessionMetadata(sessionId);
-        }
-        if (format === 'blob') {
-            return this.blobStorage.getSessionMetadata(sessionId);
-        }
-        return undefined;
-    }
-    /**
-     * Check if a session uses granular format.
-     * Useful for consumers that want to use granular-specific features.
-     */
-    async isGranularFormat(sessionId) {
-        const format = await this.detectFormat(sessionId);
-        return format === 'granular';
-    }
-    /**
-     * List all session IDs from both storage formats.
-     */
-    async listSessions() {
-        const [blobSessions, granularSessions] = await Promise.all([
-            this.blobStorage.listSessions(),
-            this.granularStorage.listSessions(),
-        ]);
-        // Combine and deduplicate (shouldn't have duplicates, but be safe)
-        const allSessions = new Set([...blobSessions, ...granularSessions]);
-        return [...allSessions];
-    }
-    /**
-     * Load conversation history for a session.
-     * Routes to appropriate storage based on session format.
-     */
-    async loadHistory(sessionId) {
-        const format = await this.detectFormat(sessionId);
-        if (format === 'granular') {
-            return this.granularStorage.loadHistory(sessionId);
-        }
-        if (format === 'blob') {
-            return this.blobStorage.loadHistory(sessionId);
-        }
-        // New session - return undefined (no history yet)
-        return undefined;
-    }
-    /**
-     * Save conversation history for a session.
-     * Routes to appropriate storage based on session format.
-     *
-     * New sessions use granular format.
-     * Existing sessions stay in their original format.
-     */
-    async saveHistory(sessionId, messages) {
-        const format = await this.detectFormat(sessionId);
-        if (format === 'granular') {
-            return this.granularStorage.saveHistory(sessionId, messages);
-        }
-        if (format === 'blob') {
-            // Keep existing blob sessions in blob format
-            return this.blobStorage.saveHistory(sessionId, messages);
-        }
-        // New session - use granular format
-        return this.granularStorage.saveHistory(sessionId, messages);
-    }
-    /**
-     * Detect which storage format a session uses.
-     *
-     * Priority:
-     * 1. Granular format (check first as it's the newer format)
-     * 2. Blob format (legacy)
-     * 3. None (new session)
-     */
-    async detectFormat(sessionId) {
-        // Check granular format first (newer, preferred)
-        const isGranular = await this.granularStorage.exists(sessionId);
-        if (isGranular) {
-            return 'granular';
-        }
-        // Check blob format (legacy)
-        const isBlob = await this.blobStorage.exists(sessionId);
-        if (isBlob) {
-            return 'blob';
-        }
-        // New session
-        return 'none';
-    }
-}
-/**
- * Factory function to create DualFormatHistoryStorage.
- */
-export function createDualFormatHistoryStorage(blobStorage, granularStorage) {
-    return new DualFormatHistoryStorage(blobStorage, granularStorage);
-}

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

@@ -1,113 +0,0 @@
-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[]>;
-    /**
-     * 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 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;