codehere 0.2.2 → 0.3.0-rc.10

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

@@ -1,477 +0,0 @@
-/**
- * Infrastructure: ProviderAIService
- * Adapter from IModelProvider → IAIService
- *
- * Phase 4B: Provider Adapter Implementation
- * Bridges provider layer into existing IAIService abstraction
- *
- * This adapter:
- * - Implements IAIService interface
- * - Uses IModelProvider internally for actual AI operations
- * - Preserves all existing behavior (context compression, tracing, prompt building)
- * - Maintains backward compatibility with existing code
- */
-import { executionTracer } from '../observability/execution-tracer.js';
-import { promptVersioner } from '../observability/prompt-versioner.js';
-import { getModelConfigManager } from './model-config.js';
-import { OperationProviderResolver } from '../providers/operation-provider-resolver.js';
-import { ProviderRegistry } from '../providers/provider-registry.js';
-import { encoding_for_model } from 'tiktoken';
-import { serializeCodeChunks } from '../serialization/toon-serializer.js';
-// Token counting helper (same as CohereAIService for consistency)
-let tokenEncoder = null;
-function getTokenEncoder() {
-    if (!tokenEncoder) {
-        try {
-            tokenEncoder = encoding_for_model('gpt-3.5-turbo');
-        }
-        catch {
-            tokenEncoder = encoding_for_model('gpt-4');
-        }
-    }
-    return tokenEncoder;
-}
-function countTokens(text) {
-    try {
-        const encoder = getTokenEncoder();
-        return encoder.encode(text).length;
-    }
-    catch (error) {
-        console.warn('Warning: tiktoken failed, using character-based estimate (less accurate)');
-        return Math.ceil(text.length / 4);
-    }
-}
-/**
- * ProviderAIService
- * Adapter that implements IAIService using IModelProvider(s)
- *
- * Phase 4F: Supports per-operation provider selection
- * Phase 4G: Supports user-facing config files
- */
-export class ProviderAIService {
-    _contextCompressor;
-    provider; // Default provider (backward compatibility)
-    providerResolver = null;
-    constructor(provider, contextCompressor, operationConfig, configDefaultProvider) {
-        this.provider = provider; // Keep for backward compatibility
-        this._contextCompressor = contextCompressor;
-        // Phase 4F/4G: Initialize operation provider resolver if operation config is provided
-        if (operationConfig !== undefined || configDefaultProvider !== undefined) {
-            const registry = ProviderRegistry.getInstance();
-            this.providerResolver = new OperationProviderResolver(registry, operationConfig || null, configDefaultProvider || null);
-        }
-    }
-    /**
-     * Get provider for a specific operation
-     * Phase 4F: Operation-aware provider resolution
-     */
-    getProviderForOperation(operation) {
-        // If resolver is configured, use it
-        if (this.providerResolver) {
-            return this.providerResolver.resolveProvider(operation);
-        }
-        // Otherwise, use default provider (backward compatible)
-        return this.provider;
-    }
-    /**
-     * Build prompt from query, context, and memories
-     * Reuses logic from CohereAIService to preserve behavior
-     */
-    async buildPrompt(query, context, memories) {
-        // Use TOON serialization if enabled, otherwise use traditional format
-        const contextText = await serializeCodeChunks(context);
-        const memoryText = memories && memories.length > 0
-            ? `\n\nPREVIOUS EXPERIENCES:\n${memories.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);
-                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`;
-            }
-        }
-        return `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}`;
-    }
-    /**
-     * Select model based on context size and use case
-     * Preserves existing model selection logic
-     */
-    selectModel(contextChunks, memoryCount, useCase = 'default') {
-        const modelConfig = getModelConfigManager();
-        if (modelConfig.isCommandModelAvailable()) {
-            const preferredModel = modelConfig.getPreferredModel(useCase);
-            if (preferredModel) {
-                return preferredModel;
-            }
-        }
-        // Use default model for now
-        if (contextChunks > 20 || memoryCount > 10) {
-            return undefined; // Use default
-        }
-        return undefined; // Use default
-    }
-    async chat(query, context, memories) {
-        // Context Compression: Compress if context is too large (preserves CohereAIService behavior)
-        let finalContext = context;
-        let finalMemories = memories;
-        let compressionMetrics;
-        const contextCompressor = this._contextCompressor || this.contextCompressor;
-        if (contextCompressor) {
-            const estimatedTokens = context.reduce((sum, chunk) => sum + Math.ceil(chunk.content.length / 4), 0);
-            const maxTokens = 3000; // Same threshold as CohereAIService
-            if (estimatedTokens > maxTokens) {
-                const strategy = {
-                    maxTokens,
-                    preserveCode: true,
-                    preserveErrors: true,
-                    compressMemories: true,
-                    compressObservations: false,
-                };
-                const compressed = await contextCompressor.compressWithSummarization(context, query, strategy);
-                finalContext = compressed.chunks;
-                compressionMetrics = {
-                    originalTokens: compressed.originalTokenCount,
-                    compressedTokens: compressed.compressedTokenCount,
-                    reductionPercent: compressed.reductionPercent,
-                };
-                if (strategy.compressMemories && memories && memories.length > 10) {
-                    finalMemories = await contextCompressor.compressMemories(memories, query, 10);
-                }
-                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' },
-                    });
-                }
-            }
-        }
-        const prompt = await this.buildPrompt(query, finalContext, finalMemories);
-        const model = this.selectModel(finalContext.length, finalMemories?.length || 0, 'chat');
-        // Register prompt version for reproducibility
-        const promptVersionId = promptVersioner.registerVersion(prompt, {
-            model: model || 'default',
-            temperature: 0.7,
-            operation: 'chat',
-        });
-        const runId = executionTracer.getCurrentRunId();
-        if (runId) {
-            promptVersioner.linkRunToVersion(prompt, runId);
-        }
-        const startTime = Date.now();
-        // Phase 4F: Use operation-aware provider resolution
-        const operationProvider = this.getProviderForOperation('chat');
-        // 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 operationProvider.chat(prompt, {
-                model,
-                temperature: 0.7,
-            });
-            const result = response.text || 'No response generated';
-            const duration = Date.now() - startTime;
-            // Phase 4F: Use operation-aware provider for token counting
-            const inputTokens = response.usage?.inputTokens || await operationProvider.countTokens(prompt, model);
-            const outputTokens = response.usage?.outputTokens || await operationProvider.countTokens(result, model);
-            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) {
-            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;
-        }
-    }
-    async chatStream(query, context, memories, streamHandler) {
-        const prompt = await this.buildPrompt(query, context, memories);
-        const model = this.selectModel(context.length, memories?.length || 0, 'chat');
-        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 {
-            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,
-                },
-            });
-            // Phase 4F: Use operation-aware provider resolution
-            const operationProvider = this.getProviderForOperation('chat');
-            if (operationProvider.chatStream) {
-                // Use provider's streaming if available
-                const response = await operationProvider.chatStream(prompt, {
-                    model,
-                    temperature: 0.7,
-                }, (event) => {
-                    if (event.type === 'delta' && event.text) {
-                        fullText += event.text;
-                        if (streamHandler.onToken) {
-                            streamHandler.onToken(event.text);
-                        }
-                    }
-                    else if (event.type === 'complete' && event.text) {
-                        fullText = event.text;
-                    }
-                    else if (event.type === 'error' && event.error) {
-                        if (streamHandler.onError) {
-                            streamHandler.onError(event.error);
-                        }
-                    }
-                });
-                fullText = response.text || fullText;
-            }
-            else {
-                // Fallback: Use regular chat and simulate streaming
-                const response = await operationProvider.chat(prompt, {
-                    model,
-                    temperature: 0.7,
-                });
-                fullText = response.text || '';
-                // Simulate streaming by sending chunks
-                const chunkSize = 10;
-                for (let i = 0; i < fullText.length; i += chunkSize) {
-                    const chunk = fullText.substring(i, i + chunkSize);
-                    if (streamHandler.onToken) {
-                        streamHandler.onToken(chunk);
-                    }
-                    if (fullText.length > chunkSize * 2) {
-                        await new Promise(resolve => setTimeout(resolve, 50));
-                    }
-                }
-            }
-            const duration = Date.now() - startTime;
-            const inputTokens = await operationProvider.countTokens(prompt, model);
-            const outputTokens = await operationProvider.countTokens(fullText, model);
-            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,
-                },
-            });
-            if (streamHandler.onComplete) {
-                streamHandler.onComplete(fullText);
-            }
-            return fullText;
-        }
-        catch (error) {
-            const duration = Date.now() - startTime;
-            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,
-                },
-            });
-            if (streamHandler.onError) {
-                streamHandler.onError(error instanceof Error ? error : new Error(String(error)));
-            }
-            throw error;
-        }
-    }
-    async embed(text) {
-        // Phase 4F: Use operation-aware provider resolution
-        const operationProvider = this.getProviderForOperation('embedding');
-        return await operationProvider.embed(text);
-    }
-    async embedQuery(query) {
-        // Phase 4F: Use operation-aware provider resolution
-        const operationProvider = this.getProviderForOperation('embedding');
-        if (operationProvider.embedQuery) {
-            return await operationProvider.embedQuery(query);
-        }
-        // Fallback: Use regular embed if embedQuery not available
-        const result = await operationProvider.embed(query);
-        return Array.isArray(result[0]) ? result[0] : result;
-    }
-    async generateEdit(fileContent, instruction, filepath) {
-        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):`;
-        // Phase 4F: Use operation-aware provider resolution (chat operation)
-        const operationProvider = this.getProviderForOperation('chat');
-        const response = await operationProvider.chat(prompt, {
-            temperature: 0.3, // Lower for deterministic code generation
-        });
-        return response.text || '';
-    }
-    async generateFileContent(filepath, instruction, requirements = []) {
-        const requirementsText = requirements.length > 0
-            ? `\n\nREQUIREMENTS:\n${requirements.map((r, i) => `${i + 1}. ${r}`).join('\n')}`
-            : '';
-        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):`;
-        // Phase 4F: Use operation-aware provider resolution (chat operation)
-        const operationProvider = this.getProviderForOperation('chat');
-        const response = await operationProvider.chat(prompt, {
-            temperature: 0.35,
-        });
-        let content = response.text || '';
-        // Clean up common markdown formatting
-        content = content.replace(/^```[\w]*\n?/gm, '');
-        content = content.replace(/^```$/gm, '');
-        content = content.trim();
-        return content;
-    }
-    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:`;
-        // Phase 4F: Use operation-aware provider resolution (chat operation)
-        const operationProvider = this.getProviderForOperation('chat');
-        const response = await operationProvider.chat(prompt, {
-            temperature: 0.5,
-        });
-        return response.text || '';
-    }
-    async rerank(query, documents, topN = 10) {
-        if (documents.length === 0) {
-            return [];
-        }
-        // Phase 4F: Use operation-aware provider resolution
-        const operationProvider = this.getProviderForOperation('rerank');
-        if (!operationProvider.capabilities.rerank || !operationProvider.rerank) {
-            // Fallback: Return original order if rerank not supported
-            return documents.slice(0, topN).map((_, i) => ({ index: i, relevanceScore: 1.0 }));
-        }
-        const topNAdjusted = Math.min(topN, documents.length);
-        const response = await operationProvider.rerank(query, documents, { topN: topNAdjusted });
-        return response.results.map(result => ({
-            index: result.index,
-            relevanceScore: result.relevanceScore,
-        }));
-    }
-}
-//# sourceMappingURL=provider-ai-service.js.map

package/dist/infrastructure/cache/embedding-cache.js

@@ -1,175 +0,0 @@
-/**
- * Infrastructure: Embedding Cache
- * Caches embeddings to avoid redundant API calls
- *
- * Performance optimization: Reduces API calls by ~30-50% for repeated queries
- */
-import { createHash } from 'crypto';
-export class EmbeddingCache {
-    cache = new Map();
-    maxSize;
-    ttl; // Time to live in milliseconds
-    constructor(maxSize = 1000, ttl = 3600000) {
-        this.maxSize = maxSize;
-        this.ttl = ttl;
-    }
-    /**
-     * Generate cache key from query
-     */
-    getCacheKey(query) {
-        // Normalize query (trim, lowercase) for better cache hits
-        const normalized = query.trim().toLowerCase();
-        return createHash('sha256').update(normalized).digest('hex');
-    }
-    /**
-     * Get cached embedding if available and not expired
-     * OPTIMIZATION: Also checks for similar queries with fuzzy matching
-     */
-    get(query, enableFuzzyMatch = true) {
-        const key = this.getCacheKey(query);
-        let cached = this.cache.get(key);
-        // Direct cache hit
-        if (cached) {
-            const now = Date.now();
-            if (now - cached.timestamp > this.ttl) {
-                this.cache.delete(key);
-            }
-            else {
-                return cached.embedding;
-            }
-        }
-        // Fuzzy matching for similar queries
-        // OPTIMIZATION: Use lower threshold (80%) for more aggressive caching
-        // This helps with query variations like "what is main" vs "what is the main function"
-        if (enableFuzzyMatch && this.cache.size > 0) {
-            const normalizedQuery = query.trim().toLowerCase();
-            // Try with standard threshold first (85%), then lower threshold (80%) for more aggressive matching
-            let bestMatch = this.findSimilarQuery(normalizedQuery, 0.85);
-            if (!bestMatch) {
-                bestMatch = this.findSimilarQuery(normalizedQuery, 0.80);
-            }
-            if (bestMatch && bestMatch.embedding) {
-                // Found similar query - reuse its embedding
-                return bestMatch.embedding;
-            }
-        }
-        return null;
-    }
-    /**
-     * Find similar query using Levenshtein distance
-     * Returns cached embedding if similarity >= threshold
-     */
-    findSimilarQuery(query, threshold = 0.85) {
-        let bestMatch = null;
-        const now = Date.now();
-        for (const [key, cached] of this.cache.entries()) {
-            // Skip expired entries
-            if (now - cached.timestamp > this.ttl) {
-                continue;
-            }
-            const normalizedCached = cached.query.trim().toLowerCase();
-            const similarity = this.calculateSimilarity(query, normalizedCached);
-            if (similarity >= threshold) {
-                if (!bestMatch || similarity > bestMatch.similarity) {
-                    bestMatch = { cached, similarity };
-                }
-            }
-        }
-        return bestMatch ? bestMatch.cached : null;
-    }
-    /**
-     * Calculate string similarity using word overlap with stop word filtering
-     * Returns value between 0.0 (no similarity) and 1.0 (identical)
-     * OPTIMIZATION: Filters common stop words to focus on meaningful content
-     */
-    calculateSimilarity(str1, str2) {
-        if (str1 === str2)
-            return 1.0;
-        if (str1.length === 0 || str2.length === 0)
-            return 0.0;
-        // Common stop words to ignore for better matching
-        const stopWords = new Set(['the', 'a', 'an', 'is', 'are', 'was', 'were', 'be', 'been', 'being', 'have', 'has', 'had', 'do', 'does', 'did', 'will', 'would', 'should', 'could', 'may', 'might', 'must', 'can', 'this', 'that', 'these', 'those', 'what', 'which', 'who', 'where', 'when', 'why', 'how', 'to', 'of', 'in', 'on', 'at', 'by', 'for', 'with', 'from', 'as', 'about', 'into', 'through', 'during', 'including', 'against', 'among', 'throughout', 'despite', 'towards', 'upon', 'concerning', 'to', 'of', 'in', 'on', 'at', 'by', 'for', 'with', 'from']);
-        // Filter out stop words and short words for better matching
-        const filterWords = (text) => {
-            return text.split(/\s+/)
-                .filter(w => w.length > 2 && !stopWords.has(w.toLowerCase()))
-                .map(w => w.toLowerCase().replace(/[^\w]/g, '')); // Normalize
-        };
-        const words1 = new Set(filterWords(str1));
-        const words2 = new Set(filterWords(str2));
-        if (words1.size === 0 || words2.size === 0)
-            return 0.0;
-        // Calculate Jaccard similarity (word overlap)
-        let intersection = 0;
-        for (const word of words1) {
-            if (words2.has(word)) {
-                intersection++;
-            }
-        }
-        const union = words1.size + words2.size - intersection;
-        return union > 0 ? intersection / union : 0.0;
-    }
-    /**
-     * Store embedding in cache
-     */
-    set(query, embedding) {
-        const key = this.getCacheKey(query);
-        // Evict oldest entries if cache is full
-        if (this.cache.size >= this.maxSize) {
-            this.evictOldest();
-        }
-        this.cache.set(key, {
-            embedding,
-            timestamp: Date.now(),
-            query: query.trim(),
-        });
-    }
-    /**
-     * Evict oldest entries (LRU eviction)
-     */
-    evictOldest() {
-        // Remove 10% of oldest entries
-        const entriesToRemove = Math.ceil(this.maxSize * 0.1);
-        const entries = Array.from(this.cache.entries())
-            .sort((a, b) => a[1].timestamp - b[1].timestamp)
-            .slice(0, entriesToRemove);
-        for (const [key] of entries) {
-            this.cache.delete(key);
-        }
-    }
-    /**
-     * Clear expired entries
-     */
-    clearExpired() {
-        const now = Date.now();
-        for (const [key, value] of this.cache.entries()) {
-            if (now - value.timestamp > this.ttl) {
-                this.cache.delete(key);
-            }
-        }
-    }
-    /**
-     * Clear all cache
-     */
-    clear() {
-        this.cache.clear();
-    }
-    /**
-     * Get cache statistics
-     */
-    getStats() {
-        return {
-            size: this.cache.size,
-            maxSize: this.maxSize,
-        };
-    }
-}
-// Singleton instance
-let embeddingCacheInstance = null;
-export function getEmbeddingCache() {
-    if (!embeddingCacheInstance) {
-        embeddingCacheInstance = new EmbeddingCache();
-    }
-    return embeddingCacheInstance;
-}
-//# sourceMappingURL=embedding-cache.js.map