byterover-cli 2.0.0 → 2.1.0

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

@@ -1,307 +0,0 @@
-import Database from 'better-sqlite3';
-import * as fs from 'node:fs/promises';
-import { dirname, join } from 'node:path';
-import { BlobError } from '../../core/domain/errors/blob-error.js';
-import { runMigrations } from './migrations.js';
-/**
- * SQLite-based blob storage implementation
- *
- * Stores all blobs in a single SQLite database file:
- * - .brv/storage.db
- *
- * Schema:
- * - blobs: key, content, content_type, original_name, size, tags, created_at, updated_at
- *
- * Benefits over file-based storage:
- * - O(1) lookup for exists/retrieve
- * - Fast listing and filtering
- * - ACID transactions for data integrity
- * - Single file for easy backup/migration
- */
-export class SqliteBlobStorage {
-    db = null;
-    dbPath;
-    initialized = false;
-    inMemory;
-    logger;
-    maxBlobSize;
-    maxTotalSize;
-    storageDir;
-    constructor(config) {
-        this.inMemory = config?.inMemory ?? false;
-        this.storageDir = config?.storageDir ?? '';
-        if (!this.inMemory && !this.storageDir) {
-            throw new Error('SqliteBlobStorage: storageDir is required when inMemory is false');
-        }
-        this.dbPath = this.inMemory ? ':memory:' : (config?.dbPath ?? join(this.storageDir, 'storage.db'));
-        this.maxBlobSize = config?.maxBlobSize ?? 100 * 1024 * 1024; // 100MB default
-        this.maxTotalSize = config?.maxTotalSize ?? 1024 * 1024 * 1024; // 1GB default
-        this.logger = config?.logger ?? {
-            error: (message) => console.error(message),
-            info: (message) => console.log(message),
-        };
-    }
-    /**
-     * Clear all blobs from storage
-     * WARNING: This is a destructive operation
-     */
-    async clear() {
-        this.ensureInitialized();
-        try {
-            this.db.exec('DELETE FROM blobs');
-        }
-        catch (error) {
-            throw BlobError.deleteError(`Failed to clear storage: ${error instanceof Error ? error.message : String(error)}`, error instanceof Error ? error : undefined);
-        }
-    }
-    /**
-     * Close the database connection
-     */
-    close() {
-        if (this.db) {
-            this.db.close();
-            this.db = null;
-            this.initialized = false;
-        }
-    }
-    /**
-     * Delete a blob by its key
-     */
-    async delete(key) {
-        this.ensureInitialized();
-        this.validateKey(key);
-        try {
-            const stmt = this.db.prepare('DELETE FROM blobs WHERE key = ?');
-            const result = stmt.run(key);
-            if (result.changes === 0) {
-                throw BlobError.notFound(key);
-            }
-        }
-        catch (error) {
-            if (error instanceof BlobError) {
-                throw error;
-            }
-            throw BlobError.deleteError(`Failed to delete blob ${key}: ${error instanceof Error ? error.message : String(error)}`, error instanceof Error ? error : undefined);
-        }
-    }
-    /**
-     * Check if a blob exists
-     */
-    async exists(key) {
-        this.ensureInitialized();
-        this.validateKey(key);
-        const stmt = this.db.prepare('SELECT 1 FROM blobs WHERE key = ?');
-        const row = stmt.get(key);
-        return row !== undefined;
-    }
-    /**
-     * Get metadata for a blob without retrieving its content
-     */
-    async getMetadata(key) {
-        this.ensureInitialized();
-        this.validateKey(key);
-        try {
-            const stmt = this.db.prepare(`
-        SELECT content_type, original_name, size, tags, created_at, updated_at
-        FROM blobs WHERE key = ?
-      `);
-            const row = stmt.get(key);
-            if (!row) {
-                return undefined;
-            }
-            return this.rowToMetadata(row);
-        }
-        catch (error) {
-            throw BlobError.retrievalError(`Failed to read metadata for blob ${key}: ${error instanceof Error ? error.message : String(error)}`, error instanceof Error ? error : undefined);
-        }
-    }
-    /**
-     * Get storage statistics
-     */
-    async getStats() {
-        this.ensureInitialized();
-        try {
-            const stmt = this.db.prepare(`
-        SELECT COUNT(*) as count, COALESCE(SUM(size), 0) as total_size
-        FROM blobs
-      `);
-            const row = stmt.get();
-            return {
-                lastUpdated: Date.now(),
-                totalBlobs: row.count,
-                totalSize: row.total_size,
-            };
-        }
-        catch (error) {
-            throw BlobError.retrievalError(`Failed to get storage stats: ${error instanceof Error ? error.message : String(error)}`, error instanceof Error ? error : undefined);
-        }
-    }
-    /**
-     * Initialize storage by creating the database and running migrations
-     */
-    async initialize() {
-        if (this.initialized) {
-            return;
-        }
-        try {
-            // Ensure parent directory of database file exists (skip for in-memory)
-            if (!this.inMemory) {
-                await fs.mkdir(dirname(this.dbPath), { recursive: true });
-            }
-            // Open/create database (':memory:' for in-memory mode)
-            this.db = new Database(this.dbPath);
-            // Enable WAL mode for better concurrent performance
-            this.db.pragma('journal_mode = WAL');
-            // Run migrations to ensure schema is up-to-date
-            runMigrations(this.db, this.logger);
-            this.initialized = true;
-        }
-        catch (error) {
-            throw BlobError.initializationError(`Failed to initialize SQLite storage: ${error instanceof Error ? error.message : String(error)}`, error instanceof Error ? error : undefined);
-        }
-    }
-    /**
-     * List all blob keys, optionally filtered by prefix
-     */
-    async list(prefix) {
-        this.ensureInitialized();
-        try {
-            let stmt;
-            let rows;
-            if (prefix) {
-                stmt = this.db.prepare('SELECT key FROM blobs WHERE key LIKE ? ORDER BY key');
-                rows = stmt.all(`${prefix}%`);
-            }
-            else {
-                stmt = this.db.prepare('SELECT key FROM blobs ORDER BY key');
-                rows = stmt.all();
-            }
-            return rows.map((row) => row.key);
-        }
-        catch (error) {
-            throw BlobError.retrievalError(`Failed to list blobs: ${error instanceof Error ? error.message : String(error)}`, error instanceof Error ? error : undefined);
-        }
-    }
-    /**
-     * Retrieve a blob by its key
-     */
-    async retrieve(key) {
-        this.ensureInitialized();
-        this.validateKey(key);
-        try {
-            const stmt = this.db.prepare('SELECT * FROM blobs WHERE key = ?');
-            const row = stmt.get(key);
-            if (!row) {
-                return undefined;
-            }
-            return {
-                content: row.content,
-                key: row.key,
-                metadata: this.rowToMetadata(row),
-            };
-        }
-        catch (error) {
-            throw BlobError.retrievalError(`Failed to retrieve blob ${key}: ${error instanceof Error ? error.message : String(error)}`, error instanceof Error ? error : undefined);
-        }
-    }
-    /**
-     * Store a blob with optional metadata
-     */
-    async store(key, content, metadata) {
-        this.ensureInitialized();
-        this.validateKey(key);
-        // Convert content to Buffer
-        const buffer = Buffer.isBuffer(content) ? content : Buffer.from(content);
-        // Check individual blob size
-        if (buffer.length > this.maxBlobSize) {
-            throw BlobError.tooLarge(buffer.length, this.maxBlobSize);
-        }
-        // Check total storage size
-        const stats = await this.getStats();
-        const existingBlob = await this.retrieve(key);
-        const existingSize = existingBlob?.metadata.size ?? 0;
-        const newTotalSize = stats.totalSize - existingSize + buffer.length;
-        if (newTotalSize > this.maxTotalSize) {
-            throw BlobError.totalSizeExceeded(stats.totalSize - existingSize, buffer.length, this.maxTotalSize);
-        }
-        const now = Date.now();
-        const fullMetadata = {
-            createdAt: existingBlob?.metadata.createdAt ?? now,
-            size: buffer.length,
-            updatedAt: now,
-            ...metadata,
-        };
-        try {
-            const stmt = this.db.prepare(`
-        INSERT INTO blobs (key, content, content_type, original_name, size, tags, created_at, updated_at)
-        VALUES (?, ?, ?, ?, ?, ?, ?, ?)
-        ON CONFLICT(key) DO UPDATE SET
-          content = excluded.content,
-          content_type = excluded.content_type,
-          original_name = excluded.original_name,
-          size = excluded.size,
-          tags = excluded.tags,
-          updated_at = excluded.updated_at
-      `);
-            stmt.run(key, buffer, fullMetadata.contentType ?? null, fullMetadata.originalName ?? null, buffer.length, fullMetadata.tags ? JSON.stringify(fullMetadata.tags) : null, fullMetadata.createdAt, fullMetadata.updatedAt);
-            return {
-                content: buffer,
-                key,
-                metadata: fullMetadata,
-            };
-        }
-        catch (error) {
-            throw BlobError.storageError(`Failed to store blob ${key}: ${error instanceof Error ? error.message : String(error)}`, error instanceof Error ? error : undefined);
-        }
-    }
-    /**
-     * Ensure storage has been initialized
-     */
-    ensureInitialized() {
-        if (!this.initialized || !this.db) {
-            throw BlobError.notInitialized();
-        }
-    }
-    /**
-     * Convert database row to BlobMetadata
-     */
-    rowToMetadata(row) {
-        const metadata = {
-            createdAt: row.created_at,
-            size: row.size,
-            updatedAt: row.updated_at,
-        };
-        if (row.content_type) {
-            metadata.contentType = row.content_type;
-        }
-        if (row.original_name) {
-            metadata.originalName = row.original_name;
-        }
-        if (row.tags) {
-            try {
-                metadata.tags = JSON.parse(row.tags);
-            }
-            catch {
-                // Ignore invalid JSON
-            }
-        }
-        return metadata;
-    }
-    /**
-     * Validate blob key
-     * Keys must be alphanumeric with hyphens and underscores only
-     */
-    validateKey(key) {
-        if (!key || typeof key !== 'string') {
-            throw BlobError.invalidKey(String(key), 'Key must be a non-empty string');
-        }
-        if (key.length === 0) {
-            throw BlobError.invalidKey(key, 'Key cannot be empty');
-        }
-        // Allow alphanumeric, hyphens, and underscores only
-        const validKeyRegex = /^[a-zA-Z0-9_-]+$/;
-        if (!validKeyRegex.test(key)) {
-            throw BlobError.invalidKey(key, 'Key must contain only alphanumeric characters, hyphens, and underscores');
-        }
-    }
-}

