byterover-cli 1.6.0 → 1.7.0

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

@@ -1,307 +0,0 @@
-import Database from 'better-sqlite3';
-import * as fs from 'node:fs/promises';
-import { join } from 'node:path';
-import { BlobError } from '../../../core/domain/cipher/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 || join(process.cwd(), '.brv');
-        this.dbPath = this.inMemory ? ':memory:' : 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 storage directory exists (skip for in-memory)
-            if (!this.inMemory) {
-                await fs.mkdir(this.storageDir, { 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
-            const appliedCount = runMigrations(this.db, this.logger);
-            if (appliedCount > 0) {
-                this.logger.info(`💾 Initializing storage...`);
-            }
-            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/infra/cipher/display/todo-display.d.ts

@@ -1,23 +0,0 @@
-import type { Todo } from '../../../core/domain/cipher/todos/types.js';
-/**
- * Formats a single todo item for display.
- *
- * @param todo - Todo item to format
- * @param index - 1-based index of the todo
- * @returns Formatted todo string
- */
-export declare function formatTodoItem(todo: Todo, index: number): string;
-/**
- * Formats the entire todo list for display.
- *
- * @param todos - Array of todos to format
- * @returns Formatted todo list string
- */
-export declare function formatTodoList(todos: Todo[]): string;
-/**
- * Formats a compact status line for the current task.
- *
- * @param todos - Array of todos
- * @returns Status line string or null if no task in progress
- */
-export declare function formatCurrentTaskStatus(todos: Todo[]): null | string;

package/dist/infra/cipher/events/event-emitter.d.ts

@@ -1,137 +0,0 @@
-import { EventEmitter } from 'node:events';
-import type { AgentEventMap, SessionEventMap } from '../../../core/domain/cipher/agent-events/types.js';
-import type { EventListenerOptions, IEventEmitter } from '../../../core/interfaces/cipher/i-event-emitter.js';
-/**
- * Base implementation of a type-safe event emitter.
- *
- * Extends Node.js EventEmitter with TypeScript type safety and AbortController support.
- * This follows the pattern from Dexto's event system.
- *
- * Features:
- * - Type-safe emit/on/once/off methods
- * - AbortController integration for automatic listener cleanup
- * - Proper handling of void payloads
- * - WeakMap-based tracking for signal-listener associations
- *
- * @template TEventMap - Map of event names to their payload types
- *
- * @example
- * ```typescript
- * interface MyEvents {
- *   'data:received': { value: number };
- *   'data:cleared': void;
- * }
- *
- * class MyEventBus extends BaseTypedEventEmitter<MyEvents> {}
- *
- * const bus = new MyEventBus();
- * bus.emit('data:received', { value: 42 });
- * bus.emit('data:cleared');
- *
- * // With AbortController
- * const controller = new AbortController();
- * bus.on('data:received', (data) => console.log(data.value), { signal: controller.signal });
- * controller.abort(); // Automatically removes listener
- * ```
- */
-export declare class BaseTypedEventEmitter<TEventMap extends object> extends EventEmitter implements IEventEmitter<TEventMap> {
-    /**
-     * WeakMap tracking AbortSignal → Set<listener function>.
-     * Used to automatically remove listeners when signals are aborted.
-     */
-    private readonly signalListeners;
-    /**
-     * Emit an event with optional payload.
-     *
-     * @param eventName - Name of the event to emit
-     * @param payload - Event payload (omit for void events)
-     * @returns true if the event had listeners, false otherwise
-     */
-    emit<K extends keyof TEventMap>(eventName: K, ...payload: TEventMap[K] extends void ? [] : [TEventMap[K]]): boolean;
-    emit(eventName: string, ...args: never[]): boolean;
-    /**
-     * Remove an event listener.
-     *
-     * @param eventName - Name of the event
-     * @param listener - Callback function to remove
-     * @returns this (for chaining)
-     */
-    off<K extends keyof TEventMap>(eventName: K, listener: TEventMap[K] extends void ? () => void : (payload: TEventMap[K]) => void): this;
-    off(eventName: string | symbol, listener: (data?: unknown) => void): this;
-    /**
-     * Register an event listener.
-     *
-     * @param eventName - Name of the event to listen for
-     * @param listener - Callback function
-     * @param options - Optional AbortSignal for automatic cleanup
-     * @returns this (for chaining)
-     */
-    on<K extends keyof TEventMap>(eventName: K, listener: TEventMap[K] extends void ? () => void : (payload: TEventMap[K]) => void, options?: EventListenerOptions): this;
-    on(eventName: string | symbol, listener: (data?: unknown) => void): this;
-    /**
-     * Register a one-time event listener.
-     *
-     * @param eventName - Name of the event to listen for
-     * @param listener - Callback function
-     * @param options - Optional AbortSignal for automatic cleanup
-     * @returns this (for chaining)
-     */
-    once<K extends keyof TEventMap>(eventName: K, listener: TEventMap[K] extends void ? () => void : (payload: TEventMap[K]) => void, options?: EventListenerOptions): this;
-    once(eventName: string | symbol, listener: (data?: unknown) => void): this;
-    /**
-     * Setup automatic cleanup when AbortSignal fires.
-     *
-     * @param eventName - Event name
-     * @param listener - Listener function to remove
-     * @param signal - AbortSignal to watch
-     */
-    private setupAbortCleanup;
-}
-/**
- * Event bus for agent-level events.
- *
- * Handles global agent events like state changes, conversation resets, etc.
- * All events include sessionId to track which session triggered the event.
- *
- * @example
- * ```typescript
- * const agentBus = new AgentEventBus();
- *
- * agentBus.on('cipher:stateChanged', (payload) => {
- *   console.log(`State changed: ${payload.field} in session ${payload.sessionId}`);
- * });
- *
- * agentBus.emit('cipher:stateChanged', {
- *   field: 'model',
- *   newValue: 'gemini-2.5-flash',
- *   sessionId: 'session-123'
- * });
- * ```
- */
-export declare class AgentEventBus extends BaseTypedEventEmitter<AgentEventMap> {
-}
-/**
- * Event bus for session-level events.
- *
- * Handles session-scoped events like LLM thinking, tool calls, responses, etc.
- * Events do not include sessionId as they are already scoped to a specific session.
- *
- * Typically, these events are forwarded to the AgentEventBus with sessionId added.
- *
- * @example
- * ```typescript
- * const sessionBus = new SessionEventBus();
- *
- * sessionBus.on('llmservice:toolCall', (payload) => {
- *   console.log(`Tool call: ${payload.toolName}`);
- * });
- *
- * sessionBus.emit('llmservice:toolCall', {
- *   toolName: 'read_file',
- *   args: { filePath: '/path/to/file' },
- *   callId: 'call-456'
- * });
- * ```
- */
-export declare class SessionEventBus extends BaseTypedEventEmitter<SessionEventMap> {
-}

package/dist/infra/cipher/file-system/binary-utils.d.ts

@@ -1,51 +0,0 @@
-/**
- * Checks if a file is binary based on extension and content analysis.
- *
- * Detection strategy:
- * 1. Fast path: Check against known binary extensions
- * 2. Check for null bytes (definitive binary indicator)
- * 3. UTF-8 aware: Check for invalid UTF-8 sequences (replacement character)
- * 4. Heuristic: Check for excessive control characters
- *
- * @param filePath - Path to the file (used for extension check)
- * @param buffer - Buffer containing first N bytes of the file
- * @returns true if the file is binary, false otherwise
- */
-export declare function isBinaryFile(filePath: string, buffer: Buffer): boolean;
-/**
- * Checks if a file is an image based on its extension.
- * SVG files are excluded as they are text-based.
- *
- * @param filePath - Path to the file
- * @returns true if the file is an image (excluding SVG)
- */
-export declare function isImageFile(filePath: string): boolean;
-/**
- * Checks if a file is a PDF. When buffer is provided, validates magic bytes (%PDF-).
- * Searches within first 1KB to handle PDFs with leading whitespace/comments.
- */
-export declare function isPdfFile(filePath: string, buffer?: Buffer): boolean;
-/**
- * Gets the MIME type for an image or PDF file.
- *
- * @param filePath - Path to the file
- * @returns MIME type string, or null if not a recognized image/PDF
- */
-export declare function getMimeType(filePath: string): null | string;
-/**
- * Checks if a file is a media file (only images supported at this point). PDFs are handled separately.
- * @param filePath - Path to the file
- */
-export declare function isMediaFile(filePath: string): boolean;
-/**
- * Determines if a file should be returned as a base64 attachment.
- *
- * - Images: Always returned as attachment
- * - PDFs: Depends on pdfMode ('base64' = attachment, 'text' = extract text)
- * - Other files: Never returned as attachment
- *
- * @param filePath - Path to the file
- * @param pdfMode - PDF read mode ('text' | 'base64'), defaults to 'text'
- * @returns true if file should be returned as base64 attachment
- */
-export declare function shouldReturnAsAttachment(filePath: string, pdfMode?: 'base64' | 'text'): boolean;