codehere 0.1.0 → 0.2.0

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

@@ -0,0 +1,711 @@
+/**
+ * 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';
+export class IntelligentRouter {
+    intentClassifier;
+    aiService;
+    memoryStream;
+    constructor(intentClassifier, aiService, memoryStream) {
+        this.intentClassifier = intentClassifier || new QueryIntentClassifier();
+        this.aiService = aiService;
+        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(', ')}`,
+            };
+        }
+        // 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) {
+            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);
+            }
+        }
+        // 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')) {
+            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,
+            };
+        }
+        // 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
+     * 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');
+            const repo = container.embeddingRepository;
+            // 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');
+            const useCase = container.askQuestionUseCase;
+            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');
+            const explainWorkflow = new ExplainWorkflow(container.embeddingRepository, 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