codehere 0.1.1

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

@@ -0,0 +1,942 @@
+/**
+ * Intelligent Query Router
+ * Understands user intent and routes to appropriate use cases
+ * Provides seamless experience - user just types what they want
+ * MEMORY-AWARE: Uses Memory Stream to inform routing decisions
+ */
+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;
+    memoryStream;
+    constructor(intentClassifier, aiService, memoryStream) {
+        this.intentClassifier = intentClassifier || new QueryIntentClassifier();
+        this.aiService = aiService;
+        this.memoryStream = memoryStream;
+    }
+    async route(request) {
+        // 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;
+            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', // Open questions → semantic search
+                'general': 'ask',
+                'review': 'ask', // Code review questions → semantic search
+                'test': 'ask', // Test-related questions → semantic search
+                'refactor': 'edit', // Single-file refactoring
+            };
+            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,
+                },
+            });
+            // 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')) {
+                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 {
+                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);
+                        break;
+                    case 'find':
+                        // For "find" queries, use AskQuestion to search the codebase
+                        routingResult = await this.handleAsk(query, memories);
+                        break;
+                    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) {
+                // 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,
+                };
+            }
+        }
+        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: 'error',
+                action: 'general',
+                result: null,
+                success: false,
+                error: outerError instanceof Error ? outerError.message : String(outerError),
+                routingRunId,
+            };
+        }
+    }
+    /**
+     * Classify intent using AI and memory context
+     * More accurate than keyword-based classification
+     */
+    async classifyIntentWithMemory(query, memories) {
+        if (!this.aiService) {
+            return this.intentClassifier.classify(query);
+        }
+        // Build memory context
+        const memoryContext = memories
+            .slice(0, 5) // Use top 5 most relevant
+            .map((m, i) => `${i + 1}. ${m.description} (${m.type})`)
+            .join('\n');
+        const prompt = `Classify the intent of this user query. Consider past experiences that might inform the classification.
+
+Query: "${query}"
+
+Relevant Past Experiences:
+${memoryContext}
+
+Classify the intent as ONE of: explain, refactor, debug, implement, understand, find, modify, multi-file-modify, index, review, test, plan, general
+
+Consider:
+- If similar queries were handled successfully before, use that intent
+- If past experiences suggest a specific approach, use that
+- If the query is complex and requires planning, use "plan"
+- If it's a simple question, use "understand" or "find"
+
+Respond with ONLY the intent word (e.g., "explain", "plan", "understand"):`;
+        try {
+            const response = await this.aiService.chat(prompt, []);
+            const intent = response.trim().toLowerCase().split(/\s+/)[0];
+            // Validate intent
+            const validIntents = ['explain', 'refactor', 'debug', 'implement', 'understand', 'find', 'modify', 'multi-file-modify', 'index', 'review', 'test', 'plan', 'general'];
+            if (validIntents.includes(intent)) {
+                return intent;
+            }
+        }
+        catch (error) {
+            // Fallback to keyword-based
+        }
+        return this.intentClassifier.classify(query);
+    }
+    /**
+     * Check if query is a simple question (explain, find, understand)
+     * Simple questions should NEVER use ReAct - they go directly to AskQuestionUseCase
+     */
+    isSimpleQuestion(query) {
+        const lower = query.toLowerCase();
+        // Simple question patterns
+        const simplePatterns = [
+            /^(what|where|how|why|when|who|which|is|are|does|do|can|could|will|would)\s+/i,
+            /^(explain|describe|tell me about|show me|find|locate|search for)/i,
+            /^(what is|what are|where is|where are|how does|how do|how is|how are)/i,
+            /\?$/, // Ends with question mark
+        ];
+        // Check if query matches simple question patterns
+        const isQuestion = simplePatterns.some(pattern => pattern.test(query));
+        // Simple if it's a question AND doesn't require multiple steps
+        const isSingleStep = !this.isComplexQuery(query);
+        return isQuestion && isSingleStep;
+    }
+    /**
+     * Determine if ReAct should be used based on query complexity and past experiences
+     * CRITICAL: Only use ReAct for truly complex multi-step queries
+     */
+    shouldUseReAct(query, memories) {
+        // NEVER use ReAct for simple questions
+        if (this.isSimpleQuestion(query)) {
+            return false;
+        }
+        // Check query complexity - must be truly complex
+        if (!this.isComplexQuery(query)) {
+            return false;
+        }
+        // Additional check: Query must require multiple tools/steps
+        const requiresMultipleSteps = this.requiresMultipleSteps(query);
+        if (!requiresMultipleSteps) {
+            return false;
+        }
+        // Check memories for similar queries that used ReAct successfully
+        // But only if query is already complex
+        if (memories.length > 0) {
+            const similarQueries = memories.filter(m => {
+                const desc = m.description.toLowerCase();
+                const queryLower = query.toLowerCase();
+                // Check if memory mentions ReAct or similar complex handling
+                return desc.includes('react') ||
+                    desc.includes('complex') ||
+                    desc.includes('multi-step') ||
+                    (desc.includes(queryLower.split(' ')[0]) && m.metadata?.action === 'react');
+            });
+            // If we have memories of similar queries using ReAct, use it
+            if (similarQueries.length > 0) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * Check if query requires multiple steps/tools
+     */
+    requiresMultipleSteps(query) {
+        const lower = query.toLowerCase();
+        // Multi-step indicators
+        const multiStepIndicators = [
+            'and then',
+            'after that',
+            'also',
+            'first',
+            'second',
+            'third',
+            'finally',
+            'then',
+            'next',
+            'step',
+            'steps',
+            'multiple',
+            'several',
+            'check',
+            'verify',
+            'debug',
+            'fix',
+            'and',
+            'while',
+            'during',
+        ];
+        // Count multi-step indicators
+        const indicatorCount = multiStepIndicators.filter(indicator => lower.includes(indicator)).length;
+        // Requires multiple steps if 2+ indicators or very long query
+        return indicatorCount >= 2 || query.split(' ').length > 20;
+    }
+    async checkIfIndexingNeeded(context) {
+        // Quick mode - bypass indexing entirely, use direct file reading
+        if (context?.quickMode) {
+            return false;
+        }
+        // FAKE_AI mode never needs indexing - for demos and testing
+        if (process.env.CODEHERE_FAKE_AI === '1') {
+            return false;
+        }
+        // Local provider with no embeddings support - skip indexing
+        if (process.env.CODEHERE_AI_PROVIDER === 'local') {
+            return false;
+        }
+        if (context?.hasIndex === false)
+            return true;
+        try {
+            const { container } = await import('./dependency-container.js');
+            // 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;
+        }
+        catch {
+            return true; // Assume needs indexing if check fails
+        }
+    }
+    async handleAsk(query, memories) {
+        try {
+            const { container } = await import('./dependency-container.js');
+            // 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) {
+                await this.memoryStream.recordObservation(`Successfully routed query to AskQuestionUseCase: ${query}`, {
+                    query,
+                    action: 'ask',
+                    memoriesUsed: memories.length,
+                });
+            }
+            return {
+                intent: 'understand',
+                action: 'ask',
+                result,
+                success: result.chunks.length > 0,
+                message: result.answer,
+                memoriesUsed: memories?.length || 0,
+            };
+        }
+        catch (error) {
+            return {
+                intent: 'understand',
+                action: 'ask',
+                result: null,
+                success: false,
+                error: error instanceof Error ? error.message : String(error),
+                memoriesUsed: memories?.length || 0,
+            };
+        }
+    }
+    async handleExplainWithWorkflow(query, symbols, memories) {
+        // Try deterministic workflow first (faster, no ReAct overhead)
+        try {
+            const { container } = await import('./dependency-container.js');
+            const { ExplainWorkflow } = await import('../workflows/deterministic-workflows.js');
+            // 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 {
+                    intent: 'explain',
+                    action: 'explain',
+                    result: workflowResult.result,
+                    success: true,
+                    message: workflowResult.result?.explanation || 'Explanation generated',
+                    memoriesUsed: memories?.length || 0,
+                };
+            }
+        }
+        catch (error) {
+            // Fallback to original implementation if workflow fails
+            console.warn('Workflow failed, falling back to standard explain:', error);
+        }
+        // Fallback to standard explain
+        return await this.handleExplain(query, symbols, memories);
+    }
+    async handleExplain(query, symbols, memories) {
+        // Extract filepath from query
+        const filepath = this.extractFilepath(query);
+        if (!filepath) {
+            // No filepath found, treat as ask query
+            return await this.handleAsk(query, memories);
+        }
+        try {
+            const { container } = await import('./dependency-container.js');
+            const useCase = container.explainFileUseCase;
+            const result = await useCase.execute({ filepath });
+            // Record successful routing
+            if (this.memoryStream && memories && memories.length > 0) {
+                await this.memoryStream.recordObservation(`Successfully routed to ExplainFileUseCase: ${query}`, {
+                    query,
+                    action: 'explain',
+                    filepath,
+                    memoriesUsed: memories.length,
+                });
+            }
+            return {
+                intent: 'explain',
+                action: 'explain',
+                result,
+                success: true,
+                message: result.explanation,
+                memoriesUsed: memories?.length || 0,
+            };
+        }
+        catch (error) {
+            return {
+                intent: 'explain',
+                action: 'explain',
+                result: null,
+                success: false,
+                error: error instanceof Error ? error.message : String(error),
+                memoriesUsed: memories?.length || 0,
+            };
+        }
+    }
+    async handleEdit(query, symbols, memories) {
+        // Extract filepath and instruction
+        let { filepath, instruction } = this.extractEditParams(query);
+        // CRITICAL: Fast security check BEFORE any expensive operations (file search, reading, etc.)
+        // This prevents wasting time and tokens on dangerous code
+        if (instruction) {
+            const securityCheck = await this.fastSecurityCheck(instruction);
+            if (!securityCheck.allowed) {
+                return {
+                    intent: 'edit',
+                    action: 'edit',
+                    result: null,
+                    success: false,
+                    error: securityCheck.reason,
+                    memoriesUsed: memories?.length || 0,
+                };
+            }
+        }
+        console.log(`[IntelligentRouter] Edit query: ${query}`);
+        console.log(`[IntelligentRouter] Extracted filepath: ${filepath || 'none'}`);
+        console.log(`[IntelligentRouter] Extracted instruction: ${instruction || 'none'}`);
+        console.log(`[IntelligentRouter] Symbols found: ${symbols.join(', ')}`);
+        // If no filepath found but we have symbols (class/function names), search for the file
+        if (!filepath && symbols.length > 0) {
+            // Filter out common words and prioritize capitalized names (likely class/function names)
+            const meaningfulSymbols = symbols.filter(s => {
+                const lower = s.toLowerCase();
+                // Exclude common words
+                return !['in', 'to', 'the', 'a', 'an', 'and', 'or', 'of', 'for', 'with', 'from'].includes(lower) &&
+                    s.length > 2; // At least 3 characters
+            });
+            // Prioritize capitalized names (classes) and camelCase (functions)
+            const prioritizedSymbols = meaningfulSymbols.sort((a, b) => {
+                const aIsClass = /^[A-Z]/.test(a);
+                const bIsClass = /^[A-Z]/.test(b);
+                if (aIsClass && !bIsClass)
+                    return -1;
+                if (!aIsClass && bIsClass)
+                    return 1;
+                return b.length - a.length; // Longer names are more specific
+            });
+            console.log(`[IntelligentRouter] Filtered symbols: ${prioritizedSymbols.join(', ')}`);
+            if (prioritizedSymbols.length > 0) {
+                console.log(`[IntelligentRouter] Searching for file containing symbol: ${prioritizedSymbols[0]}`);
+                filepath = await this.findFileBySymbol(prioritizedSymbols[0], query);
+                console.log(`[IntelligentRouter] Found filepath: ${filepath || 'none'}`);
+            }
+        }
+        if (!filepath || !instruction) {
+            console.error(`[IntelligentRouter] Missing filepath or instruction. filepath: ${filepath}, instruction: ${instruction}`);
+            return {
+                intent: 'edit',
+                action: 'edit',
+                result: null,
+                success: false,
+                error: 'Could not extract filepath and instruction from query. Format: "edit <file> <instruction>" or "fix <file> <what to fix>" or mention the class/function name',
+                memoriesUsed: memories?.length || 0,
+            };
+        }
+        console.log(`[IntelligentRouter] Proceeding with edit: ${filepath} - ${instruction}`);
+        try {
+            const { container } = await import('./dependency-container.js');
+            const useCase = container.editFileUseCase;
+            const result = await useCase.execute({ filepath, instruction });
+            // Record successful routing
+            if (this.memoryStream && memories && memories.length > 0) {
+                await this.memoryStream.recordObservation(`Successfully routed to EditFileUseCase: ${query}`, {
+                    query,
+                    action: 'edit',
+                    filepath,
+                    memoriesUsed: memories.length,
+                    success: result.success,
+                });
+            }
+            return {
+                intent: 'edit',
+                action: 'edit',
+                result,
+                success: result.success,
+                message: result.success ? 'Edit applied successfully' : result.error,
+                error: result.error,
+                memoriesUsed: memories?.length || 0,
+            };
+        }
+        catch (error) {
+            return {
+                intent: 'edit',
+                action: 'edit',
+                result: null,
+                success: false,
+                error: error instanceof Error ? error.message : String(error),
+                memoriesUsed: memories?.length || 0,
+            };
+        }
+    }
+    async handleReAct(query, memories) {
+        try {
+            const { container } = await import('./dependency-container.js');
+            const useCase = container.reactOrchestrationUseCase;
+            // Pass memories to ReAct for context
+            const result = await useCase.execute({
+                query,
+                maxTurns: 15,
+                context: {
+                    memories: memories || [],
+                },
+            });
+            // Record successful routing
+            if (this.memoryStream && memories && memories.length > 0) {
+                await this.memoryStream.recordObservation(`Successfully routed complex query to ReAct: ${query}`, {
+                    query,
+                    action: 'react',
+                    memoriesUsed: memories.length,
+                    steps: result.trajectory.steps.length,
+                });
+            }
+            return {
+                intent: 'general',
+                action: 'react',
+                result,
+                success: result.trajectory.success,
+                message: result.answer,
+                memoriesUsed: memories?.length || 0,
+            };
+        }
+        catch (error) {
+            return {
+                intent: 'general',
+                action: 'react',
+                result: null,
+                success: false,
+                error: error instanceof Error ? error.message : String(error),
+                memoriesUsed: memories?.length || 0,
+            };
+        }
+    }
+    async handleIndex(query) {
+        return {
+            intent: 'index',
+            action: 'index',
+            result: { message: 'Use "codehere index" command to index the codebase' },
+            success: false,
+            message: 'To index the codebase, run: codehere index',
+        };
+    }
+    async handlePlan(query, memories) {
+        try {
+            const { container } = await import('./dependency-container.js');
+            const useCase = container.planningUseCase;
+            const result = await useCase.execute({
+                goal: query,
+                planningMode: 'hybrid',
+                context: {
+                // Pass memories for planning context
+                },
+            });
+            // Record successful planning
+            if (this.memoryStream && memories && memories.length > 0) {
+                await this.memoryStream.recordObservation(`Successfully routed to Planning Module: ${query}`, {
+                    query,
+                    action: 'plan',
+                    memoriesUsed: memories.length,
+                    subPlans: result.plan.subPlans.length,
+                });
+            }
+            return {
+                intent: 'plan',
+                action: 'plan',
+                result,
+                success: true,
+                message: `Plan created with ${result.plan.subPlans.length} sub-plans`,
+                memoriesUsed: memories?.length || 0,
+            };
+        }
+        catch (error) {
+            return {
+                intent: 'plan',
+                action: 'plan',
+                result: null,
+                success: false,
+                error: error instanceof Error ? error.message : String(error),
+                memoriesUsed: memories?.length || 0,
+            };
+        }
+    }
+    async handleOrchestrate(query, memories) {
+        try {
+            const { container } = await import('./dependency-container.js');
+            const orchestrator = container.multiAgentOrchestrator;
+            const result = await orchestrator.orchestrate({
+                goal: query,
+                mode: 'full', // Plan + Execute + Validate
+                context: {
+                // Pass memories context if needed
+                },
+            });
+            // Record successful orchestration
+            if (this.memoryStream && memories && memories.length > 0) {
+                await this.memoryStream.recordObservation(`Successfully routed compound instruction to Orchestrator: ${query}`, {
+                    query,
+                    action: 'orchestrate',
+                    memoriesUsed: memories.length,
+                    planSubPlans: result.plan?.subPlans.length || 0,
+                    executionCompleted: result.execution?.completedSubPlans || 0,
+                });
+            }
+            return {
+                intent: 'plan',
+                action: 'plan',
+                result,
+                success: result.success,
+                message: result.message,
+                error: result.success ? undefined : result.message,
+                memoriesUsed: memories?.length || 0,
+            };
+        }
+        catch (error) {
+            return {
+                intent: 'plan',
+                action: 'plan',
+                result: null,
+                success: false,
+                error: error instanceof Error ? error.message : String(error),
+                memoriesUsed: memories?.length || 0,
+            };
+        }
+    }
+    extractFilepath(query) {
+        // Look for file paths in query
+        const patterns = [
+            /(?:file|in|from|at)\s+([^\s]+\.(ts|js|tsx|jsx|py|java|cpp|go|rs|rb|php|vue|svelte|html|css|json|yaml|yml|md|txt|sh|bash))/i,
+            /([a-zA-Z0-9_\-/]+\.(ts|js|tsx|jsx|py|java|cpp|go|rs|rb|php|vue|svelte|html|css|json|yaml|yml|md|txt|sh|bash))/,
+            /src\/[^\s]+/,
+            /\.\/[^\s]+/,
+        ];
+        for (const pattern of patterns) {
+            const match = query.match(pattern);
+            if (match) {
+                return match[1] || match[0];
+            }
+        }
+        return null;
+    }
+    extractEditParams(query) {
+        const filepath = this.extractFilepath(query);
+        if (!filepath) {
+            return { filepath: null, instruction: query };
+        }
+        // Remove filepath from query to get instruction
+        const instruction = query
+            .replace(new RegExp(filepath.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), 'gi'), '')
+            .replace(/(?:edit|fix|modify|change|update|add to|remove from)\s+/i, '')
+            .trim();
+        return { filepath, instruction: instruction || 'Make the requested changes' };
+    }
+    isComplexQuery(query) {
+        const lower = query.toLowerCase();
+        // Complex if it requires multiple steps
+        const complexIndicators = [
+            'and then',
+            'after that',
+            'also',
+            'multiple',
+            'several',
+            'steps',
+            'first',
+            'second',
+            'finally',
+            'create',
+            'build',
+            'implement',
+            'refactor',
+        ];
+        return complexIndicators.some(indicator => lower.includes(indicator)) ||
+            query.split(' ').length > 15; // Long queries are likely complex
+    }
+    /**
+     * Fast security check using pattern matching (before expensive operations)
+     * Synchronous pattern matching - instant rejection for dangerous patterns
+     */
+    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.' },
+            { pattern: /shell.*command|system.*call|process\.exec/i, reason: 'Security vulnerabilities detected: 1 critical, 0 high severity findings. Review and fix before applying.' },
+            { pattern: /bypass.*security|disable.*security|remove.*validation/i, reason: 'Security vulnerabilities detected: 1 critical, 0 high severity findings. Review and fix before applying.' },
+            { pattern: /hardcode.*password|store.*password.*plaintext|plaintext.*password/i, reason: 'Security vulnerabilities detected: 0 critical, 1 high severity findings. Review and fix before applying.' },
+        ];
+        for (const { pattern, reason } of dangerousPatterns) {
+            if (pattern.test(query)) {
+                return { allowed: false, reason };
+            }
+        }
+        return { allowed: true };
+    }
+    /**
+     * Find file containing a symbol (class/function name)
+     * Uses search to locate the file
+     */
+    async findFileBySymbol(symbol, query) {
+        try {
+            console.log(`[IntelligentRouter] Searching for symbol: ${symbol}`);
+            const { container } = await import('./dependency-container.js');
+            const useCase = container.askQuestionUseCase;
+            // Search for the symbol - try multiple query variations
+            const searchQueries = [
+                `Find ${symbol}`,
+                `file containing ${symbol}`,
+                `Where is ${symbol} defined`,
+                `${symbol} class or function`,
+            ];
+            for (const searchQuery of searchQueries) {
+                console.log(`[IntelligentRouter] Trying search query: ${searchQuery}`);
+                const result = await useCase.execute({ query: searchQuery, maxResults: 5 });
+                // Look for filepath in results
+                if (result.chunks && result.chunks.length > 0) {
+                    // Get the most relevant chunk
+                    const topChunk = result.chunks[0];
+                    if (topChunk && topChunk.filepath) {
+                        // Convert absolute path to relative if needed
+                        let filepath = topChunk.filepath;
+                        const cwd = process.cwd();
+                        if (filepath.startsWith(cwd)) {
+                            filepath = filepath.substring(cwd.length + 1); // Remove leading slash
+                        }
+                        console.log(`[IntelligentRouter] Found filepath from search: ${filepath}`);
+                        return filepath;
+                    }
+                }
+                // Also check answer for filepath mentions
+                if (result.answer) {
+                    const filepathMatch = result.answer.match(/([^\s]+\.(ts|js|tsx|jsx|py|java|cpp|go|rs|rb|php|vue|svelte|html|css|json|yaml|yml|md|txt|sh|bash))/);
+                    if (filepathMatch) {
+                        console.log(`[IntelligentRouter] Found filepath from answer: ${filepathMatch[1]}`);
+                        return filepathMatch[1];
+                    }
+                }
+            }
+            console.warn(`[IntelligentRouter] Could not find file for symbol: ${symbol}`);
+            return null;
+        }
+        catch (error) {
+            console.error(`[IntelligentRouter] Failed to find file by symbol:`, error);
+            return null;
+        }
+    }
+}
+//# sourceMappingURL=intelligent-router.js.map