package/dist/agent/infra/llm/providers/google-vertex.d.ts

@@ -1,15 +0,0 @@
-/**
- * Google Vertex AI Provider Module
- *
- * Access Gemini models via Google Cloud Vertex AI using @ai-sdk/google-vertex.
- * Uses service account authentication (Application Default Credentials).
- *
- * Required env vars:
- * - GOOGLE_CLOUD_PROJECT (or GCP_PROJECT, GCLOUD_PROJECT)
- * - GOOGLE_APPLICATION_CREDENTIALS (path to service account JSON)
- *
- * Optional env vars:
- * - GOOGLE_CLOUD_LOCATION (defaults to us-central1)
- */
-import type { ProviderModule } from './types.js';
-export declare const googleVertexProvider: ProviderModule;

package/dist/agent/infra/llm/providers/google-vertex.js

@@ -1,36 +0,0 @@
-/**
- * Google Vertex AI Provider Module
- *
- * Access Gemini models via Google Cloud Vertex AI using @ai-sdk/google-vertex.
- * Uses service account authentication (Application Default Credentials).
- *
- * Required env vars:
- * - GOOGLE_CLOUD_PROJECT (or GCP_PROJECT, GCLOUD_PROJECT)
- * - GOOGLE_APPLICATION_CREDENTIALS (path to service account JSON)
- *
- * Optional env vars:
- * - GOOGLE_CLOUD_LOCATION (defaults to us-central1)
- */
-import { createVertex } from '@ai-sdk/google-vertex';
-import { AiSdkContentGenerator } from '../generators/ai-sdk-content-generator.js';
-export const googleVertexProvider = {
-    apiKeyUrl: 'https://console.cloud.google.com/iam-admin/serviceaccounts',
-    authType: 'service-account',
-    category: 'popular',
-    createGenerator(config) {
-        const provider = createVertex({
-            location: config.location ?? 'us-central1',
-            project: config.project,
-        });
-        return new AiSdkContentGenerator({
-            model: provider(config.model),
-        });
-    },
-    defaultModel: 'gemini-2.5-flash',
-    description: 'Gemini models via Google Cloud Vertex AI',
-    envVars: ['GOOGLE_APPLICATION_CREDENTIALS'],
-    id: 'google-vertex',
-    name: 'Google Vertex AI',
-    priority: 5,
-    providerType: 'gemini',
-};

