byterover-cli 1.8.0 → 2.1.0

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

@@ -1,304 +0,0 @@
-import Database from 'better-sqlite3';
-import * as fs from 'node:fs/promises';
-import { 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 || 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
-            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/generators/openrouter-content-generator.d.ts

@@ -1,94 +0,0 @@
-/**
- * OpenRouter Content Generator.
- *
- * Implements IContentGenerator using OpenRouter API (OpenAI-compatible).
- * Supports various models available through OpenRouter.
- */
-import type { GenerateContentChunk, GenerateContentRequest, GenerateContentResponse, IContentGenerator } from '../../../core/interfaces/i-content-generator.js';
-/**
- * Configuration for OpenRouter Content Generator.
- */
-export interface OpenRouterContentGeneratorConfig {
-    /** OpenRouter API key */
-    apiKey: string;
-    /** Base URL for OpenRouter API */
-    baseUrl?: string;
-    /** HTTP Referer header for OpenRouter */
-    httpReferer?: string;
-    /** Maximum tokens in the response */
-    maxTokens?: number;
-    /** Model identifier */
-    model?: string;
-    /** Site name for X-Title header */
-    siteName?: string;
-    /** Temperature for randomness */
-    temperature?: number;
-    /** Request timeout in milliseconds */
-    timeout?: number;
-}
-/**
- * OpenRouter Content Generator.
- *
- * Wraps OpenAI client configured for OpenRouter and implements IContentGenerator.
- * Provides:
- * - Non-streaming content generation
- * - Streaming content generation (true streaming via OpenAI SDK)
- * - Token estimation
- */
-export declare class OpenRouterContentGenerator implements IContentGenerator {
-    private readonly client;
-    private readonly config;
-    private readonly formatter;
-    private readonly tokenizer;
-    /**
-     * Create a new OpenRouter Content Generator.
-     *
-     * @param config - Generator configuration
-     */
-    constructor(config: OpenRouterContentGeneratorConfig);
-    /**
-     * Estimate tokens synchronously using character-based approximation.
-     *
-     * @param content - Text to estimate tokens for
-     * @returns Estimated token count
-     */
-    estimateTokensSync(content: string): number;
-    /**
-     * Generate content (non-streaming).
-     *
-     * @param request - Generation request
-     * @returns Generated content response
-     */
-    generateContent(request: GenerateContentRequest): Promise<GenerateContentResponse>;
-    /**
-     * Generate content with streaming.
-     *
-     * Uses OpenAI SDK's native streaming support for real-time content generation.
-     * Includes rawChunk for native reasoning extraction by the stream transformer.
-     *
-     * @param request - Generation request
-     * @yields Content chunks as they are generated
-     * @returns Async generator yielding content chunks
-     */
-    generateContentStream(request: GenerateContentRequest): AsyncGenerator<GenerateContentChunk>;
-    /**
-     * Build tool calls array from accumulated tool calls.
-     */
-    private buildToolCallsArray;
-    /**
-     * Build tools array from ToolSet.
-     */
-    private buildTools;
-    /**
-     * Determine finish reason from OpenAI finish reason.
-     */
-    private determineFinishReason;
-    /**
-     * Extract text content from an internal message.
-     */
-    private extractTextContent;
-    /**
-     * Process tool call deltas and accumulate them.
-     */
-    private processToolCallDeltas;
-}

package/dist/agent/infra/llm/generators/openrouter-content-generator.js

@@ -1,280 +0,0 @@
-/**
- * OpenRouter Content Generator.
- *
- * Implements IContentGenerator using OpenRouter API (OpenAI-compatible).
- * Supports various models available through OpenRouter.
- */
-import { OpenAI } from 'openai';
-import { OpenRouterMessageFormatter } from '../formatters/openrouter-formatter.js';
-import { OpenRouterTokenizer } from '../tokenizers/openrouter-tokenizer.js';
-/**
- * OpenRouter Content Generator.
- *
- * Wraps OpenAI client configured for OpenRouter and implements IContentGenerator.
- * Provides:
- * - Non-streaming content generation
- * - Streaming content generation (true streaming via OpenAI SDK)
- * - Token estimation
- */
-export class OpenRouterContentGenerator {
-    client;
-    config;
-    formatter;
-    tokenizer;
-    /**
-     * Create a new OpenRouter Content Generator.
-     *
-     * @param config - Generator configuration
-     */
-    constructor(config) {
-        this.config = {
-            maxTokens: config.maxTokens ?? 8192,
-            model: config.model ?? 'anthropic/claude-haiku-4.5',
-            temperature: config.temperature ?? 0.7,
-        };
-        // Initialize OpenAI client with OpenRouter base URL
-        this.client = new OpenAI({
-            apiKey: config.apiKey,
-            baseURL: config.baseUrl ?? 'https://openrouter.ai/api/v1',
-            defaultHeaders: {
-                ...(config.httpReferer && { 'HTTP-Referer': config.httpReferer }),
-                ...(config.siteName && { 'X-Title': config.siteName }),
-            },
-            timeout: config.timeout,
-        });
-        // Initialize formatter and tokenizer
-        this.formatter = new OpenRouterMessageFormatter();
-        this.tokenizer = new OpenRouterTokenizer();
-    }
-    /**
-     * Estimate tokens synchronously using character-based approximation.
-     *
-     * @param content - Text to estimate tokens for
-     * @returns Estimated token count
-     */
-    estimateTokensSync(content) {
-        return this.tokenizer.countTokens(content);
-    }
-    /**
-     * Generate content (non-streaming).
-     *
-     * @param request - Generation request
-     * @returns Generated content response
-     */
-    async generateContent(request) {
-        // Format messages for OpenAI/OpenRouter
-        const formattedMessages = this.formatter.format(request.contents);
-        // Build tools array
-        const tools = this.buildTools(request.tools ?? {});
-        // Build messages with system prompt
-        const messages = request.systemPrompt
-            ? [{ content: request.systemPrompt, role: 'system' }, ...formattedMessages]
-            : formattedMessages;
-        // Call OpenRouter API
-        const rawResponse = await this.client.chat.completions.create({
-            // eslint-disable-next-line camelcase
-            max_tokens: request.config.maxTokens ?? this.config.maxTokens,
-            messages,
-            model: request.model ?? this.config.model,
-            temperature: request.config.temperature ?? this.config.temperature,
-            ...(tools.length > 0 && { tools: tools }),
-        });
-        // Parse response to internal format
-        const parsedMessages = this.formatter.parseResponse(rawResponse);
-        const lastMessage = parsedMessages.at(-1);
-        if (!lastMessage) {
-            return {
-                content: '',
-                finishReason: 'error',
-                rawResponse,
-                toolCalls: [],
-            };
-        }
-        // Extract content and tool calls
-        const content = this.extractTextContent(lastMessage);
-        const toolCalls = lastMessage.toolCalls ?? [];
-        // Determine finish reason
-        let finishReason = 'stop';
-        if (toolCalls.length > 0) {
-            finishReason = 'tool_calls';
-        }
-        else if (rawResponse.choices[0]?.finish_reason === 'length') {
-            finishReason = 'max_tokens';
-        }
-        // Extract usage if available
-        const usage = rawResponse.usage
-            ? {
-                completionTokens: rawResponse.usage.completion_tokens,
-                promptTokens: rawResponse.usage.prompt_tokens,
-                totalTokens: rawResponse.usage.total_tokens,
-            }
-            : undefined;
-        return {
-            content,
-            finishReason,
-            rawResponse,
-            toolCalls,
-            usage,
-        };
-    }
-    /**
-     * Generate content with streaming.
-     *
-     * Uses OpenAI SDK's native streaming support for real-time content generation.
-     * Includes rawChunk for native reasoning extraction by the stream transformer.
-     *
-     * @param request - Generation request
-     * @yields Content chunks as they are generated
-     * @returns Async generator yielding content chunks
-     */
-    async *generateContentStream(request) {
-        // Format messages for OpenAI/OpenRouter
-        const formattedMessages = this.formatter.format(request.contents);
-        // Build tools array
-        const tools = this.buildTools(request.tools ?? {});
-        // Build messages with system prompt
-        const messages = request.systemPrompt
-            ? [{ content: request.systemPrompt, role: 'system' }, ...formattedMessages]
-            : formattedMessages;
-        // Call OpenRouter API with streaming
-        const stream = await this.client.chat.completions.create({
-            // eslint-disable-next-line camelcase
-            max_tokens: request.config.maxTokens ?? this.config.maxTokens,
-            messages,
-            model: request.model ?? this.config.model,
-            stream: true,
-            temperature: request.config.temperature ?? this.config.temperature,
-            ...(tools.length > 0 && { tools: tools }),
-        });
-        // Accumulate tool calls across chunks
-        const accumulatedToolCalls = new Map();
-        // Stream chunks
-        for await (const chunk of stream) {
-            const choice = chunk.choices[0];
-            if (!choice)
-                continue;
-            const { delta } = choice;
-            // Handle tool call deltas
-            if (delta.tool_calls) {
-                this.processToolCallDeltas(delta.tool_calls, accumulatedToolCalls);
-            }
-            // Yield content chunk
-            const isComplete = choice.finish_reason !== null;
-            const finishReason = this.determineFinishReason(choice.finish_reason, isComplete);
-            const toolCalls = this.buildToolCallsArray(accumulatedToolCalls, isComplete);
-            // Extract native reasoning fields if present (for OpenAI o1/o3, Grok, Gemini)
-            // Different providers return reasoning differently:
-            // - OpenAI: delta.reasoning
-            // - Grok: delta.reasoning_content or delta.reasoning_details
-            // - Gemini via OpenRouter: delta.reasoning_details array with {type: 'reasoning.text', text: '...'}
-            // The rawChunk allows the stream transformer to extract reasoning using model-specific logic
-            const deltaAny = delta;
-            // Check for standard reasoning fields first
-            let reasoning = (deltaAny.reasoning ?? deltaAny.reasoning_content ?? deltaAny.thoughts);
-            // Check for OpenRouter's reasoning_details array format (used for Gemini and some other models)
-            if (!reasoning && deltaAny.reasoning_details) {
-                const details = deltaAny.reasoning_details;
-                if (Array.isArray(details)) {
-                    const reasoningText = details
-                        .filter((d) => d.type === 'reasoning.text' && d.text)
-                        .map((d) => d.text)
-                        .join('');
-                    if (reasoningText) {
-                        reasoning = reasoningText;
-                    }
-                }
-            }
-            yield {
-                content: delta.content ?? undefined,
-                finishReason,
-                isComplete,
-                rawChunk: chunk,
-                reasoning,
-                reasoningId: reasoning ? chunk.id : undefined,
-                toolCalls,
-            };
-        }
-    }
-    /**
-     * Build tool calls array from accumulated tool calls.
-     */
-    buildToolCallsArray(accumulatedToolCalls, isComplete) {
-        if (!isComplete || accumulatedToolCalls.size === 0) {
-            return undefined;
-        }
-        return [...accumulatedToolCalls.values()].map((tc) => ({
-            function: {
-                arguments: tc.arguments,
-                name: tc.name,
-            },
-            id: tc.id,
-            type: 'function',
-        }));
-    }
-    /**
-     * Build tools array from ToolSet.
-     */
-    buildTools(tools) {
-        return Object.entries(tools).map(([name, schema]) => ({
-            function: {
-                description: schema.description ?? '',
-                name,
-                parameters: schema.parameters,
-            },
-            type: 'function',
-        }));
-    }
-    /**
-     * Determine finish reason from OpenAI finish reason.
-     */
-    determineFinishReason(finishReason, isComplete) {
-        if (!isComplete) {
-            return undefined;
-        }
-        if (finishReason === 'tool_calls') {
-            return 'tool_calls';
-        }
-        if (finishReason === 'length') {
-            return 'max_tokens';
-        }
-        return 'stop';
-    }
-    /**
-     * Extract text content from an internal message.
-     */
-    extractTextContent(message) {
-        if (typeof message.content === 'string') {
-            return message.content;
-        }
-        if (Array.isArray(message.content)) {
-            return message.content
-                .filter((part) => part.type === 'text')
-                .map((part) => (part.type === 'text' ? part.text : ''))
-                .join('');
-        }
-        return '';
-    }
-    /**
-     * Process tool call deltas and accumulate them.
-     */
-    processToolCallDeltas(toolCallDeltas, accumulatedToolCalls) {
-        for (const toolCallDelta of toolCallDeltas) {
-            const { function: func, id, index } = toolCallDelta;
-            const existing = accumulatedToolCalls.get(index);
-            if (existing) {
-                // Append to existing tool call
-                if (func?.arguments) {
-                    existing.arguments += func.arguments;
-                }
-            }
-            else {
-                // Start new tool call
-                accumulatedToolCalls.set(index, {
-                    arguments: func?.arguments ?? '',
-                    id: id ?? `tool_${index}`,
-                    name: func?.name ?? '',
-                });
-            }
-        }
-    }
-}