codehere 0.1.1 → 0.2.2

package/dist/application/use-cases/react-orchestration-use-case.js

@@ -35,9 +35,8 @@ export class ReActOrchestrationUseCase {
         // 2. Get available tools for context
         const { getToolRegistry } = await import('../../tools/registry.js');
         const toolRegistry = getToolRegistry();
-        // Use getToolList() which returns formatted string with tool names and descriptions
-        // This helps prevent AI from hallucinating tool names
-        const availableTools = toolRegistry.getToolList(); // Returns formatted string
+        // getToolList() returns a string, getAll() returns Tool[] array
+        const availableTools = toolRegistry.getAll().map(tool => tool.name); // Get array of tool names
         // 3. Log goal interpretation (XAI Foundation - Research: Full auditability required)
         const goalId = `goal-${Date.now()}`;
         const goalInterpretation = {
@@ -99,14 +98,9 @@ export class ReActOrchestrationUseCase {
                     toolName: action.name,
                     parameters: action.parameters || {},
                     reasoning: `Tool selected based on thought and available context`,
-                    alternativeTools: typeof context.availableTools === 'string'
-                        ? [] // Can't extract from string easily
-                        : Array.isArray(context.availableTools)
-                            ? context.availableTools.filter((t) => {
-                                const toolName = typeof t === 'string' ? t : t.name || t;
-                                return toolName !== action.name;
-                            }).slice(0, 3)
-                            : [],
+                    alternativeTools: Array.isArray(context.availableTools)
+                        ? context.availableTools.filter((t) => t !== action.name).slice(0, 3)
+                        : [],
                 };
                 this.decisionTreeLog.logToolExecution(toolId, toolRationale, context.goalId || goalId);
                 // Store tool ID for linking observation
@@ -130,9 +124,7 @@ export class ReActOrchestrationUseCase {
             // Add observation to CoT trajectory (XAI Foundation - Research: CoT visualization)
             if (this.cotVisualizer && cotTrajectory) {
                 const obsContent = observation.success
-                    ? (typeof observation.result === 'string'
-                        ? observation.result
-                        : JSON.stringify(observation.result, null, 2)).substring(0, 500) // Truncate for display
+                    ? String(observation.result).substring(0, 500) // Truncate for display
                     : `Error: ${observation.error || 'Failed'}`;
                 this.cotVisualizer.addObservation(cotTrajectory, obsContent, {
                     success: observation.success,
@@ -141,29 +133,9 @@ export class ReActOrchestrationUseCase {
             }
             // Stream observation result if handler provided
             if (request.streamHandler?.onObservation) {
-                let obsDesc;
-                if (observation.success) {
-                    if (typeof observation.result === 'string') {
-                        obsDesc = `✓ ${observation.result}`;
-                    }
-                    else if (observation.result === null || observation.result === undefined) {
-                        obsDesc = '✓ No result';
-                    }
-                    else {
-                        // Try to stringify, but handle circular references and large objects
-                        try {
-                            const serialized = JSON.stringify(observation.result, null, 2);
-                            obsDesc = `✓ ${serialized.substring(0, 200)}${serialized.length > 200 ? '...' : ''}`;
-                        }
-                        catch (e) {
-                            // Fallback for objects that can't be stringified
-                            obsDesc = `✓ ${String(observation.result).substring(0, 200)}`;
-                        }
-                    }
-                }
-                else {
-                    obsDesc = `✗ ${observation.error || 'Failed'}`;
-                }
+                const obsDesc = observation.success
+                    ? `✓ ${String(observation.result).substring(0, 100)}`
+                    : `✗ ${observation.error || 'Failed'}`;
                 request.streamHandler.onObservation(obsDesc);
             }
             // Log error if execution failed (XAI Foundation - Research: Error Trace for Fault Attribution)
@@ -245,12 +217,7 @@ Thought:`;
         };
     }
     async generateAction(thought, context) {
-        // Ensure availableTools is a formatted string (not array)
-        const availableTools = typeof context.availableTools === 'string'
-            ? context.availableTools
-            : Array.isArray(context.availableTools)
-                ? context.availableTools.map((t) => `- ${t}: ${typeof t === 'string' ? t : t.name || t}`).join('\n')
-                : 'No tools available';
+        const availableTools = context.availableTools || 'No tools available';
         const trajectory = context.trajectory || { steps: [] };
         const trajectoryContext = trajectory.steps.length > 0
             ? `\n\nPrevious actions:\n${trajectory.steps.map((s, i) => `${i + 1}. ${s.action.type}: ${s.action.name} - ${s.observation.success ? 'Success' : 'Failed: ' + (s.observation.error || 'Unknown')}`).join('\n')}`

package/dist/chat.js

@@ -1,11 +1,9 @@
 import { config } from 'dotenv';
 import { join, dirname } from 'path';
 import { fileURLToPath } from 'url';
-import { retryWithBackoff, cohereCircuitBreaker, handleError } from './error-handler.js';
+import { retryWithBackoff, handleError } from './error-handler.js';
 import { optimizeContext } from './token-optimizer.js';
 import { optimizeQuery } from './query-optimizer.js';
-import { ProviderRegistry } from './infrastructure/providers/provider-registry.js';
-import { OperationProviderResolver } from './infrastructure/providers/operation-provider-resolver.js';
 // Load .env from agent directory
 try {
     const __filename = fileURLToPath(import.meta.url);
@@ -17,46 +15,112 @@ catch {
     // Fallback
 }
 config(); // Also try current directory
+async function chatCompletion(prompt) {
+    // Route to available provider
+    if (process.env.ANTHROPIC_API_KEY) {
+        const response = await fetch('https://api.anthropic.com/v1/messages', {
+            method: 'POST',
+            headers: {
+                'x-api-key': process.env.ANTHROPIC_API_KEY,
+                'anthropic-version': '2023-06-01',
+                'content-type': 'application/json',
+            },
+            body: JSON.stringify({
+                model: 'claude-sonnet-4-20250514',
+                max_tokens: 4096,
+                messages: [{ role: 'user', content: prompt }],
+            }),
+        });
+        if (!response.ok)
+            throw new Error(`Anthropic API error: ${response.status}`);
+        const data = await response.json();
+        return data.content?.[0]?.text || 'No response generated';
+    }
+    if (process.env.OPENAI_API_KEY) {
+        const response = await fetch('https://api.openai.com/v1/chat/completions', {
+            method: 'POST',
+            headers: {
+                'Authorization': `Bearer ${process.env.OPENAI_API_KEY}`,
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({
+                model: 'gpt-4o-mini',
+                messages: [{ role: 'user', content: prompt }],
+                max_tokens: 4096,
+            }),
+        });
+        if (!response.ok)
+            throw new Error(`OpenAI API error: ${response.status}`);
+        const data = await response.json();
+        return data.choices?.[0]?.message?.content || 'No response generated';
+    }
+    if (process.env.COHERE_API_KEY) {
+        const { CohereClient } = require('cohere-ai');
+        const cohere = new CohereClient({ token: process.env.COHERE_API_KEY });
+        const response = await cohere.chat({ message: prompt });
+        return response.text || 'No response generated';
+    }
+    throw new Error('No API key found. Set ANTHROPIC_API_KEY, OPENAI_API_KEY, or COHERE_API_KEY.');
+}
 /**
- * Get chat provider (supports all providers via registry)
+ * Streaming chat completion — yields tokens as they arrive
  */
-async function getChatProvider() {
-    const registry = ProviderRegistry.getInstance();
-    // Ensure providers are registered
-    if (!registry.get('cohere') && !registry.get('openai') && !registry.get('fake')) {
-        if (process.env.CODEHERE_FAKE_AI === '1') {
-            const { FakeProvider } = await import('./infrastructure/providers/fake-provider.js');
-            registry.register(new FakeProvider());
-            registry.setDefault('fake');
-        }
-        else {
-            if (process.env.COHERE_API_KEY) {
-                const { CohereProvider } = await import('./infrastructure/providers/cohere-provider.js');
-                registry.register(new CohereProvider());
-            }
-            if (process.env.CODEHERE_OPENAI_API_KEY || process.env.OPENAI_API_KEY) {
-                const { OpenAIProvider } = await import('./infrastructure/providers/openai-provider.js');
-                registry.register(new OpenAIProvider());
-            }
-            if (process.env.OPENROUTER_API_KEY) {
-                const { OpenRouterProvider } = await import('./infrastructure/providers/openrouter-provider.js');
-                registry.register(new OpenRouterProvider());
-            }
-            // Set default based on CODEHERE_AI_PROVIDER
-            const requestedProvider = process.env.CODEHERE_AI_PROVIDER?.toLowerCase();
-            if (requestedProvider && registry.get(requestedProvider)) {
-                registry.setDefault(requestedProvider);
-            }
-            else if (registry.get('openai')) {
-                registry.setDefault('openai');
-            }
-            else if (registry.get('cohere')) {
-                registry.setDefault('cohere');
+async function chatCompletionStream(prompt, onToken) {
+    if (process.env.ANTHROPIC_API_KEY) {
+        const response = await fetch('https://api.anthropic.com/v1/messages', {
+            method: 'POST',
+            headers: {
+                'x-api-key': process.env.ANTHROPIC_API_KEY,
+                'anthropic-version': '2023-06-01',
+                'content-type': 'application/json',
+            },
+            body: JSON.stringify({
+                model: 'claude-sonnet-4-20250514',
+                max_tokens: 4096,
+                stream: true,
+                messages: [{ role: 'user', content: prompt }],
+            }),
+        });
+        if (!response.ok)
+            throw new Error(`Anthropic API error: ${response.status}`);
+        let fullText = '';
+        const reader = response.body?.getReader();
+        if (!reader)
+            throw new Error('No response body');
+        const decoder = new TextDecoder();
+        let buffer = '';
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            buffer += decoder.decode(value, { stream: true });
+            const lines = buffer.split('\n');
+            buffer = lines.pop() || '';
+            for (const line of lines) {
+                if (!line.startsWith('data: '))
+                    continue;
+                const data = line.slice(6);
+                if (data === '[DONE]')
+                    continue;
+                try {
+                    const event = JSON.parse(data);
+                    if (event.type === 'content_block_delta' && event.delta?.text) {
+                        const token = event.delta.text;
+                        fullText += token;
+                        onToken(token);
+                    }
+                }
+                catch {
+                    // Skip malformed JSON
+                }
             }
         }
+        return fullText || 'No response generated';
     }
-    const resolver = new OperationProviderResolver(registry);
-    return resolver.resolveProvider('chat');
+    // Fallback: non-streaming for other providers
+    const result = await chatCompletion(prompt);
+    onToken(result);
+    return result;
 }
 export async function chatWithContext(query, context) {
     // Optimize query to understand intent and select strategy
@@ -79,14 +143,7 @@ USER QUERY:
 
 ${optimizedQuery}`;
     return await retryWithBackoff(async () => {
-        return await cohereCircuitBreaker.execute(async () => {
-            // Get chat provider (respects CODEHERE_AI_PROVIDER)
-            const provider = await getChatProvider();
-            const response = await provider.chat(prompt, {
-                maxTokens: strategy.maxTokens,
-            });
-            return response.text || 'No response generated';
-        });
+        return await chatCompletion(prompt);
     }, {
         maxRetries: 5,
         baseDelay: 2000,
@@ -107,6 +164,29 @@ ${optimizedQuery}`;
         });
     });
 }
+/**
+ * Chat with context — streaming version
+ * Calls onToken for each token as it arrives from the LLM
+ */
+export async function chatWithContextStream(query, context, onToken) {
+    const { optimizedQuery, strategy } = optimizeQuery(query);
+    const optimized = optimizeContext(context, optimizedQuery, strategy.maxTokens, strategy.contextStrategy);
+    const optimizedChunks = optimized.chunks;
+    const contextText = optimizedChunks
+        .map((chunk, idx) => `[Chunk ${idx + 1} from ${chunk.filepath}]\n${chunk.content}`)
+        .join('\n\n---\n\n');
+    const prompt = `You are a strict coding assistant for enterprise environments.
+Use ONLY the provided code context.
+
+CONTEXT:
+
+${contextText}
+
+USER QUERY:
+
+${optimizedQuery}`;
+    return chatCompletionStream(prompt, onToken);
+}
 export async function generateDiff(fileContent, instruction, filepath) {
     const prompt = `You are a code editor. Generate ONLY a unified diff patch that applies cleanly to the file.
 Do not include any explanation, comments, or markdown formatting.
@@ -133,13 +213,9 @@ Instruction: ${instruction}
 
 Return the unified diff patch:`;
     return await retryWithBackoff(async () => {
-        return await cohereCircuitBreaker.execute(async () => {
-            // Get chat provider (respects CODEHERE_AI_PROVIDER)
-            const provider = await getChatProvider();
-            const response = await provider.chat(prompt, {
-                maxTokens: 4000,
-            });
-            let diffText = response.text || '';
+        const responseText = await chatCompletion(prompt);
+        return (() => {
+            let diffText = responseText;
             // Extract diff if wrapped in markdown code blocks
             const diffMatch = diffText.match(/```(?:diff)?\n([\s\S]*?)```/);
             if (diffMatch) {
@@ -155,7 +231,7 @@ Return the unified diff patch:`;
                 }
             }
             return diffText.trim();
-        });
+        })();
     }, {
         maxRetries: 5,
         baseDelay: 2000,

package/dist/domain/services/query-intent-classifier.js

@@ -60,30 +60,6 @@ export class QueryIntentClassifier {
                 return 'multi-file-modify';
             }
         }
-        // EARLY CHECK: Open questions about codebase state (before action intents!)
-        // Must come BEFORE modify/debug/implement to catch "what changed?" correctly
-        const openQuestionPatterns = [
-            /^what\s+(changed|is\s+new|happened|did\s+i|files?\s+changed)/i, // "what changed"
-            /what\s+has\s+(changed|happened|been\s+modified)/i, // "what has changed"
-            /what\s+are\s+the\s+(recent|latest|new)\s+(changes|updates|modifications)/i,
-            /what\s+are\s+the\s+(main|key|important|recent)/i,
-            /how\s+does\s+the\s+(project|codebase|system|app)/i,
-            /how\s+does\s+(it|this)\s+work/i,
-            /tell\s+me\s+about/i,
-            /overview\s+of/i,
-            /summary\s+of/i,
-            /what\s+is\s+this\s+(project|codebase|app|repo)/i,
-            /^what\s+is\s+\w+\??$/i, // "What is X?" without file context
-            /what\s+is\s+this\??$/i, // "What is this?"
-            /show\s+me\s+(recent|latest|new)\s+(changes|updates)/i,
-            /what\s+did\s+(i|we)\s+(change|modify|update)/i,
-            /recently\s+(changed|modified|updated)/i,
-        ];
-        for (const pattern of openQuestionPatterns) {
-            if (pattern.test(query)) {
-                return 'understand'; // Route to ask handler for semantic search
-            }
-        }
         // Refactor intent (single-file)
         if (lowerQuery.includes('refactor') || lowerQuery.includes('rename') ||
             lowerQuery.includes('extract') || lowerQuery.includes('move') ||
@@ -112,21 +88,12 @@ export class QueryIntentClassifier {
             lowerQuery.includes('update') || lowerQuery.includes('edit')) {
             return 'modify';
         }
-        // Explain intent - requires file/function context
-        // Only match if query mentions a specific file, function, or code element
-        const hasFileContext = /\.(ts|js|tsx|jsx|py|go|java|rs|cpp|c|h|json|yaml|yml|md)\b/i.test(query) ||
-            /function|class|interface|type|const|method|component/i.test(lowerQuery) ||
-            /src\/|lib\/|app\/|components\/|utils\/|services\//i.test(query);
-        if (hasFileContext && (lowerQuery.includes('how') || lowerQuery.includes('what') ||
+        // Explain intent
+        if (lowerQuery.includes('how') || lowerQuery.includes('what') ||
             lowerQuery.includes('explain') || lowerQuery.includes('understand') ||
-            lowerQuery.includes('does') || lowerQuery.includes('work'))) {
+            lowerQuery.includes('does') || lowerQuery.includes('work')) {
             return 'explain';
         }
-        // General understanding questions without file context → ask handler
-        if (lowerQuery.includes('how') || lowerQuery.includes('what') ||
-            lowerQuery.includes('explain') || lowerQuery.includes('understand')) {
-            return 'understand';
-        }
         // Review intent
         if (lowerQuery.includes('review') || lowerQuery.includes('check') ||
             lowerQuery.includes('analyze') || lowerQuery.includes('audit')) {

package/dist/embed.js

@@ -2,6 +2,7 @@ import { readFileSync, readdirSync, statSync, existsSync, writeFileSync, mkdirSy
 import { join, relative, dirname } from 'path';
 import { fileURLToPath } from 'url';
 import { config } from 'dotenv';
+// CohereClient is lazy-loaded in getCohereClient() to avoid hard dependency
 import initSqlJs from 'sql.js';
 import { encoding_for_model } from 'tiktoken';
 import { indexParallel } from './parallel-processor.js';
@@ -17,6 +18,22 @@ catch {
     // Fallback
 }
 config(); // Also try current directory
+function detectEmbeddingProvider() {
+    if (process.env.OPENAI_API_KEY)
+        return 'openai';
+    if (process.env.COHERE_API_KEY)
+        return 'cohere';
+    return 'none';
+}
+// Lazy-init Cohere client only when needed
+let _cohereClient = null;
+function getCohereClient() {
+    if (!_cohereClient) {
+        const { CohereClient } = require('cohere-ai');
+        _cohereClient = new CohereClient({ token: process.env.COHERE_API_KEY || '' });
+    }
+    return _cohereClient;
+}
 import { getEmbeddingsDbPath } from './infrastructure/storage/embeddings-path.js';
 /**
  * @deprecated Legacy global DB path - use getEmbeddingsDbPath() instead
@@ -37,14 +54,9 @@ function getLegacyDbPath() {
 // Legacy DB_PATH - only used by deprecated indexRepository() function
 // Active CLI uses indexRepositoryParallel() with per-repo paths
 const DB_PATH = getLegacyDbPath();
-// Token encoder and chunking - tiktoken is OpenAI-specific, use GPT model
-import { getConfigManager } from './infrastructure/config/config-manager.js';
-const embedConfig = getConfigManager();
-const defaultModel = embedConfig.getModel('default') || embedConfig.getPreference('defaultModel');
-const tiktokenModel = (defaultModel && defaultModel.includes('gpt')) ? defaultModel : 'gpt-3.5-turbo';
-const enc = encoding_for_model(tiktokenModel);
-const CHUNK_SIZE = embedConfig.getChunking('chunkSize') || 300; // target tokens per chunk
-const OVERLAP = embedConfig.getChunking('overlap') || 50; // overlap tokens between chunks
+const CHUNK_SIZE = 300; // target tokens per chunk
+const OVERLAP = 50; // overlap tokens between chunks
+const enc = encoding_for_model('gpt-3.5-turbo');
 function shouldIgnorePath(filepath) {
     const ignorePatterns = [
         'node_modules',
@@ -115,85 +127,60 @@ function chunkText(text, targetTokens, overlap) {
     }
     return chunks;
 }
-/**
- * Get embedding provider (supports all providers via registry)
- */
-async function getEmbeddingProvider() {
-    const { ProviderRegistry } = await import('./infrastructure/providers/provider-registry.js');
-    const { OperationProviderResolver } = await import('./infrastructure/providers/operation-provider-resolver.js');
-    const registry = ProviderRegistry.getInstance();
-    // Ensure providers are registered
-    if (!registry.get('cohere') && !registry.get('openai') && !registry.get('fake')) {
-        if (process.env.CODEHERE_FAKE_AI === '1') {
-            const { FakeProvider } = await import('./infrastructure/providers/fake-provider.js');
-            registry.register(new FakeProvider());
-            registry.setDefault('fake');
-        }
-        else {
-            if (process.env.COHERE_API_KEY) {
-                const { CohereProvider } = await import('./infrastructure/providers/cohere-provider.js');
-                registry.register(new CohereProvider());
-            }
-            if (process.env.CODEHERE_OPENAI_API_KEY || process.env.OPENAI_API_KEY) {
-                const { OpenAIProvider } = await import('./infrastructure/providers/openai-provider.js');
-                registry.register(new OpenAIProvider());
-            }
-            if (process.env.OPENROUTER_API_KEY) {
-                const { OpenRouterProvider } = await import('./infrastructure/providers/openrouter-provider.js');
-                registry.register(new OpenRouterProvider());
-            }
-            // Set default based on CODEHERE_AI_PROVIDER
-            const requestedProvider = process.env.CODEHERE_AI_PROVIDER?.toLowerCase();
-            if (requestedProvider && registry.get(requestedProvider)) {
-                registry.setDefault(requestedProvider);
-            }
-            else if (registry.get('openai')) {
-                registry.setDefault('openai');
-            }
-            else if (registry.get('cohere')) {
-                registry.setDefault('cohere');
-            }
-        }
-    }
-    const resolver = new OperationProviderResolver(registry);
-    // Special handling for OpenRouter: fallback to OpenAI or Cohere for embeddings
-    const currentDefault = registry.getDefault();
-    if (currentDefault?.id === 'openrouter') {
-        if (registry.get('openai')?.capabilities.embedding) {
-            return registry.get('openai');
-        }
-        if (registry.get('cohere')?.capabilities.embedding) {
-            return registry.get('cohere');
-        }
-        throw new Error('OpenRouter doesn\'t support embeddings. Please set up OpenAI or Cohere:\n' +
-            '  export CODEHERE_OPENAI_API_KEY="sk-..."\n' +
-            '  or\n' +
-            '  export COHERE_API_KEY="..."\n');
+async function embedTextOpenAI(text) {
+    const response = await fetch('https://api.openai.com/v1/embeddings', {
+        method: 'POST',
+        headers: {
+            'Authorization': `Bearer ${process.env.OPENAI_API_KEY}`,
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({
+            input: text,
+            model: 'text-embedding-3-small',
+        }),
+    });
+    if (!response.ok) {
+        const errText = await response.text();
+        throw new Error(`OpenAI embedding error: ${response.status} ${errText}`);
     }
-    return resolver.resolveProvider('embedding');
+    const data = await response.json();
+    return data.data?.[0]?.embedding || [];
+}
+async function embedTextCohere(text) {
+    const cohere = getCohereClient();
+    const response = await cohere.embed({
+        texts: [text],
+        model: 'embed-english-v3.0',
+        inputType: 'search_document',
+    });
+    const embeddings = Array.isArray(response.embeddings)
+        ? response.embeddings
+        : response.embeddings.embeddings || [];
+    return embeddings[0] || [];
 }
 async function embedText(text, retries = 3) {
-    const provider = await getEmbeddingProvider();
+    const provider = detectEmbeddingProvider();
+    if (provider === 'none') {
+        throw new Error('No embedding API key found. Set OPENAI_API_KEY or COHERE_API_KEY to use index/ask/fix commands.');
+    }
     for (let attempt = 0; attempt < retries; attempt++) {
         try {
-            // Use provider's embed method
-            const embedding = await provider.embed(text);
-            // Handle both single embedding and array of embeddings
-            const resultVector = Array.isArray(embedding[0])
-                ? embedding[0]
-                : embedding;
-            return resultVector;
+            if (provider === 'openai') {
+                return await embedTextOpenAI(text);
+            }
+            else {
+                return await embedTextCohere(text);
+            }
         }
         catch (error) {
             const isRateLimit = error?.status === 429 || error?.message?.includes('429') || error?.message?.includes('rate limit');
             if (isRateLimit && attempt < retries - 1) {
-                // Exponential backoff: wait 2^attempt seconds, with a max of 60 seconds
                 const waitTime = Math.min(Math.pow(2, attempt) * 1000, 60000);
-                console.log(warning(`Rate limited, waiting ${waitTime / 1000}s before retry ${attempt + 1}/${retries}...`));
+                console.log(warning(`Rate limited, waiting ${waitTime / 1000}s before retry...`));
                 await new Promise(resolve => setTimeout(resolve, waitTime));
                 continue;
             }
-            throw new Error(`Embedding error: ${error instanceof Error ? error.message : String(error)}`);
+            throw new Error(`Embedding error (${provider}): ${error instanceof Error ? error.message : String(error)}`);
         }
     }
     throw new Error('Embedding failed after retries');