package/dist/agent/infra/storage/blob-history-storage.d.ts

@@ -1,81 +0,0 @@
-import type { SessionMetadata } from '../../core/domain/storage/history-types.js';
-import type { IBlobStorage } from '../../core/interfaces/i-blob-storage.js';
-import type { IHistoryStorage } from '../../core/interfaces/i-history-storage.js';
-import type { InternalMessage } from '../../core/interfaces/message-types.js';
-/**
- * Blob-based implementation of history storage.
- *
- * Stores conversation history as JSON blobs in the file system.
- * Each session gets its own blob file at `.brv/blobs/session-{sessionId}.blob`.
- *
- * Follows the same pattern as MemoryManager for consistency.
- */
-export declare class BlobHistoryStorage implements IHistoryStorage {
-    private readonly blobStorage;
-    private static readonly SESSION_KEY_PREFIX;
-    /**
-     * Creates a new blob history storage instance.
-     *
-     * @param blobStorage - The blob storage backend to use
-     */
-    constructor(blobStorage: IBlobStorage);
-    /**
-     * Append a single message to the session history.
-     * For blob storage, this loads existing history, appends, and re-saves.
-     */
-    appendMessage(sessionId: string, message: InternalMessage): Promise<void>;
-    /**
-     * Delete all history for a specific session.
-     *
-     * @param sessionId - Unique session identifier
-     */
-    deleteHistory(sessionId: string): Promise<void>;
-    /**
-     * Check if history exists for a specific session.
-     *
-     * @param sessionId - Unique session identifier
-     * @returns True if history exists
-     */
-    exists(sessionId: string): Promise<boolean>;
-    /**
-     * Get metadata for a specific session without loading full history.
-     *
-     * @param sessionId - Unique session identifier
-     * @returns Session metadata or undefined if not found
-     */
-    getSessionMetadata(sessionId: string): Promise<SessionMetadata | undefined>;
-    /**
-     * List all session IDs that have persisted history.
-     *
-     * @returns Array of session IDs
-     */
-    listSessions(): Promise<string[]>;
-    /**
-     * Load conversation history for a specific session.
-     *
-     * @param sessionId - Unique session identifier
-     * @returns Array of messages, or undefined if session not found
-     */
-    loadHistory(sessionId: string): Promise<InternalMessage[] | undefined>;
-    /**
-     * Save conversation history for a specific session.
-     *
-     * @param sessionId - Unique session identifier
-     * @param messages - Array of messages to persist
-     */
-    saveHistory(sessionId: string, messages: InternalMessage[]): Promise<void>;
-    /**
-     * Extract session ID from storage key.
-     *
-     * @param key - Storage key (e.g., "session-abc123")
-     * @returns Session ID (e.g., "abc123") or undefined if invalid key
-     */
-    private extractSessionId;
-    /**
-     * Get storage key for a session.
-     *
-     * @param sessionId - Unique session identifier
-     * @returns Storage key (e.g., "session-abc123")
-     */
-    private getSessionKey;
-}

