codehere 0.2.2 → 0.3.0-rc.10

package/dist/infrastructure/ai/cohere-ai-service.js

@@ -1,607 +0,0 @@
-/**
- * Infrastructure: CohereAIService
- * Implements IAIService using Cohere API
- */
-import { CohereClient } from 'cohere-ai';
-import { config } from 'dotenv';
-import { join, dirname } from 'path';
-import { fileURLToPath } from 'url';
-import { encoding_for_model } from 'tiktoken';
-import { retryWithBackoff, cohereCircuitBreaker } from '../../error-handler.js';
-import { executionTracer } from '../observability/execution-tracer.js';
-import { promptVersioner } from '../observability/prompt-versioner.js';
-import { getModelConfigManager } from './model-config.js';
-// Initialize tiktoken encoder for accurate token counting
-// Using cl100k_base which is compatible with most models
-let tokenEncoder = null;
-function getTokenEncoder() {
-    if (!tokenEncoder) {
-        try {
-            tokenEncoder = encoding_for_model('gpt-3.5-turbo'); // cl100k_base encoding
-        }
-        catch {
-            // Fallback if model not found
-            tokenEncoder = encoding_for_model('gpt-4');
-        }
-    }
-    return tokenEncoder;
-}
-function countTokens(text) {
-    try {
-        const encoder = getTokenEncoder();
-        return encoder.encode(text).length;
-    }
-    catch (error) {
-        // Fallback: Use character-based estimate only if tiktoken completely fails
-        // This should rarely happen, but provides a safety net
-        console.warn('Warning: tiktoken failed, using character-based estimate (less accurate)');
-        return Math.ceil(text.length / 4);
-    }
-}
-// Load .env
-try {
-    const __filename = fileURLToPath(import.meta.url);
-    const __dirname = dirname(__filename);
-    const agentDir = join(__dirname, '../../..');
-    config({ path: join(agentDir, '.env') });
-}
-catch { }
-config();
-export class CohereAIService {
-    client;
-    _contextCompressor;
-    constructor(contextCompressor) {
-        this._contextCompressor = contextCompressor;
-        const apiKey = process.env.COHERE_API_KEY;
-        if (!apiKey) {
-            throw new Error('COHERE_API_KEY not found in environment');
-        }
-        this.client = new CohereClient({ token: apiKey });
-    }
-    async chat(query, context, memories) {
-        // Context Compression: Compress if context is too large (P0 - prevents cost escalation)
-        let finalContext = context;
-        let finalMemories = memories;
-        let compressionMetrics;
-        // Lazy getter for context compressor to avoid circular dependency
-        const contextCompressor = this._contextCompressor || this.contextCompressor;
-        if (contextCompressor) {
-            // Estimate tokens (rough: 1 token ≈ 4 chars)
-            const estimatedTokens = context.reduce((sum, chunk) => sum + Math.ceil(chunk.content.length / 4), 0);
-            // OPTIMIZATION: Lower compression threshold to trigger earlier (3000 vs 8000)
-            // This reduces AI Chat latency by compressing context more aggressively
-            // Further reduced from 4000 to 3000 for even more aggressive compression
-            const maxTokens = 3000; // Reduced from 8000 to trigger compression earlier
-            if (estimatedTokens > maxTokens) {
-                const strategy = {
-                    maxTokens,
-                    preserveCode: true, // Keep code, compress comments/context
-                    preserveErrors: true,
-                    compressMemories: true,
-                    compressObservations: false, // Not applicable here
-                };
-                const compressed = await contextCompressor.compressWithSummarization(context, query, strategy);
-                finalContext = compressed.chunks;
-                compressionMetrics = {
-                    originalTokens: compressed.originalTokenCount,
-                    compressedTokens: compressed.compressedTokenCount,
-                    reductionPercent: compressed.reductionPercent,
-                };
-                // Compress memories if enabled
-                if (strategy.compressMemories && memories && memories.length > 10) {
-                    finalMemories = await contextCompressor.compressMemories(memories, query, 10);
-                }
-                // Log compression metrics
-                const runId = executionTracer.getCurrentRunId();
-                if (runId) {
-                    executionTracer.trace({
-                        operationType: 'context_compression',
-                        operationName: 'compress_context',
-                        input: { contextCount: context.length, estimatedTokens },
-                        output: {
-                            compressedCount: finalContext.length,
-                            ...compressionMetrics
-                        },
-                        metadata: { strategy: 'llm_summarization' },
-                    });
-                }
-            }
-        }
-        // Use TOON serialization if enabled, otherwise use traditional format
-        const { serializeCodeChunks } = await import('../serialization/toon-serializer.js');
-        const contextText = await serializeCodeChunks(finalContext);
-        const memoryText = finalMemories && finalMemories.length > 0
-            ? `\n\nPREVIOUS EXPERIENCES:\n${finalMemories.map(m => `- ${m.description}`).join('\n')}`
-            : '';
-        // Get conversation history if available in context
-        let conversationHistoryText = '';
-        if (context.length > 0 && context[0].conversationHistory) {
-            const history = context[0].conversationHistory;
-            if (history && history.length > 0) {
-                const recentHistory = history.slice(-3); // Last 3 turns
-                conversationHistoryText = `\n\nCONVERSATION HISTORY:\n${recentHistory.map((turn, idx) => `[Previous ${idx + 1}]: User asked "${turn.query}". Response: ${turn.response.substring(0, 150)}...`).join('\n')}\n`;
-            }
-        }
-        const prompt = `You are a strict coding assistant for enterprise environments.
-Use ONLY the provided code context.
-${conversationHistoryText ? 'Consider the conversation history when answering the current query, especially if the user uses references like "it", "that", or "the previous".' : ''}
-
-CONTEXT:
-${contextText}${memoryText}${conversationHistoryText}
-
-USER QUERY:
-${query}`;
-        // Determine model based on context size and use case
-        // For now, use default. Command A evaluation will determine if we should migrate.
-        const model = this.selectModel(context.length, memories?.length || 0, 'chat');
-        // Register prompt version for reproducibility
-        const promptVersionId = promptVersioner.registerVersion(prompt, {
-            model: model || 'default',
-            temperature: 0.7,
-            operation: 'chat',
-        });
-        // Link to current run if available
-        const runId = executionTracer.getCurrentRunId();
-        if (runId) {
-            promptVersioner.linkRunToVersion(prompt, runId);
-        }
-        const startTime = Date.now();
-        return await retryWithBackoff(async () => {
-            return await cohereCircuitBreaker.execute(async () => {
-                // Trace LLM call
-                const traceId = executionTracer.trace({
-                    operationType: 'llm_call',
-                    operationName: 'chat',
-                    input: { query, contextCount: context.length, memoryCount: memories?.length || 0 },
-                    metadata: {
-                        model: model || 'default',
-                        temperature: 0.7,
-                        promptVersionId,
-                    },
-                });
-                try {
-                    const response = await this.client.chat({
-                        message: prompt,
-                        ...(model ? { model } : {}), // Only add model if specified
-                        temperature: 0.7, // Balanced for general chat/explanation
-                    });
-                    const result = response.text || 'No response generated';
-                    const duration = Date.now() - startTime;
-                    // Count tokens for trace metadata
-                    const inputTokens = countTokens(prompt);
-                    const outputTokens = countTokens(result);
-                    // Update trace with output
-                    executionTracer.trace({
-                        operationType: 'llm_call',
-                        operationName: 'chat',
-                        output: { responseLength: result.length, inputTokens, outputTokens },
-                        duration,
-                        metadata: {
-                            model: model || 'default',
-                            temperature: 0.7,
-                            promptVersionId,
-                        },
-                    });
-                    return result;
-                }
-                catch (error) {
-                    // Trace error
-                    executionTracer.trace({
-                        operationType: 'llm_call',
-                        operationName: 'chat',
-                        error: error instanceof Error ? error : new Error(String(error)),
-                        duration: Date.now() - startTime,
-                        metadata: {
-                            model: model || 'default',
-                            temperature: 0.7,
-                            promptVersionId,
-                        },
-                    });
-                    throw error;
-                }
-            });
-        }, {
-            maxRetries: 5,
-            baseDelay: 2000,
-            maxDelay: 60000,
-            operationName: 'chat',
-        });
-    }
-    /**
-     * Generate chat response with streaming support
-     * Real-time feedback for better UX (target: < 200ms latency)
-     *
-     * NOTE: Cohere SDK streaming implementation - using async iteration pattern
-     * Falls back to regular chat if streaming is not available
-     */
-    async chatStream(query, context, memories, streamHandler) {
-        const contextText = context
-            .map((chunk, idx) => `[Chunk ${idx + 1} from ${chunk.filepath}]\n${chunk.content}`)
-            .join('\n\n---\n\n');
-        const memoryText = memories && memories.length > 0
-            ? `\n\nPREVIOUS EXPERIENCES:\n${memories.map(m => `- ${m.description}`).join('\n')}`
-            : '';
-        const prompt = `You are a strict coding assistant for enterprise environments.
-Use ONLY the provided code context.
-
-CONTEXT:
-${contextText}${memoryText}
-
-USER QUERY:
-${query}`;
-        const model = this.selectModel(context.length, memories?.length || 0, 'chat');
-        // Register prompt version
-        const promptVersionId = promptVersioner.registerVersion(prompt, {
-            model: model || 'default',
-            temperature: 0.7,
-            operation: 'chat-stream',
-        });
-        const runId = executionTracer.getCurrentRunId();
-        if (runId) {
-            promptVersioner.linkRunToVersion(prompt, runId);
-        }
-        const startTime = Date.now();
-        let fullText = '';
-        try {
-            // Trace streaming start
-            executionTracer.trace({
-                operationType: 'llm_call',
-                operationName: 'chat-stream',
-                input: { query, contextCount: context.length, memoryCount: memories?.length || 0 },
-                metadata: {
-                    model: model || 'default',
-                    temperature: 0.7,
-                    promptVersionId,
-                    streaming: true,
-                },
-            });
-            // Check if Cohere SDK supports streaming
-            // Cohere SDK v7+ should support streaming via chatStream method or stream option
-            // Fallback: Use regular chat if streaming not available
-            if (typeof this.client.chatStream === 'function') {
-                // Use Cohere's native streaming
-                const stream = await this.client.chatStream({
-                    message: prompt,
-                    ...(model ? { model } : {}),
-                    temperature: 0.7,
-                });
-                // Process stream events (Cohere SDK typically uses async iterator)
-                for await (const event of stream) {
-                    if (event.eventType === 'text-generation' || event.type === 'text') {
-                        const token = event.text || event.delta || '';
-                        if (token) {
-                            fullText += token;
-                            if (streamHandler.onToken) {
-                                streamHandler.onToken(token);
-                            }
-                        }
-                    }
-                }
-            }
-            else {
-                // Fallback: Use regular chat and simulate streaming
-                // Split response into chunks for better UX
-                const response = await this.client.chat({
-                    message: prompt,
-                    ...(model ? { model } : {}),
-                    temperature: 0.7,
-                });
-                fullText = response.text || '';
-                // Simulate streaming by sending chunks
-                // Target: < 200ms latency (send chunks every 50-100ms)
-                const chunkSize = 10; // Characters per chunk
-                for (let i = 0; i < fullText.length; i += chunkSize) {
-                    const chunk = fullText.substring(i, i + chunkSize);
-                    if (streamHandler.onToken) {
-                        streamHandler.onToken(chunk);
-                    }
-                    // Small delay to simulate streaming (only if text is long enough)
-                    if (fullText.length > chunkSize * 2) {
-                        await new Promise(resolve => setTimeout(resolve, 50));
-                    }
-                }
-            }
-            const duration = Date.now() - startTime;
-            // Count tokens for trace metadata
-            const inputTokens = countTokens(prompt);
-            const outputTokens = countTokens(fullText);
-            // Update trace
-            executionTracer.trace({
-                operationType: 'llm_call',
-                operationName: 'chat-stream',
-                output: { responseLength: fullText.length, inputTokens, outputTokens },
-                duration,
-                metadata: {
-                    model: model || 'default',
-                    temperature: 0.7,
-                    promptVersionId,
-                    streaming: true,
-                },
-            });
-            // Call completion handler
-            if (streamHandler.onComplete) {
-                streamHandler.onComplete(fullText);
-            }
-            return fullText;
-        }
-        catch (error) {
-            const duration = Date.now() - startTime;
-            // Trace error
-            executionTracer.trace({
-                operationType: 'llm_call',
-                operationName: 'chat-stream',
-                error: error instanceof Error ? error : new Error(String(error)),
-                duration,
-                metadata: {
-                    model: model || 'default',
-                    temperature: 0.7,
-                    promptVersionId,
-                    streaming: true,
-                },
-            });
-            // Call error handler
-            if (streamHandler.onError) {
-                streamHandler.onError(error instanceof Error ? error : new Error(String(error)));
-            }
-            throw error;
-        }
-    }
-    /**
-     * Select appropriate model based on context size and use case
-     * Returns model name if we should use a specific model, undefined for default
-     * Uses model configuration from Command A evaluation results
-     */
-    selectModel(contextChunks, memoryCount, useCase = 'default') {
-        const modelConfig = getModelConfigManager();
-        // Check if Command models are available from evaluation
-        if (modelConfig.isCommandModelAvailable()) {
-            const preferredModel = modelConfig.getPreferredModel(useCase);
-            if (preferredModel) {
-                return preferredModel;
-            }
-        }
-        // Use default model for now (will be updated after Command A evaluation)
-        // Large context or many memories → might need Command A (after evaluation)
-        if (contextChunks > 20 || memoryCount > 10) {
-            // After evaluation, this will return the preferred Command model
-            return undefined; // Use default for now
-        }
-        return undefined; // Use default
-    }
-    /**
-     * Embed text as documents (for code chunks, memory storage)
-     * Uses 'search_document' input type for optimal document embedding
-     */
-    async embed(text) {
-        const texts = Array.isArray(text) ? text : [text];
-        return await retryWithBackoff(async () => {
-            return await cohereCircuitBreaker.execute(async () => {
-                const response = await this.client.embed({
-                    texts,
-                    model: 'embed-english-v3.0',
-                    inputType: 'search_document', // For code chunks/documents
-                });
-                const embeddings = response.embeddings;
-                if (texts.length === 1) {
-                    return embeddings[0];
-                }
-                return embeddings;
-            });
-        }, {
-            maxRetries: 5,
-            baseDelay: 2000,
-            maxDelay: 60000,
-            operationName: 'embed',
-        });
-    }
-    /**
-     * Embed text as a search query (for user queries)
-     * Uses 'search_query' input type for optimal query-document matching
-     * This is critical for better search quality!
-     */
-    async embedQuery(query) {
-        return await retryWithBackoff(async () => {
-            return await cohereCircuitBreaker.execute(async () => {
-                const response = await this.client.embed({
-                    texts: [query],
-                    model: 'embed-english-v3.0',
-                    inputType: 'search_query', // For user queries - better matching!
-                });
-                const embeddings = response.embeddings;
-                // Handle both array and object response types
-                if (Array.isArray(embeddings)) {
-                    if (embeddings.length === 0) {
-                        throw new Error('No embedding returned for query');
-                    }
-                    return embeddings[0] || [];
-                }
-                else {
-                    // Handle EmbedByTypeResponseEmbeddings type
-                    const embeddingsArray = embeddings.float || [];
-                    if (embeddingsArray.length === 0) {
-                        throw new Error('No embedding returned for query');
-                    }
-                    return embeddingsArray[0] || [];
-                }
-            });
-        }, {
-            maxRetries: 5,
-            baseDelay: 2000,
-            maxDelay: 60000,
-            operationName: 'embedQuery',
-        });
-    }
-    async generateEdit(fileContent, instruction, filepath) {
-        // For simplicity and reliability, always request the complete modified file
-        // This avoids diff parsing issues and is more reliable
-        const prompt = `You are a code editor. Return the COMPLETE modified file content.
-
-CRITICAL RULES:
-1. Return ONLY the complete modified file content - no explanations, no markdown, no code blocks
-2. If renaming a function/class/variable, you MUST update ALL references
-3. Maintain exact indentation and formatting from the original
-4. Only modify what's necessary for the instruction
-5. Return the ENTIRE file, not just the changes
-
-FILE: ${filepath}
-
-CURRENT CODE:
-\`\`\`
-${fileContent}
-\`\`\`
-
-INSTRUCTION: ${instruction}
-
-Return the COMPLETE modified file content (entire file, not a diff):`;
-        return await retryWithBackoff(async () => {
-            return await cohereCircuitBreaker.execute(async () => {
-                const response = await this.client.chat({
-                    message: prompt,
-                    temperature: 0.3, // Lower for deterministic code generation and editing
-                });
-                const result = response.text || '';
-                return result;
-            });
-        }, {
-            maxRetries: 3,
-            baseDelay: 2000,
-            maxDelay: 30000,
-            operationName: 'generateEdit',
-        });
-    }
-    async generateFileContent(filepath, instruction, requirements = []) {
-        const requirementsText = requirements.length > 0
-            ? `\n\nREQUIREMENTS:\n${requirements.map((r, i) => `${i + 1}. ${r}`).join('\n')}`
-            : '';
-        // Detect file type from extension
-        const ext = filepath.split('.').pop()?.toLowerCase() || '';
-        const languageMap = {
-            'ts': 'TypeScript',
-            'js': 'JavaScript',
-            'tsx': 'TypeScript React',
-            'jsx': 'JavaScript React',
-            'py': 'Python',
-            'java': 'Java',
-            'go': 'Go',
-            'rs': 'Rust',
-            'rb': 'Ruby',
-            'php': 'PHP',
-            'vue': 'Vue',
-            'svelte': 'Svelte',
-            'html': 'HTML',
-            'css': 'CSS',
-            'json': 'JSON',
-            'yaml': 'YAML',
-            'yml': 'YAML',
-            'md': 'Markdown',
-            'sh': 'Bash',
-            'bash': 'Bash',
-        };
-        const language = languageMap[ext] || 'code';
-        const prompt = `You are a code generator. Create a NEW ${language} file from scratch.
-
-CRITICAL RULES:
-1. Return ONLY the complete file content - no explanations, no markdown, no code blocks
-2. Follow ${language} best practices and conventions
-3. Include proper imports, exports, and structure
-4. Add appropriate comments for clarity
-5. Ensure the code is production-ready and well-structured
-
-FILE PATH: ${filepath}
-FILE TYPE: ${language}${requirementsText}
-
-INSTRUCTION: ${instruction}
-
-Return the COMPLETE file content (entire file, ready to save):`;
-        return await retryWithBackoff(async () => {
-            return await cohereCircuitBreaker.execute(async () => {
-                const response = await this.client.chat({
-                    message: prompt,
-                    temperature: 0.35, // Slightly higher for new file generation (allows some creativity while staying deterministic)
-                });
-                let content = response.text || '';
-                // Clean up common markdown formatting
-                // Remove code blocks if present
-                content = content.replace(/^```[\w]*\n?/gm, '');
-                content = content.replace(/^```$/gm, '');
-                content = content.trim();
-                return content;
-            });
-        }, {
-            maxRetries: 3,
-            baseDelay: 2000,
-            maxDelay: 30000,
-            operationName: 'generateFileContent',
-        });
-    }
-    async generateReflection(trajectory, reward, errors) {
-        const prompt = `You are a self-reflection model. Analyze the following failed trajectory:
-
-Trajectory:
-${JSON.stringify(trajectory, null, 2)}
-
-Reward: ${reward}
-Errors: ${errors.join('; ')}
-
-Generate a reflective text that:
-1. Identifies the root cause of failure
-2. Explains what went wrong
-3. Suggests specific improvements for the next attempt
-4. Extracts lessons learned
-
-Reflection:`;
-        return await retryWithBackoff(async () => {
-            return await cohereCircuitBreaker.execute(async () => {
-                const response = await this.client.chat({
-                    message: prompt,
-                    temperature: 0.5, // Balanced for reflection (analytical but open to insights)
-                });
-                const result = response.text || '';
-                return result;
-            });
-        }, {
-            maxRetries: 3,
-            baseDelay: 2000,
-            maxDelay: 30000,
-            operationName: 'generateReflection',
-        });
-    }
-    /**
-     * Rerank search results using Cohere Rerank API
-     * Implements two-stage retrieval: initial recall → rerank precision
-     *
-     * Strategy:
-     * 1. Initial retrieval (vector search) finds candidate documents
-     * 2. Rerank API scores and reorders for precision
-     * 3. Returns top N most relevant results
-     */
-    async rerank(query, documents, topN = 10) {
-        if (documents.length === 0) {
-            return [];
-        }
-        // Cohere Rerank API has limits, so we cap at 100 documents
-        const documentsToRerank = documents.slice(0, 100);
-        const topNAdjusted = Math.min(topN, documentsToRerank.length);
-        return await retryWithBackoff(async () => {
-            return await cohereCircuitBreaker.execute(async () => {
-                const response = await this.client.rerank({
-                    model: 'rerank-english-v3.0', // Use latest English rerank model
-                    query,
-                    documents: documentsToRerank,
-                    topN: topNAdjusted,
-                });
-                // Map Cohere rerank results to our format
-                return (response.results || []).map((result) => ({
-                    index: result.index,
-                    relevanceScore: result.relevanceScore || 0,
-                }));
-            });
-        }, {
-            maxRetries: 3,
-            baseDelay: 2000,
-            maxDelay: 30000,
-            operationName: 'rerank',
-        });
-    }
-}
-//# sourceMappingURL=cohere-ai-service.js.map