byterover-cli 0.2.1 → 0.3.1

package/dist/infra/cipher/llm/generators/byterover-content-generator.js

@@ -0,0 +1,211 @@
+/**
+ * ByteRover Content Generator.
+ *
+ * Implements IContentGenerator using ByteRover gRPC service.
+ * Supports both Claude and Gemini models through the unified gRPC interface.
+ */
+import { ClaudeMessageFormatter } from '../formatters/claude-formatter.js';
+import { GeminiMessageFormatter } from '../formatters/gemini-formatter.js';
+import { ThinkingConfigManager } from '../thought-parser.js';
+import { ClaudeTokenizer } from '../tokenizers/claude-tokenizer.js';
+import { GeminiTokenizer } from '../tokenizers/gemini-tokenizer.js';
+/**
+ * ByteRover Content Generator.
+ *
+ * Wraps ByteRoverLlmGrpcService and implements IContentGenerator.
+ * Handles:
+ * - Provider detection (Claude vs Gemini)
+ * - Message formatting via provider-specific formatters
+ * - Token estimation via provider-specific tokenizers
+ * - Response parsing to unified format
+ */
+export class ByteRoverContentGenerator {
+    config;
+    formatter;
+    grpcService;
+    providerType;
+    tokenizer;
+    /**
+     * Create a new ByteRover Content Generator.
+     *
+     * @param grpcService - Configured gRPC service for LLM API calls
+     * @param config - Generator configuration
+     */
+    constructor(grpcService, config) {
+        this.grpcService = grpcService;
+        this.config = {
+            maxTokens: config.maxTokens ?? 8192,
+            model: config.model,
+            temperature: config.temperature ?? 0.7,
+            thinkingConfig: config.thinkingConfig,
+        };
+        // Detect provider type from model name
+        this.providerType = this.detectProviderType(this.config.model);
+        // Initialize formatter and tokenizer based on provider type
+        if (this.providerType === 'claude') {
+            this.formatter = new ClaudeMessageFormatter();
+            this.tokenizer = new ClaudeTokenizer(this.config.model);
+        }
+        else {
+            this.formatter = new GeminiMessageFormatter();
+            this.tokenizer = new GeminiTokenizer(this.config.model);
+        }
+    }
+    /**
+     * 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 provider
+        const formattedMessages = this.formatter.format(request.contents);
+        // Build generation config
+        const genConfig = this.buildGenerationConfig(request.tools ?? {}, request.systemPrompt ?? '', formattedMessages);
+        // Call gRPC service
+        const contents = this.providerType === 'claude' ? genConfig : formattedMessages;
+        const config = this.providerType === 'claude' ? {} : genConfig;
+        // Build execution metadata from request
+        const executionMetadata = {
+            sessionId: request.sessionId,
+            ...(request.mode && { mode: request.mode }),
+            ...(request.executionContext && { executionContext: request.executionContext }),
+        };
+        const rawResponse = await this.grpcService.generateContent(contents, config, this.config.model, executionMetadata);
+        // Parse response to internal format
+        const messages = this.formatter.parseResponse(rawResponse);
+        const lastMessage = messages.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';
+        }
+        return {
+            content,
+            finishReason,
+            rawResponse,
+            toolCalls,
+        };
+    }
+    /**
+     * Generate content with streaming.
+     *
+     * Note: The current gRPC service collects all chunks before returning.
+     * This implementation yields the complete response as a single chunk.
+     * True streaming can be implemented when the gRPC service exposes the stream.
+     *
+     * @param request - Generation request
+     * @yields Content chunks as they are generated
+     * @returns Async generator yielding content chunks
+     */
+    async *generateContentStream(request) {
+        // For now, use non-streaming and yield complete response
+        // True streaming can be added when gRPC service exposes the stream
+        const response = await this.generateContent(request);
+        yield {
+            content: response.content,
+            finishReason: response.finishReason,
+            isComplete: true,
+            toolCalls: response.toolCalls,
+        };
+    }
+    /**
+     * Build Claude-specific generation configuration.
+     */
+    buildClaudeConfig(tools, systemPrompt, messages) {
+        /* eslint-disable camelcase */
+        const claudeTools = Object.entries(tools).map(([name, schema]) => ({
+            description: schema.description ?? '',
+            input_schema: schema.parameters,
+            name,
+        }));
+        return {
+            max_tokens: this.config.maxTokens,
+            messages,
+            model: this.config.model,
+            system: systemPrompt,
+            temperature: this.config.temperature,
+            ...(claudeTools.length > 0 && { tools: claudeTools }),
+        };
+        /* eslint-enable camelcase */
+    }
+    /**
+     * Build Gemini-specific generation configuration.
+     */
+    buildGeminiConfig(tools, systemPrompt) {
+        const toolDefinitions = Object.entries(tools).map(([name, schema]) => ({
+            description: schema.description ?? '',
+            name,
+            parameters: schema.parameters,
+        }));
+        const baseConfig = {
+            maxOutputTokens: this.config.maxTokens,
+            temperature: this.config.temperature,
+            topP: 1,
+            ...(systemPrompt && { systemInstruction: { parts: [{ text: systemPrompt }] } }),
+            ...(toolDefinitions.length > 0 && {
+                tools: [
+                    {
+                        functionDeclarations: toolDefinitions,
+                    },
+                ],
+            }),
+        };
+        // Add thinking configuration for Gemini models
+        const thinkingConfig = ThinkingConfigManager.mergeConfig(this.config.model, this.config.thinkingConfig);
+        if (thinkingConfig) {
+            baseConfig.thinkingConfig = thinkingConfig;
+        }
+        return baseConfig;
+    }
+    /**
+     * Build generation config for the appropriate provider.
+     */
+    buildGenerationConfig(tools, systemPrompt, messages) {
+        if (this.providerType === 'claude') {
+            return this.buildClaudeConfig(tools, systemPrompt, messages);
+        }
+        return this.buildGeminiConfig(tools, systemPrompt);
+    }
+    /**
+     * Detect provider type from model name.
+     */
+    detectProviderType(model) {
+        return model.toLowerCase().startsWith('claude') ? 'claude' : 'gemini';
+    }
+    /**
+     * 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 '';
+    }
+}

package/dist/infra/cipher/llm/generators/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Content Generator exports.
+ *
+ * This module provides content generators implementing IContentGenerator:
+ * - ByteRoverContentGenerator: Uses ByteRover gRPC service
+ * - OpenRouterContentGenerator: Uses OpenRouter API (OpenAI-compatible)
+ * - LoggingContentGenerator: Decorator for debug logging
+ * - RetryableContentGenerator: Decorator for retry with backoff
+ */
+export { ByteRoverContentGenerator, type ByteRoverContentGeneratorConfig } from './byterover-content-generator.js';
+export { LoggingContentGenerator, type LoggingOptions } from './logging-content-generator.js';
+export { OpenRouterContentGenerator, type OpenRouterContentGeneratorConfig } from './openrouter-content-generator.js';
+export { RetryableContentGenerator, type RetryableOptions } from './retryable-content-generator.js';

package/dist/infra/cipher/llm/generators/index.js

@@ -0,0 +1,13 @@
+/**
+ * Content Generator exports.
+ *
+ * This module provides content generators implementing IContentGenerator:
+ * - ByteRoverContentGenerator: Uses ByteRover gRPC service
+ * - OpenRouterContentGenerator: Uses OpenRouter API (OpenAI-compatible)
+ * - LoggingContentGenerator: Decorator for debug logging
+ * - RetryableContentGenerator: Decorator for retry with backoff
+ */
+export { ByteRoverContentGenerator } from './byterover-content-generator.js';
+export { LoggingContentGenerator } from './logging-content-generator.js';
+export { OpenRouterContentGenerator } from './openrouter-content-generator.js';
+export { RetryableContentGenerator } from './retryable-content-generator.js';

package/dist/infra/cipher/llm/generators/logging-content-generator.d.ts

@@ -0,0 +1,104 @@
+/**
+ * Logging Content Generator Decorator.
+ *
+ * Wraps any IContentGenerator to add debug logging capabilities.
+ * Logs request/response metadata, timing, and errors.
+ */
+import type { GenerateContentChunk, GenerateContentRequest, GenerateContentResponse, IContentGenerator } from '../../../../core/interfaces/cipher/i-content-generator.js';
+import type { SessionEventBus } from '../../events/event-emitter.js';
+/**
+ * Logging options for the decorator.
+ */
+export interface LoggingOptions {
+    /** Log individual streaming chunks */
+    logChunks?: boolean;
+    /** Log request details */
+    logRequests?: boolean;
+    /** Log response details */
+    logResponses?: boolean;
+    /** Enable verbose logging (all options) */
+    verbose?: boolean;
+}
+/**
+ * Logging Content Generator.
+ *
+ * Decorator that wraps any IContentGenerator to add logging capabilities.
+ * Useful for debugging, monitoring, and performance analysis.
+ *
+ * Features:
+ * - Request/response logging with configurable verbosity
+ * - Timing information for all operations
+ * - Error logging with context
+ * - Event emission via SessionEventBus
+ */
+export declare class LoggingContentGenerator implements IContentGenerator {
+    private readonly eventBus?;
+    private readonly inner;
+    private readonly options;
+    /**
+     * Create a new Logging Content Generator.
+     *
+     * @param inner - The wrapped content generator
+     * @param eventBus - Optional event bus for emitting events
+     * @param options - Logging options
+     */
+    constructor(inner: IContentGenerator, eventBus?: SessionEventBus, options?: LoggingOptions);
+    /**
+     * Estimate tokens (delegates to inner generator).
+     *
+     * @param content - Text to estimate tokens for
+     * @returns Estimated token count
+     */
+    estimateTokensSync(content: string): number;
+    /**
+     * Generate content with logging.
+     *
+     * @param request - Generation request
+     * @returns Generated content response
+     */
+    generateContent(request: GenerateContentRequest): Promise<GenerateContentResponse>;
+    /**
+     * Generate content with streaming and logging.
+     *
+     * @param request - Generation request
+     * @yields Content chunks as they are generated
+     * @returns Async generator yielding content chunks
+     */
+    generateContentStream(request: GenerateContentRequest): AsyncGenerator<GenerateContentChunk>;
+    /**
+     * Generate a unique request ID for tracking.
+     */
+    private generateRequestId;
+    /**
+     * Log a streaming chunk.
+     */
+    private logChunk;
+    /**
+     * Log an error that occurred during generation.
+     */
+    private logError;
+    /**
+     * Log a generation request.
+     */
+    private logRequest;
+    /**
+     * Log a generation response.
+     */
+    private logResponse;
+    /**
+     * Log streaming completion.
+     */
+    private logStreamComplete;
+    /**
+     * Check if chunks should be logged.
+     */
+    private shouldLogChunks;
+    /**
+     * Check if requests should be logged.
+     */
+    private shouldLogRequests;
+    /**
+     * Check if responses should be logged.
+     */
+    private shouldLogResponses;
+}

package/dist/infra/cipher/llm/generators/logging-content-generator.js

@@ -0,0 +1,182 @@
+/**
+ * Logging Content Generator Decorator.
+ *
+ * Wraps any IContentGenerator to add debug logging capabilities.
+ * Logs request/response metadata, timing, and errors.
+ */
+/**
+ * Logging Content Generator.
+ *
+ * Decorator that wraps any IContentGenerator to add logging capabilities.
+ * Useful for debugging, monitoring, and performance analysis.
+ *
+ * Features:
+ * - Request/response logging with configurable verbosity
+ * - Timing information for all operations
+ * - Error logging with context
+ * - Event emission via SessionEventBus
+ */
+export class LoggingContentGenerator {
+    eventBus;
+    inner;
+    options;
+    /**
+     * Create a new Logging Content Generator.
+     *
+     * @param inner - The wrapped content generator
+     * @param eventBus - Optional event bus for emitting events
+     * @param options - Logging options
+     */
+    constructor(inner, eventBus, options = {}) {
+        this.inner = inner;
+        this.eventBus = eventBus;
+        this.options = options;
+    }
+    /**
+     * Estimate tokens (delegates to inner generator).
+     *
+     * @param content - Text to estimate tokens for
+     * @returns Estimated token count
+     */
+    estimateTokensSync(content) {
+        return this.inner.estimateTokensSync(content);
+    }
+    /**
+     * Generate content with logging.
+     *
+     * @param request - Generation request
+     * @returns Generated content response
+     */
+    async generateContent(request) {
+        const startTime = Date.now();
+        const requestId = this.generateRequestId();
+        this.logRequest(requestId, request);
+        this.eventBus?.emit('llmservice:thinking');
+        try {
+            const response = await this.inner.generateContent(request);
+            this.logResponse(requestId, response, Date.now() - startTime);
+            return response;
+        }
+        catch (error) {
+            this.logError(requestId, error, Date.now() - startTime);
+            throw error;
+        }
+    }
+    /**
+     * Generate content with streaming and logging.
+     *
+     * @param request - Generation request
+     * @yields Content chunks as they are generated
+     * @returns Async generator yielding content chunks
+     */
+    async *generateContentStream(request) {
+        const startTime = Date.now();
+        const requestId = this.generateRequestId();
+        this.logRequest(requestId, request);
+        this.eventBus?.emit('llmservice:thinking');
+        try {
+            let chunkCount = 0;
+            let totalContentLength = 0;
+            for await (const chunk of this.inner.generateContentStream(request)) {
+                chunkCount++;
+                if (chunk.content) {
+                    totalContentLength += chunk.content.length;
+                }
+                if (this.shouldLogChunks()) {
+                    this.logChunk(requestId, chunk, chunkCount);
+                }
+                yield chunk;
+            }
+            this.logStreamComplete(requestId, chunkCount, totalContentLength, Date.now() - startTime);
+        }
+        catch (error) {
+            this.logError(requestId, error, Date.now() - startTime);
+            throw error;
+        }
+    }
+    /**
+     * Generate a unique request ID for tracking.
+     */
+    generateRequestId() {
+        return Math.random().toString(36).slice(2, 8);
+    }
+    /**
+     * Log a streaming chunk.
+     */
+    logChunk(requestId, chunk, index) {
+        console.debug(`[LLM:${requestId}] Chunk #${index}`, {
+            contentLength: chunk.content?.length ?? 0,
+            finishReason: chunk.finishReason,
+            hasToolCalls: Boolean(chunk.toolCalls?.length),
+            isComplete: chunk.isComplete,
+        });
+    }
+    /**
+     * Log an error that occurred during generation.
+     */
+    logError(requestId, error, durationMs) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        console.error(`[LLM:${requestId}] Error after ${durationMs}ms:`, errorMessage);
+        this.eventBus?.emit('llmservice:error', {
+            error: errorMessage,
+        });
+    }
+    /**
+     * Log a generation request.
+     */
+    logRequest(requestId, request) {
+        if (!this.shouldLogRequests()) {
+            return;
+        }
+        console.debug(`[LLM:${requestId}] Request`, {
+            hasSystemPrompt: Boolean(request.systemPrompt),
+            hasTools: Boolean(request.tools && Object.keys(request.tools).length > 0),
+            maxTokens: request.config.maxTokens,
+            messageCount: request.contents.length,
+            model: request.model,
+            temperature: request.config.temperature,
+            toolCount: request.tools ? Object.keys(request.tools).length : 0,
+        });
+    }
+    /**
+     * Log a generation response.
+     */
+    logResponse(requestId, response, durationMs) {
+        if (!this.shouldLogResponses()) {
+            return;
+        }
+        console.debug(`[LLM:${requestId}] Response in ${durationMs}ms`, {
+            contentLength: response.content.length,
+            finishReason: response.finishReason,
+            toolCalls: response.toolCalls?.length ?? 0,
+            usage: response.usage,
+        });
+    }
+    /**
+     * Log streaming completion.
+     */
+    logStreamComplete(requestId, chunkCount, totalContentLength, durationMs) {
+        console.debug(`[LLM:${requestId}] Stream complete in ${durationMs}ms`, {
+            chunkCount,
+            totalContentLength,
+        });
+    }
+    /**
+     * Check if chunks should be logged.
+     */
+    shouldLogChunks() {
+        return this.options.logChunks === true || this.options.verbose === true;
+    }
+    /**
+     * Check if requests should be logged.
+     */
+    shouldLogRequests() {
+        return this.options.logRequests === true || this.options.verbose === true;
+    }
+    /**
+     * Check if responses should be logged.
+     */
+    shouldLogResponses() {
+        return this.options.logResponses === true || this.options.verbose === true;
+    }
+}

package/dist/infra/cipher/llm/generators/openrouter-content-generator.d.ts

@@ -0,0 +1,93 @@
+/**
+ * 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/cipher/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.
+     *
+     * @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;
+}