package/dist/agent/infra/storage/blob-history-storage.js

@@ -1,193 +0,0 @@
-/**
- * Blob-based implementation of history storage.
- *
- * Stores conversation history as JSON blobs in the file system.
- * Each session gets its own blob file at `.brv/blobs/session-{sessionId}.blob`.
- *
- * Follows the same pattern as MemoryManager for consistency.
- */
-export class BlobHistoryStorage {
-    blobStorage;
-    static SESSION_KEY_PREFIX = 'session-';
-    /**
-     * Creates a new blob history storage instance.
-     *
-     * @param blobStorage - The blob storage backend to use
-     */
-    constructor(blobStorage) {
-        this.blobStorage = blobStorage;
-    }
-    /**
-     * Append a single message to the session history.
-     * For blob storage, this loads existing history, appends, and re-saves.
-     */
-    async appendMessage(sessionId, message) {
-        try {
-            const existing = await this.loadHistory(sessionId);
-            const messages = existing ?? [];
-            messages.push(message);
-            await this.saveHistory(sessionId, messages);
-        }
-        catch (error) {
-            console.error(`[BlobHistoryStorage] Failed to append message for session ${sessionId}:`, error);
-        }
-    }
-    /**
-     * Delete all history for a specific session.
-     *
-     * @param sessionId - Unique session identifier
-     */
-    async deleteHistory(sessionId) {
-        const key = this.getSessionKey(sessionId);
-        try {
-            await this.blobStorage.delete(key);
-        }
-        catch (error) {
-            // Log error but don't throw - graceful degradation
-            console.error(`[BlobHistoryStorage] Failed to delete history for session ${sessionId}:`, error);
-        }
-    }
-    /**
-     * Check if history exists for a specific session.
-     *
-     * @param sessionId - Unique session identifier
-     * @returns True if history exists
-     */
-    async exists(sessionId) {
-        const key = this.getSessionKey(sessionId);
-        try {
-            return await this.blobStorage.exists(key);
-        }
-        catch (error) {
-            console.error(`[BlobHistoryStorage] Error checking existence for session ${sessionId}:`, error);
-            return false;
-        }
-    }
-    /**
-     * Get metadata for a specific session without loading full history.
-     *
-     * @param sessionId - Unique session identifier
-     * @returns Session metadata or undefined if not found
-     */
-    async getSessionMetadata(sessionId) {
-        const key = this.getSessionKey(sessionId);
-        try {
-            const blob = await this.blobStorage.retrieve(key);
-            if (!blob) {
-                return undefined;
-            }
-            // Parse JSON content to extract metadata
-            const historyData = JSON.parse(blob.content.toString('utf8'));
-            return {
-                createdAt: historyData.createdAt,
-                lastActivity: historyData.updatedAt,
-                messageCount: historyData.messageCount,
-                sessionId: historyData.sessionId,
-                title: historyData.metadata?.title,
-            };
-        }
-        catch (error) {
-            console.error(`[BlobHistoryStorage] Failed to get metadata for session ${sessionId}:`, error);
-            return undefined;
-        }
-    }
-    /**
-     * List all session IDs that have persisted history.
-     *
-     * @returns Array of session IDs
-     */
-    async listSessions() {
-        try {
-            const keys = await this.blobStorage.list(BlobHistoryStorage.SESSION_KEY_PREFIX);
-            // Extract session IDs from keys (remove prefix)
-            return keys.map(key => this.extractSessionId(key)).filter((id) => id !== undefined);
-        }
-        catch (error) {
-            console.error('[BlobHistoryStorage] Failed to list sessions:', error);
-            return [];
-        }
-    }
-    /**
-     * Load conversation history for a specific session.
-     *
-     * @param sessionId - Unique session identifier
-     * @returns Array of messages, or undefined if session not found
-     */
-    async loadHistory(sessionId) {
-        const key = this.getSessionKey(sessionId);
-        try {
-            const blob = await this.blobStorage.retrieve(key);
-            if (!blob) {
-                return undefined;
-            }
-            // Parse JSON content
-            const historyData = JSON.parse(blob.content.toString('utf8'));
-            // Removed verbose console.log for cleaner interactive UX
-            // console.log(`[BlobHistoryStorage] Loaded ${historyData.messages.length} messages for session ${sessionId}`)
-            return historyData.messages;
-        }
-        catch (error) {
-            console.error(`[BlobHistoryStorage] Failed to load history for session ${sessionId}:`, error);
-            return undefined;
-        }
-    }
-    /**
-     * Save conversation history for a specific session.
-     *
-     * @param sessionId - Unique session identifier
-     * @param messages - Array of messages to persist
-     */
-    async saveHistory(sessionId, messages) {
-        const key = this.getSessionKey(sessionId);
-        // Check if session already exists to preserve createdAt timestamp
-        const existingMetadata = await this.getSessionMetadata(sessionId);
-        // Build history data structure
-        const now = Date.now();
-        const historyData = {
-            createdAt: existingMetadata?.createdAt ?? now, // Preserve original creation time
-            messageCount: messages.length,
-            messages,
-            sessionId,
-            updatedAt: now,
-        };
-        try {
-            // Serialize to JSON with pretty-printing for inspectability
-            const content = JSON.stringify(historyData, null, 2);
-            // Store in blob storage
-            await this.blobStorage.store(key, content, {
-                contentType: 'application/json',
-                tags: {
-                    sessionId,
-                    type: 'chat-history',
-                },
-            });
-            // Removed verbose console.log for cleaner interactive UX
-            // console.log(`[BlobHistoryStorage] Saved ${messages.length} messages for session ${sessionId}`)
-        }
-        catch (error) {
-            // Log error but don't throw - graceful degradation
-            console.error(`[BlobHistoryStorage] Failed to save history for session ${sessionId}:`, error);
-        }
-    }
-    /**
-     * Extract session ID from storage key.
-     *
-     * @param key - Storage key (e.g., "session-abc123")
-     * @returns Session ID (e.g., "abc123") or undefined if invalid key
-     */
-    extractSessionId(key) {
-        if (!key.startsWith(BlobHistoryStorage.SESSION_KEY_PREFIX)) {
-            return undefined;
-        }
-        return key.slice(BlobHistoryStorage.SESSION_KEY_PREFIX.length);
-    }
-    /**
-     * Get storage key for a session.
-     *
-     * @param sessionId - Unique session identifier
-     * @returns Storage key (e.g., "session-abc123")
-     */
-    getSessionKey(sessionId) {
-        return `${BlobHistoryStorage.SESSION_KEY_PREFIX}${sessionId}`;
-    }
-}