codehere 0.3.0 → 0.5.0-alpha

package/dist/application/services/intelligent-router.js

@@ -6,6 +6,9 @@
  */
 import { QueryIntentClassifier } from '../../domain/services/query-intent-classifier.js';
 import { validateQuery } from '../../infrastructure/security/input-validator.js';
+import { executionTracer } from '../../infrastructure/observability/execution-tracer.js';
+import { agentFeedbackManager } from '../../infrastructure/validation/agent-feedback.js';
+import { findCodebaseRoot } from '../../domain/services/codebase-detector.js';
 export class IntelligentRouter {
     intentClassifier;
     aiService;
@@ -16,104 +19,351 @@ export class IntelligentRouter {
         this.memoryStream = memoryStream;
     }
     async route(request) {
-        // Validate input
-        const validation = validateQuery(request.query);
-        if (!validation.valid) {
-            return {
-                intent: 'error',
-                action: 'general',
-                result: null,
-                success: false,
-                error: `Invalid query: ${validation.errors.join(', ')}`,
+        // Start routing trace
+        const codebaseInfo = findCodebaseRoot(process.cwd());
+        const routingRunId = executionTracer.startRun('intelligent-router', {
+            query: request.query,
+            codebaseId: codebaseInfo?.codebaseId || codebaseInfo?.rootPath,
+        });
+        // Track routing decision data
+        let routingDecision;
+        try {
+            // Validate input
+            const validation = validateQuery(request.query);
+            if (!validation.valid) {
+                executionTracer.endRun();
+                return {
+                    intent: 'error',
+                    action: 'general',
+                    result: null,
+                    success: false,
+                    error: `Invalid query: ${validation.errors.join(', ')}`,
+                    routingRunId,
+                };
+            }
+            // Use sanitized query if validation found issues
+            let query = (validation.sanitized || request.query).trim();
+            // 2. Classify intent FIRST (needed for conversation tracking)
+            const classifiedIntent = this.intentClassifier.classify(query);
+            // Record intent classification
+            executionTracer.trace({
+                operationType: 'code_analysis',
+                operationName: 'intent_classification',
+                input: { query },
+                output: { intent: classifiedIntent },
+                metadata: {
+                    classifier: 'QueryIntentClassifier',
+                },
+            });
+            // Resolve conversation references if we have history
+            let resolvedQuery = query;
+            let sessionId;
+            let lastIntent;
+            // PHASE 1 FIX: Get last intent from request context (passed from session)
+            // This is the most reliable source since it's the actual conversation history
+            if (request.context?.conversationHistory && request.context.conversationHistory.length > 0) {
+                const lastHistoryItem = request.context.conversationHistory[request.context.conversationHistory.length - 1];
+                lastIntent = lastHistoryItem.intent;
+            }
+            if (request.context?.conversationHistory && request.context.conversationHistory.length > 0) {
+                const { conversationContextManager } = await import('../../infrastructure/context/conversation-context.js');
+                sessionId = request.context.sessionId || 'default-session';
+                // Resolve references in query (e.g., "it", "that", "the previous")
+                resolvedQuery = conversationContextManager.resolveReferences(sessionId, query);
+                // Extract entities for context tracking
+                const entities = conversationContextManager.extractEntities(resolvedQuery);
+                // Store original query turn (will be updated with response after routing)
+                conversationContextManager.addTurn(sessionId, query, '', entities, classifiedIntent);
+            }
+            // Use resolved query for processing
+            query = resolvedQuery;
+            // 1. MEMORY-AWARE: Retrieve relevant memories to inform routing decision
+            let memories = [];
+            let memoryInformedIntent = null;
+            if (this.memoryStream) {
+                try {
+                    // Retrieve memories relevant to this query
+                    memories = await this.memoryStream.retrieve(query, 10);
+                    // If we have memories, use them to inform intent classification
+                    if (memories.length > 0 && this.aiService) {
+                        memoryInformedIntent = await this.classifyIntentWithMemory(query, memories);
+                    }
+                }
+                catch (error) {
+                    // Fallback to basic classification if memory retrieval fails
+                    console.warn('Memory retrieval failed, using basic classification:', error);
+                }
+            }
+            // CRITICAL: Compound instructions (numbered steps) MUST route to Planning Module
+            // Check this BEFORE memory-informed intent to prevent override
+            const isCompoundInstruction = query.includes('\n') && /\d+\.\s+[^\n]+\n\s*\d+\.\s+/.test(query);
+            // Use memory-informed intent ONLY if not a compound instruction
+            const intent = isCompoundInstruction && classifiedIntent === 'multi-file-modify'
+                ? 'multi-file-modify' // Force compound instructions to Planning Module
+                : (memoryInformedIntent || classifiedIntent);
+            const symbols = this.intentClassifier.extractSymbols(query);
+            // Determine which action/agent will be selected based on intent
+            const actionMap = {
+                'explain': 'explain',
+                'multi-file-modify': 'orchestrate',
+                'modify': 'edit',
+                'debug': 'edit',
+                'implement': 'edit',
+                'index': 'index',
+                'plan': 'plan',
+                'find': 'ask',
+                'understand': 'ask',
+                'general': 'ask',
             };
-        }
-        // Use sanitized query if validation found issues
-        const query = (validation.sanitized || request.query).trim();
-        // 1. MEMORY-AWARE: Retrieve relevant memories to inform routing decision
-        let memories = [];
-        let memoryInformedIntent = null;
-        if (this.memoryStream) {
+            const selectedAction = actionMap[intent] || 'ask';
+            const selectedAgent = selectedAction === 'orchestrate' ? 'multi-agent-orchestrator' :
+                selectedAction === 'plan' ? 'planning-agent' :
+                    selectedAction === 'react' ? 'react-orchestration' :
+                        selectedAction === 'edit' ? 'edit-file-use-case' :
+                            selectedAction === 'explain' ? 'explain-file-use-case' :
+                                selectedAction === 'index' ? 'index-codebase-use-case' :
+                                    'ask-question-use-case';
+            // Calculate confidence score (heuristic)
+            let confidence = 0.8; // Default confidence
+            if (memoryInformedIntent && memoryInformedIntent === classifiedIntent) {
+                confidence = 0.95; // High confidence when memory and classifier agree
+            }
+            else if (memoryInformedIntent) {
+                confidence = 0.85; // Good confidence with memory override
+            }
+            else if (isCompoundInstruction) {
+                confidence = 0.9; // High confidence for compound instructions
+            }
+            // Build selection reason
+            const selectionReason = isCompoundInstruction
+                ? 'Compound instruction detected - routing to orchestration'
+                : memoryInformedIntent && memoryInformedIntent !== classifiedIntent
+                    ? `Memory-informed routing: ${classifiedIntent} → ${memoryInformedIntent}`
+                    : `Intent classification: ${intent}`;
+            // Track alternatives considered
+            const alternatives = Object.keys(actionMap)
+                .filter(k => actionMap[k] !== selectedAction)
+                .map(k => actionMap[k])
+                .filter((v, i, arr) => arr.indexOf(v) === i) // Deduplicate
+                .slice(0, 3); // Top 3 alternatives
+            // Record routing decision
+            routingDecision = {
+                confidence,
+                selectedAgent,
+                selectionReason,
+                alternatives,
+            };
+            // Trace routing decision
+            executionTracer.trace({
+                operationType: 'code_analysis',
+                operationName: 'routing_decision',
+                input: { query, intent, classifiedIntent, memoryInformedIntent },
+                output: { selectedAction, selectedAgent, confidence },
+                metadata: {
+                    intent,
+                    selectedAction,
+                    selectedAgent,
+                    confidence,
+                    memoryInformed: !!memoryInformedIntent,
+                    memoriesUsed: memories.length,
+                    compoundInstruction: isCompoundInstruction,
+                },
+            });
+            // P0 FIX: Detect conversational follow-ups and skip index check
+            // Check if query is conversational (no code keywords, no file paths, questions/statements)
+            const hasCodeKeywords = /\b(src|lib|test|\.ts|\.js|\.py|\.java|file|function|class|import|export|require|module|package)\b/i.test(query);
+            const isFilePath = /^[A-Z][a-z]+\.(ts|js|py|java|go|rs|rb|php)$/.test(query) || /[\w\/\-\.]+\.(ts|js|tsx|jsx|json|md|yaml|yml|txt|py|go|rs|java|cpp|h|hpp)/.test(query);
+            const isQuestion = /^(what|how|where|when|why|can|could|should|would|do|does|is|are|will)\b/i.test(query.trim());
+            const isConversationalPhrase = /^(i want|i need|i should|i don't|i can't|let me|help me|what should|how should)\b/i.test(query.trim());
+            // P0 FIX: Detect conversational follow-ups - either from history OR from query pattern
+            // If query has conversational patterns and no code keywords, treat as conversational regardless of intent
+            const isConversationalFollowup = (
+            // Pattern-based detection (most reliable)
+            (isQuestion || isConversationalPhrase) &&
+                !hasCodeKeywords &&
+                !isFilePath) || (
+            // History-based detection
+            (lastIntent === 'plan' || intent === 'plan' || intent === 'general') &&
+                !hasCodeKeywords &&
+                !isFilePath &&
+                (isQuestion || isConversationalPhrase));
+            // Debug logging for compound instructions
+            if (isCompoundInstruction) {
+                console.log(`[IntelligentRouter] Compound instruction detected. Classified: ${classifiedIntent}, Memory: ${memoryInformedIntent}, Using: ${intent}`);
+            }
+            // 3. Check if indexing is needed
+            // CRITICAL: Only require index for code-specific queries (find, understand, explain)
+            // Planning, brainstorming, and product queries should work without index
+            const needsIndex = await this.checkIfIndexingNeeded(request.context);
+            const codeSpecificIntents = ['find', 'understand', 'explain', 'modify', 'debug', 'implement', 'multi-file-modify'];
+            // Skip index check for conversational follow-ups and non-code intents
+            const requiresIndex = !isConversationalFollowup && needsIndex && codeSpecificIntents.includes(intent);
+            // Handle indexing first if needed (only for code-specific queries)
+            if (requiresIndex) {
+                executionTracer.endRun();
+                // Record routing decision feedback
+                try {
+                    agentFeedbackManager.recordFeedback({
+                        runId: routingRunId,
+                        agentName: 'intelligent-router',
+                        operation: 'route',
+                        query: request.query,
+                        outcome: 'failure',
+                        userAction: 'not_required', // Error case - no review flow
+                        errors: ['Indexing required'],
+                    });
+                }
+                catch {
+                    // Non-blocking
+                }
+                return {
+                    intent: 'index',
+                    action: 'index',
+                    result: { message: 'Indexing required. Please run: codehere index' },
+                    success: false,
+                    message: 'Codebase not indexed. Run "codehere index" first, then try again.',
+                    memoriesUsed: memories.length,
+                    routingDecision,
+                    routingRunId,
+                };
+            }
+            // Route based on intent (pass memories for context)
+            let routingResult;
             try {
-                // Retrieve memories relevant to this query
-                memories = await this.memoryStream.retrieve(query, 10);
-                // If we have memories, use them to inform intent classification
-                if (memories.length > 0 && this.aiService) {
-                    memoryInformedIntent = await this.classifyIntentWithMemory(query, memories);
+                switch (intent) {
+                    case 'explain':
+                        // Use deterministic workflow for faster performance (no ReAct overhead)
+                        routingResult = await this.handleExplainWithWorkflow(query, symbols, memories);
+                        break;
+                    case 'multi-file-modify':
+                        // Multi-file operations require planning AND execution
+                        routingResult = await this.handleOrchestrate(query, memories);
+                        break;
+                    case 'modify':
+                    case 'debug': // 'fix' maps to 'debug'
+                    case 'implement':
+                        routingResult = await this.handleEdit(query, symbols, memories);
+                        break;
+                    case 'index':
+                        routingResult = await this.handleIndex(query);
+                        break;
+                    case 'plan':
+                        // Complex goals need planning
+                        routingResult = await this.handlePlan(query, memories);
+                        // PHASE 1 FIX: Check conversation context - if last intent was non-code, skip code search
+                        const nonCodeIntents = ['plan', 'general', 'product', 'business'];
+                        const isFollowUpToNonCode = lastIntent && nonCodeIntents.includes(lastIntent);
+                        // Also check if query is clearly conversational (not code-related) in empty directory
+                        const isEmptyDirectory = await this.checkIfIndexingNeeded(request.context);
+                        const isConversationalQuery = !query.toLowerCase().match(/\b(code|file|function|class|variable|import|export|module|package)\b/);
+                        // If this is a follow-up to a non-code query OR a conversational query in empty directory, provide conversational response
+                        if (isFollowUpToNonCode || (isEmptyDirectory && isConversationalQuery)) {
+                            routingResult = await this.handleConversationalResponse(query, memories, lastIntent);
+                        }
+                        break;
+                    case 'find':
+                    case 'understand':
+                    case 'general':
+                        // CRITICAL FIX: Simple questions should NEVER use ReAct
+                        // Only use ReAct for truly complex multi-step queries
+                        // Simple questions (explain, find, understand) go directly to AskQuestionUseCase
+                        if (this.isSimpleQuestion(query)) {
+                            routingResult = await this.handleAsk(query, memories);
+                        }
+                        else {
+                            // For complex queries, check if ReAct is appropriate
+                            const shouldUseReAct = this.shouldUseReAct(query, memories);
+                            if (shouldUseReAct) {
+                                routingResult = await this.handleReAct(query, memories);
+                            }
+                            else {
+                                // Default to AskQuestion for understand/general queries
+                                routingResult = await this.handleAsk(query, memories);
+                            }
+                        }
+                        break;
+                    default:
+                        // CRITICAL FIX: Default to AskQuestion, not ReAct
+                        routingResult = await this.handleAsk(query, memories);
+                        break;
                 }
+                // Attach routing decision to result
+                routingResult.routingDecision = routingDecision;
+                routingResult.routingRunId = routingRunId;
+                // End routing trace
+                executionTracer.endRun();
+                // Record routing feedback
+                try {
+                    agentFeedbackManager.recordFeedback({
+                        runId: routingRunId,
+                        agentName: 'intelligent-router',
+                        operation: 'route',
+                        query: request.query,
+                        outcome: routingResult.success ? 'success' : 'failure',
+                        userAction: 'not_required', // Internal routing - no review flow
+                        errors: routingResult.error ? [routingResult.error] : undefined,
+                    });
+                }
+                catch {
+                    // Non-blocking
+                }
+                return routingResult;
             }
             catch (error) {
-                // Fallback to basic classification if memory retrieval fails
-                console.warn('Memory retrieval failed, using basic classification:', error);
+                // End run on error
+                executionTracer.endRun();
+                // Record failure
+                try {
+                    agentFeedbackManager.recordFeedback({
+                        runId: routingRunId,
+                        agentName: 'intelligent-router',
+                        operation: 'route',
+                        query: request.query,
+                        outcome: 'failure',
+                        userAction: 'not_required', // Error case - no review flow
+                        errors: [error instanceof Error ? error.message : String(error)],
+                    });
+                }
+                catch {
+                    // Non-blocking
+                }
+                return {
+                    intent,
+                    action: selectedAction === 'orchestrate' ? 'general' : selectedAction,
+                    result: null,
+                    success: false,
+                    error: error instanceof Error ? error.message : String(error),
+                    routingDecision,
+                    routingRunId,
+                };
             }
         }
-        // 2. Classify intent (check for compound instructions FIRST, before memory)
-        const classifiedIntent = this.intentClassifier.classify(query);
-        // CRITICAL: Compound instructions (numbered steps) MUST route to Planning Module
-        // Check this BEFORE memory-informed intent to prevent override
-        const isCompoundInstruction = query.includes('\n') && /\d+\.\s+[^\n]+\n\s*\d+\.\s+/.test(query);
-        // Use memory-informed intent ONLY if not a compound instruction
-        const intent = isCompoundInstruction && classifiedIntent === 'multi-file-modify'
-            ? 'multi-file-modify' // Force compound instructions to Planning Module
-            : (memoryInformedIntent || classifiedIntent);
-        const symbols = this.intentClassifier.extractSymbols(query);
-        // Debug logging for compound instructions
-        if (isCompoundInstruction) {
-            console.log(`[IntelligentRouter] Compound instruction detected. Classified: ${classifiedIntent}, Memory: ${memoryInformedIntent}, Using: ${intent}`);
-        }
-        // 3. Check if indexing is needed
-        const needsIndex = await this.checkIfIndexingNeeded(request.context);
-        // Handle indexing first if needed
-        if (needsIndex && (intent === 'find' || intent === 'understand' || intent === 'explain')) {
+        catch (outerError) {
+            // Catch any errors from the outer try block (validation, classification, etc.)
+            executionTracer.endRun();
+            try {
+                agentFeedbackManager.recordFeedback({
+                    runId: routingRunId,
+                    agentName: 'intelligent-router',
+                    operation: 'route',
+                    query: request.query,
+                    outcome: 'failure',
+                    userAction: 'not_required', // Error case - no review flow
+                    errors: [outerError instanceof Error ? outerError.message : String(outerError)],
+                });
+            }
+            catch {
+                // Non-blocking
+            }
             return {
-                intent: 'index',
-                action: 'index',
-                result: { message: 'Indexing required. Please run: codehere index' },
+                intent: 'error',
+                action: 'general',
+                result: null,
                 success: false,
-                message: 'Codebase not indexed. Run "codehere index" first, then try again.',
-                memoriesUsed: memories.length,
+                error: outerError instanceof Error ? outerError.message : String(outerError),
+                routingRunId,
             };
         }
-        // Route based on intent (pass memories for context)
-        switch (intent) {
-            case 'explain':
-                // Use deterministic workflow for faster performance (no ReAct overhead)
-                return await this.handleExplainWithWorkflow(query, symbols, memories);
-            case 'multi-file-modify':
-                // Multi-file operations require planning AND execution
-                return await this.handleOrchestrate(query, memories);
-            case 'modify':
-            case 'debug': // 'fix' maps to 'debug'
-            case 'implement':
-                return await this.handleEdit(query, symbols, memories);
-            case 'index':
-                return await this.handleIndex(query);
-            case 'plan':
-                // Complex goals need planning
-                return await this.handlePlan(query, memories);
-            case 'find':
-                // For "find" queries, use AskQuestion to search the codebase
-                return await this.handleAsk(query, memories);
-            case 'understand':
-            case 'general':
-                // CRITICAL FIX: Simple questions should NEVER use ReAct
-                // Only use ReAct for truly complex multi-step queries
-                // Simple questions (explain, find, understand) go directly to AskQuestionUseCase
-                if (this.isSimpleQuestion(query)) {
-                    return await this.handleAsk(query, memories);
-                }
-                // For complex queries, check if ReAct is appropriate
-                const shouldUseReAct = this.shouldUseReAct(query, memories);
-                if (shouldUseReAct) {
-                    return await this.handleReAct(query, memories);
-                }
-                // Default to AskQuestion for understand/general queries
-                return await this.handleAsk(query, memories);
-            default:
-                // CRITICAL FIX: Default to AskQuestion, not ReAct
-                // ReAct should only be used when explicitly needed
-                // Most queries are simple and should use AskQuestionUseCase
-                return await this.handleAsk(query, memories);
-        }
     }
     /**
      * Classify intent using AI and memory context
@@ -247,12 +497,63 @@ Respond with ONLY the intent word (e.g., "explain", "plan", "understand"):`;
         // Requires multiple steps if 2+ indicators or very long query
         return indicatorCount >= 2 || query.split(' ').length > 20;
     }
+    /**
+     * Handle conversational response for follow-up queries after non-code intents
+     * Skips code search and provides contextual answer
+     */
+    async handleConversationalResponse(query, memories, lastIntent) {
+        if (!this.aiService) {
+            return {
+                intent: 'general',
+                action: 'ask',
+                result: null,
+                success: false,
+                error: 'AI service not available',
+                memoriesUsed: memories?.length || 0,
+            };
+        }
+        try {
+            // Build conversational prompt without code context
+            const memoryContext = memories && memories.length > 0
+                ? `\n\nRelevant context from previous interactions:\n${memories.slice(0, 3).map((m, i) => `${i + 1}. ${m.description}`).join('\n')}`
+                : '';
+            const conversationContext = lastIntent === 'plan'
+                ? '\n\nNote: The user previously asked about planning or brainstorming. This is a follow-up question.'
+                : '';
+            const prompt = `You are a helpful AI assistant. The user is asking a follow-up question after a previous conversation about ${lastIntent || 'general topics'}.
+
+User's question: "${query}"
+${memoryContext}${conversationContext}
+
+Provide a helpful, conversational response. Do NOT search for code unless the user explicitly asks about code or files.`;
+            const response = await this.aiService.chat(prompt, []);
+            return {
+                intent: 'general',
+                action: 'ask',
+                result: { answer: response, chunks: [] },
+                success: true,
+                message: response,
+                memoriesUsed: memories?.length || 0,
+            };
+        }
+        catch (error) {
+            return {
+                intent: 'general',
+                action: 'ask',
+                result: null,
+                success: false,
+                error: error instanceof Error ? error.message : String(error),
+                memoriesUsed: memories?.length || 0,
+            };
+        }
+    }
     async checkIfIndexingNeeded(context) {
         if (context?.hasIndex === false)
             return true;
         try {
             const { container } = await import('./dependency-container.js');
-            const repo = container.embeddingRepository;
+            // Use per-repo embedding repository for codebase isolation
+            const repo = container.getEmbeddingRepository(process.cwd());
             // Check if any embeddings exist
             const testSearch = await repo.searchWithEmbedding([0.1], 1);
             return testSearch.length === 0;
@@ -264,7 +565,8 @@ Respond with ONLY the intent word (e.g., "explain", "plan", "understand"):`;
     async handleAsk(query, memories) {
         try {
             const { container } = await import('./dependency-container.js');
-            const useCase = container.askQuestionUseCase;
+            // Use per-repo use case for codebase isolation
+            const useCase = container.getAskQuestionUseCase(process.cwd());
             const result = await useCase.execute({ query, maxResults: 15 });
             // Record successful routing in memory
             if (this.memoryStream && memories && memories.length > 0) {
@@ -299,7 +601,8 @@ Respond with ONLY the intent word (e.g., "explain", "plan", "understand"):`;
         try {
             const { container } = await import('./dependency-container.js');
             const { ExplainWorkflow } = await import('../workflows/deterministic-workflows.js');
-            const explainWorkflow = new ExplainWorkflow(container.embeddingRepository, container.aiService);
+            // Use per-repo embedding repository for codebase isolation
+            const explainWorkflow = new ExplainWorkflow(container.getEmbeddingRepository(process.cwd()), container.aiService);
             const workflowResult = await explainWorkflow.execute(query);
             if (workflowResult.success) {
                 return {
@@ -641,7 +944,6 @@ Respond with ONLY the intent word (e.g., "explain", "plan", "understand"):`;
      */
     fastSecurityCheck(query) {
         // Fast pattern-based check for obvious security issues (synchronous, no API calls)
-        const lower = query.toLowerCase();
         // Dangerous patterns that should be blocked immediately
         const dangerousPatterns = [
             { pattern: /execute.*user.*input|eval.*user|exec.*user/i, reason: 'Security vulnerabilities detected: 1 critical, 0 high severity findings. Review and fix before applying.' },