codehere 0.1.1

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

@@ -0,0 +1,676 @@
+/**
+ * Infrastructure: CohereAIService
+ * Implements IAIService using Cohere API
+ *
+ * @deprecated This class is deprecated and should not be used in new code.
+ * Use CohereProvider from infrastructure/providers/cohere-provider.ts instead.
+ * This class is maintained only as an emergency fallback in dependency-container.ts
+ * and requires COHERE_API_KEY environment variable to function.
+ *
+ * Migration path: Use ProviderRegistry to get providers and ProviderAIService for AI operations.
+ */
+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';
+import { getConfigManager } from '../config/config-manager.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 {
+            // Use default model from config for token encoding (tiktoken is OpenAI-specific)
+            const config = getConfigManager();
+            const defaultModel = config.getModel('default') || config.getPreference('defaultModel');
+            // tiktoken uses OpenAI models - use GPT model if available, else default to gpt-3.5-turbo
+            const tiktokenModel = (defaultModel && defaultModel.includes('gpt')) ? defaultModel : 'gpt-3.5-turbo';
+            tokenEncoder = encoding_for_model(tiktokenModel);
+        }
+        catch {
+            // Fallback if model not found
+            tokenEncoder = encoding_for_model('gpt-3.5-turbo');
+        }
+    }
+    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) {
+        console.warn('[DEPRECATED] CohereAIService is deprecated. Use CohereProvider from infrastructure/providers/cohere-provider.ts instead.');
+        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');
+        // Get temperature from config
+        const config = getConfigManager();
+        const chatTemperature = config.getTemperature('chat') || 0.7;
+        // Register prompt version for reproducibility
+        const promptVersionId = promptVersioner.registerVersion(prompt, {
+            model: model || 'default',
+            temperature: chatTemperature,
+            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: chatTemperature,
+                        promptVersionId,
+                    },
+                });
+                try {
+                    const response = await this.client.chat({
+                        message: prompt,
+                        ...(model ? { model } : {}), // Only add model if specified
+                        temperature: chatTemperature, // 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, requestExplanation) {
+        // For simplicity and reliability, always request the complete modified file
+        // This avoids diff parsing issues and is more reliable
+        let prompt;
+        if (requestExplanation) {
+            // Learning mode: request both code and explanation
+            prompt = `You are a code editor and teacher. Your task is to modify the code AND explain what you changed and why.
+
+CRITICAL RULES:
+1. First, provide the COMPLETE modified file content
+2. Then add a line with exactly: ---EXPLANATION---
+3. After that separator, provide a clear explanation of what changed and why
+4. If renaming a function/class/variable, you MUST update ALL references
+5. Maintain exact indentation and formatting from the original
+6. Only modify what's necessary for the instruction
+
+FILE: ${filepath}
+
+CURRENT CODE:
+\`\`\`
+${fileContent}
+\`\`\`
+
+INSTRUCTION: ${instruction}
+
+Return format:
+1. Complete modified file content (entire file, not a diff)
+2. A line with: ---EXPLANATION---
+3. Your explanation of the changes`;
+        }
+        else {
+            // Standard mode: just code
+            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 responseText = response.text || '';
+                // Parse response to extract code and explanation if requested
+                let text = responseText;
+                let explanation;
+                if (requestExplanation) {
+                    const separatorIndex = responseText.indexOf('---EXPLANATION---');
+                    if (separatorIndex !== -1) {
+                        text = responseText.substring(0, separatorIndex).trim();
+                        explanation = responseText.substring(separatorIndex + '---EXPLANATION---'.length).trim();
+                    }
+                    else {
+                        // Fallback: if separator not found, treat entire response as code
+                        text = responseText;
+                        explanation = 'Explanation not provided in expected format.';
+                    }
+                }
+                // Extract usage data if available from Cohere API
+                const usage = response.meta?.tokens ? {
+                    inputTokens: response.meta.tokens.inputTokens || 0,
+                    outputTokens: response.meta.tokens.outputTokens || 0,
+                } : undefined;
+                // Cohere SDK doesn't expose model in response, use configured model
+                const model = 'command-r';
+                return { text, explanation, usage, model };
+            });
+        }, {
+            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