codehere 0.2.2 → 0.3.0-rc.10

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

@@ -1,934 +0,0 @@
-/**
- * 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
- */
-const DEBUG = process.env.CODEHERE_DEBUG === '1';
-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',
-                'general': 'ask',
-            };
-            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) {
-                if (DEBUG)
-                    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)
-            // Design: default to ask (LLM answers anything). Only use specialized
-            // handlers when the user explicitly targets a file or action.
-            let routingResult;
-            try {
-                switch (intent) {
-                    case 'explain': {
-                        // Only use file-explain if the query contains a real file path
-                        const filepath = this.extractFilepath(query);
-                        if (filepath) {
-                            routingResult = await this.handleExplainWithWorkflow(query, symbols, memories);
-                        }
-                        else {
-                            // No file path → treat as a question about the codebase
-                            routingResult = await this.handleAsk(query, memories);
-                        }
-                        break;
-                    }
-                    case 'modify':
-                    case 'debug':
-                    case 'implement': {
-                        // Only route to edit if query references a specific file
-                        const editPath = this.extractFilepath(query);
-                        if (editPath) {
-                            routingResult = await this.handleEdit(query, symbols, memories);
-                        }
-                        else {
-                            // "fix the auth" without a file → ask (LLM explains what to do)
-                            routingResult = await this.handleAsk(query, memories);
-                        }
-                        break;
-                    }
-                    case 'multi-file-modify':
-                        routingResult = await this.handleOrchestrate(query, memories);
-                        break;
-                    case 'index':
-                        routingResult = await this.handleIndex(query);
-                        break;
-                    case 'plan':
-                        routingResult = await this.handlePlan(query, memories);
-                        break;
-                    default:
-                        // Everything else → ask. The LLM is smart enough.
-                        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) {
-        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,
-                };
-            }
-        }
-        if (DEBUG)
-            console.log(`[IntelligentRouter] Edit query: ${query}`);
-        if (DEBUG)
-            console.log(`[IntelligentRouter] Extracted filepath: ${filepath || 'none'}`);
-        if (DEBUG)
-            console.log(`[IntelligentRouter] Extracted instruction: ${instruction || 'none'}`);
-        if (DEBUG)
-            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
-            });
-            if (DEBUG)
-                console.log(`[IntelligentRouter] Filtered symbols: ${prioritizedSymbols.join(', ')}`);
-            if (prioritizedSymbols.length > 0) {
-                if (DEBUG)
-                    console.log(`[IntelligentRouter] Searching for file containing symbol: ${prioritizedSymbols[0]}`);
-                filepath = await this.findFileBySymbol(prioritizedSymbols[0], query);
-                if (DEBUG)
-                    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,
-            };
-        }
-        if (DEBUG)
-            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 {
-            if (DEBUG)
-                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) {
-                if (DEBUG)
-                    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
-                        }
-                        if (DEBUG)
-                            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) {
-                        if (DEBUG)
-                            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