codehere 0.1.1 → 0.2.2

package/dist/application/agents/planning-agent.js

@@ -85,8 +85,7 @@ export class PlanningAgent {
                 }
             }
             // 4. Generate hierarchical plan with detailed steps (including Git context and patterns)
-            const plan = await this.generateDetailedPlan(request.goal, reflections, relevantMemories, request.context, gitContext, relevantPatterns, [], // relevantKnowledge - not yet implemented
-            request.feedback);
+            const plan = await this.generateDetailedPlan(request.goal, reflections, relevantMemories, request.context, gitContext, relevantPatterns);
             // 5. Assess plan confidence
             const confidence = await this.assessPlanConfidence(plan, relevantMemories);
             // 6. Store plan in memory (with codebase context)
@@ -107,10 +106,7 @@ export class PlanningAgent {
             }
             // Calculate plan metrics for validation
             const planComplexity = plan.metadata?.complexity || 'medium';
-            const unresolvedDependencies = plan.subPlans.filter(sp => {
-                const deps = Array.isArray(sp.dependencies) ? sp.dependencies : [];
-                return deps.some(depId => !plan.subPlans.find(sp2 => sp2.id === depId));
-            });
+            const unresolvedDependencies = plan.subPlans.filter(sp => sp.dependencies.some(depId => !plan.subPlans.find(sp2 => sp2.id === depId)));
             // Complete validation and get summary
             const validationResult = await agentValidationHelper.completeAgentOperation(validationContext, {
                 plan,
@@ -218,7 +214,7 @@ export class PlanningAgent {
     /**
      * Generate detailed hierarchical plan
      */
-    async generateDetailedPlan(goal, reflections, memories, context, gitContext, relevantPatterns = [], relevantKnowledge = [], feedback) {
+    async generateDetailedPlan(goal, reflections, memories, context, gitContext, relevantPatterns = [], relevantKnowledge = []) {
         const memoryContext = memories.map(m => `- ${m.description} (Type: ${m.type})`).join('\n');
         const reflectionContext = reflections.map(r => `- ${r}`).join('\n');
         const fileContext = context?.files && context.files.length > 0
@@ -282,18 +278,10 @@ export class PlanningAgent {
     - Sub-plan 3: "Create src/repositories/user-repository.ts implementing IUserRepository"
     - Sub-plan 4: "Update src/services/user-service.ts to use UserRepository instead of direct data access"
     ` : ''}
-    ` : '';
-        const feedbackContext = feedback ? `
-
-    **IMPORTANT - PREVIOUS ATTEMPT FAILED**:
-    This is a retry. The previous plan failed with this feedback:
-    "${feedback}"
-
-    **You MUST address the issues in the feedback above to create a better plan.**
     ` : '';
         const prompt = `You are a Planning Agent (Architect) for an AI coding system. Your role is to create detailed, step-by-step modification plans.
 
-    Goal: "${goal}"${fileContext}${constraintsContext}${gitContextText}${multiFileGuidance}${feedbackContext}
+    Goal: "${goal}"${fileContext}${constraintsContext}${gitContextText}${multiFileGuidance}
 
     Consider:
     - **Relevant Past Experiences/Memories**:
@@ -349,191 +337,86 @@ export class PlanningAgent {
     ]
 
     JSON only, no other text:`;
-        // Retry logic for JSON parsing failures
-        const maxRetries = 2; // Try original prompt, then 2 retries with reinforced prompts
-        let lastError = null;
-        let response = '';
-        for (let attempt = 0; attempt <= maxRetries; attempt++) {
-            try {
-                // Reinforce JSON requirement on retries
-                let currentPrompt = prompt;
-                if (attempt > 0) {
-                    const reinforcement = `\n\n⚠️ CRITICAL: You MUST respond with ONLY valid JSON array. No explanations, no markdown, no code blocks. Just the raw JSON array starting with [ and ending with ]. Example: [{"id":"subplan_1","description":"...","type":"search",...}]`;
-                    currentPrompt = prompt + reinforcement;
-                }
-                // Add timeout protection for planning calls (120 seconds max - planning can be complex)
-                const timeoutPromise = new Promise((_, reject) => {
-                    setTimeout(() => reject(new Error('Planning API call timed out after 120 seconds')), 120000);
-                });
-                response = await Promise.race([
-                    this.aiService.chat(currentPrompt, []),
-                    timeoutPromise,
-                ]);
-                // Check for empty response
-                if (!response || response.trim().length === 0) {
-                    if (attempt < maxRetries) {
-                        console.warn(`Planning Agent: Empty response on attempt ${attempt + 1}, retrying...`);
-                        continue;
-                    }
-                    console.error('Planning Agent: Empty response from API');
-                    throw new Error('Failed to generate plan: API returned empty response');
-                }
-                // Try to parse JSON
-                try {
-                    // FAKE_AI mode detection - return mock plan for testing
-                    if (process.env.CODEHERE_FAKE_AI === '1' || response.trim().startsWith('FAKE_RESPONSE')) {
-                        const mockSubPlans = [
-                            {
-                                id: `subplan_${Date.now()}_1`,
-                                description: `Analyze requirements for: ${goal}`,
-                                type: 'analyze',
-                                status: 'pending',
-                                estimatedSteps: 2,
-                                estimatedComplexity: 'low',
-                                dependencies: [],
-                                reflections: ['FAKE_AI: This is a mock plan for testing'],
-                            },
-                            {
-                                id: `subplan_${Date.now()}_2`,
-                                description: `Implement solution for: ${goal}`,
-                                type: 'implement',
-                                status: 'pending',
-                                estimatedSteps: 3,
-                                estimatedComplexity: 'medium',
-                                dependencies: [`subplan_${Date.now()}_1`],
-                                reflections: ['FAKE_AI: Mock implementation step'],
-                            },
-                        ];
-                        // Return mock plan immediately
-                        return {
-                            id: `plan_${Date.now()}`,
-                            goal,
-                            description: `FAKE_AI mock plan for: ${goal}`,
-                            subPlans: mockSubPlans,
-                            status: 'draft',
-                            createdAt: new Date(),
-                            updatedAt: new Date(),
-                            dependencies: [],
-                            metadata: {
-                                memoriesUsed: memories.map(m => m.id || ''),
-                                reflections: reflections,
-                                complexity: 'medium',
-                                priority: 5,
-                            },
-                        };
-                    }
-                    // Try to extract JSON from response (handle cases where LLM adds extra text)
-                    let jsonStr = response.trim();
-                    // Strategy 1: Remove markdown code blocks if present
-                    jsonStr = jsonStr.replace(/```json\n?/gi, '').replace(/```\n?/g, '').trim();
-                    // Strategy 2: Try to find JSON array in response (most common format)
-                    const jsonArrayMatch = jsonStr.match(/\[[\s\S]*\]/);
-                    if (jsonArrayMatch) {
-                        jsonStr = jsonArrayMatch[0];
-                    }
-                    else {
-                        // Strategy 3: Try to find JSON object and wrap in array
-                        const jsonObjectMatch = jsonStr.match(/\{[\s\S]*\}/);
-                        if (jsonObjectMatch) {
-                            jsonStr = `[${jsonObjectMatch[0]}]`;
-                        }
-                    }
-                    // Strategy 4: Try to extract from nested structures
-                    if (!jsonStr.startsWith('[') && !jsonStr.startsWith('{')) {
-                        // Look for array or object anywhere in the string
-                        const anyJsonMatch = jsonStr.match(/(\[[\s\S]*\]|\{[\s\S]*\})/);
-                        if (anyJsonMatch) {
-                            jsonStr = anyJsonMatch[0];
-                            // If it's an object, wrap in array
-                            if (jsonStr.startsWith('{')) {
-                                jsonStr = `[${jsonStr}]`;
-                            }
-                        }
-                    }
-                    const subPlans = JSON.parse(jsonStr);
-                    // Validate subPlans
-                    if (!Array.isArray(subPlans) || subPlans.length === 0) {
-                        throw new Error('Invalid subPlans array: empty or not an array');
-                    }
-                    // Success! Return the plan
-                    return {
-                        id: `plan_${Date.now()}`,
-                        goal,
-                        description: goal,
-                        subPlans,
-                        status: 'draft',
-                        createdAt: new Date(),
-                        updatedAt: new Date(),
-                        dependencies: [],
-                        metadata: {
-                            memoriesUsed: memories.map(m => m.id || ''),
-                            reflections: reflections,
-                            complexity: 'medium',
-                            priority: 5,
-                        },
-                    };
-                }
-                catch (parseError) {
-                    // JSON parsing failed, but we got a response - retry with reinforced prompt
-                    lastError = parseError instanceof Error ? parseError : new Error(String(parseError));
-                    if (attempt < maxRetries) {
-                        console.warn(`Planning Agent: JSON parsing failed on attempt ${attempt + 1}, retrying with reinforced prompt...`);
-                        await new Promise(resolve => setTimeout(resolve, 1000 * (attempt + 1))); // Brief delay before retry
-                        continue;
-                    }
-                    // Last attempt failed, throw error
-                    throw parseError;
-                }
+        let response;
+        try {
+            // Add timeout protection for planning calls (60 seconds max)
+            const timeoutPromise = new Promise((_, reject) => {
+                setTimeout(() => reject(new Error('Planning API call timed out after 60 seconds')), 60000);
+            });
+            response = await Promise.race([
+                this.aiService.chat(prompt, []),
+                timeoutPromise,
+            ]);
+        }
+        catch (error) {
+            const errorMsg = error instanceof Error ? error.message : String(error);
+            console.error('Planning Agent: API call failed:', errorMsg);
+            // Provide more helpful error messages
+            if (errorMsg.includes('timeout') || errorMsg.includes('timed out')) {
+                throw new Error(`Failed to generate plan: API call timed out. The Cohere API may be slow or unresponsive. Please check your API key and network connection.`);
             }
-            catch (error) {
-                const errorMsg = error instanceof Error ? error.message : String(error);
-                lastError = error instanceof Error ? error : new Error(errorMsg);
-                // Don't retry on fatal errors
-                if (errorMsg.includes('timeout') || errorMsg.includes('timed out')) {
-                    throw new Error(`Failed to generate plan: API call timed out. The API may be slow or unresponsive. Please check your API key and network connection.`);
-                }
-                else if (errorMsg.includes('401') || errorMsg.includes('Unauthorized')) {
-                    throw new Error(`Failed to generate plan: API authentication failed. Please check your API key is valid.`);
-                }
-                else if (errorMsg.includes('429') || errorMsg.includes('rate limit') || errorMsg.includes('TooManyRequests')) {
-                    // Check if it's a trial key monthly limit
-                    const isTrialLimit = errorMsg.includes('Trial key') || errorMsg.includes('1000 API calls');
-                    if (isTrialLimit) {
-                        throw new Error(`Failed to generate plan: Trial API key has reached monthly limit (1000 calls/month). Please upgrade to a Production key or wait for the limit to reset. See https://dashboard.cohere.com/api-keys`);
-                    }
-                    throw new Error(`Failed to generate plan: API rate limit exceeded (429). Please wait and try again or upgrade your API key.`);
-                }
-                // Retry on other errors if we haven't exhausted retries
-                if (attempt < maxRetries) {
-                    console.warn(`Planning Agent: API call failed on attempt ${attempt + 1}, retrying...`);
-                    await new Promise(resolve => setTimeout(resolve, 1000 * (attempt + 1))); // Brief delay before retry
-                    continue;
+            else if (errorMsg.includes('401') || errorMsg.includes('Unauthorized')) {
+                throw new Error(`Failed to generate plan: API authentication failed. Please check your COHERE_API_KEY is valid.`);
+            }
+            else if (errorMsg.includes('429') || errorMsg.includes('rate limit') || errorMsg.includes('TooManyRequests')) {
+                // Check if it's a trial key monthly limit
+                const isTrialLimit = errorMsg.includes('Trial key') || errorMsg.includes('1000 API calls');
+                if (isTrialLimit) {
+                    throw new Error(`Failed to generate plan: Trial API key has reached monthly limit (1000 calls/month). Please upgrade to a Production key or wait for the limit to reset. See https://dashboard.cohere.com/api-keys`);
                 }
-                // All retries exhausted
-                throw new Error(`Failed to generate plan: API call failed after ${maxRetries + 1} attempts. ${errorMsg}`);
+                throw new Error(`Failed to generate plan: API rate limit exceeded (429). Please wait and try again or upgrade your API key.`);
             }
+            throw new Error(`Failed to generate plan: API call failed. ${errorMsg}`);
         }
-        // If we get here, all retries failed
-        const errorMessage = lastError?.message || 'Unknown error';
-        console.error('Planning agent returned an unexpected response after all retries.');
-        console.error('This is usually a provider/model issue. Try again or check your AI provider configuration.');
-        // Verbose details for debugging
-        if (process.env.CODEHERE_CLI_STYLE === 'verbose' || process.env.CODEHERE_DEBUG === '1') {
-            console.error('\nDebug details:');
-            console.error('  Response length:', response?.length || 0);
-            console.error('  Response preview:', response?.substring(0, 500) || 'empty');
-            console.error('  Parse error:', errorMessage);
-            // Try to show what was extracted
-            try {
-                const jsonArrayMatch = response?.trim().match(/\[[\s\S]*\]/);
-                if (jsonArrayMatch) {
-                    console.error('  Extracted JSON array length:', jsonArrayMatch[0].length);
-                    console.error('  Extracted preview:', jsonArrayMatch[0].substring(0, 200));
-                }
+        // Check for empty response
+        if (!response || response.trim().length === 0) {
+            console.error('Planning Agent: Empty response from API');
+            throw new Error('Failed to generate plan: API returned empty response');
+        }
+        try {
+            // Try to extract JSON from response (handle cases where LLM adds extra text)
+            let jsonStr = response.trim();
+            // Try to find JSON array in response
+            const jsonArrayMatch = jsonStr.match(/\[[\s\S]*\]/);
+            if (jsonArrayMatch) {
+                jsonStr = jsonArrayMatch[0];
+            }
+            const subPlans = JSON.parse(jsonStr);
+            // Validate subPlans
+            if (!Array.isArray(subPlans) || subPlans.length === 0) {
+                console.error('Planning Agent: Invalid subPlans array:', subPlans);
+                throw new Error('Failed to generate plan: API returned empty or invalid sub-plans array');
+            }
+            return {
+                id: `plan_${Date.now()}`,
+                goal,
+                description: goal,
+                subPlans,
+                status: 'draft',
+                createdAt: new Date(),
+                updatedAt: new Date(),
+                dependencies: [],
+                metadata: {
+                    memoriesUsed: memories.map(m => m.id || ''),
+                    reflections: reflections,
+                    complexity: 'medium',
+                    priority: 5,
+                },
+            };
+        }
+        catch (e) {
+            // User-friendly error for minimal mode
+            console.error('Planning agent returned an unexpected response.');
+            console.error('This is usually a provider/model issue. Try again or check your AI provider configuration.');
+            // Verbose details for debugging (when CODEHERE_CLI_STYLE=verbose)
+            if (process.env.CODEHERE_CLI_STYLE === 'verbose') {
+                console.error('\nDebug details:');
+                console.error('  Response length:', response?.length || 0);
+                console.error('  Response preview:', response?.substring(0, 200) || 'empty');
+                console.error('  Parse error:', e instanceof Error ? e.message : String(e));
             }
-            catch { }
+            throw new Error(`Planning failed: AI response was not valid JSON. Try again or switch providers.`);
         }
-        throw new Error(`Planning failed: AI response was not valid JSON after ${maxRetries + 1} attempts. The AI provider may not be following JSON format requirements. Try again or switch providers.`);
     }
     /**
      * Assess confidence in plan quality
@@ -543,10 +426,7 @@ export class PlanningAgent {
         // More detailed sub-plans = higher confidence
         const memoryFactor = Math.min(memories.length / 10, 1.0);
         const detailFactor = Math.min(plan.subPlans.length / 5, 1.0);
-        const dependencyFactor = plan.subPlans.some(sp => {
-            const deps = Array.isArray(sp.dependencies) ? sp.dependencies : [];
-            return deps.length > 0;
-        }) ? 0.2 : 0;
+        const dependencyFactor = plan.subPlans.some(sp => sp.dependencies.length > 0) ? 0.2 : 0;
         return Math.min(memoryFactor * 0.4 + detailFactor * 0.4 + dependencyFactor, 1.0);
     }
 }

package/dist/application/services/dependency-container.js

@@ -2,6 +2,7 @@
  * Dependency Container
  * Simple DI container for wiring up dependencies
  */
+import { CohereAIService } from '../../infrastructure/ai/cohere-ai-service.js';
 import { SQLiteEmbeddingRepository } from '../../infrastructure/storage/sqlite-embedding-repository.js';
 import { SQLiteMemoryRepository } from '../../infrastructure/storage/sqlite-memory-repository.js';
 import { MemoryStreamService } from '../../infrastructure/storage/memory-stream-service.js';
@@ -144,7 +145,7 @@ export class DependencyContainer {
                     this._providerRegistry.register(cohereProvider);
                 }
                 catch (error) {
-                    console.warn('[ProviderRegistry] CohereProvider initialization skipped:', error instanceof Error ? error.message : String(error));
+                    // Silently skip — provider not configured
                 }
                 // Phase 4E: Register LocalLLMProvider if CODEHERE_AI_PROVIDER=local and base URL is set
                 const requestedProvider = process.env.CODEHERE_AI_PROVIDER?.toLowerCase();
@@ -166,7 +167,7 @@ export class DependencyContainer {
                         this._providerRegistry.register(openaiProvider);
                     }
                     catch (error) {
-                        console.warn('[ProviderRegistry] OpenAIProvider initialization skipped:', error instanceof Error ? error.message : String(error));
+                        // Silently skip — provider not configured
                     }
                 }
                 // Register OpenRouterProvider if API key is available
@@ -176,7 +177,7 @@ export class DependencyContainer {
                         this._providerRegistry.register(openRouterProvider);
                     }
                     catch (error) {
-                        console.warn('[ProviderRegistry] OpenRouterProvider initialization skipped:', error instanceof Error ? error.message : String(error));
+                        // Silently skip — provider not configured
                     }
                 }
                 // Set default provider based on CODEHERE_AI_PROVIDER env var
@@ -220,10 +221,9 @@ export class DependencyContainer {
                 }
             }
             catch (error) {
-                // Fallback to FakeProvider instead of CohereAIService (which has blocking tiktoken imports)
-                console.warn('[DependencyContainer] ProviderAIService initialization failed, falling back to FakeProvider:', error instanceof Error ? error.message : String(error));
-                const fakeProvider = new FakeProvider();
-                this._aiService = new ProviderAIService(fakeProvider);
+                // Fallback to CohereAIService if provider registry fails
+                console.warn('[DependencyContainer] ProviderAIService initialization failed, falling back to CohereAIService:', error instanceof Error ? error.message : String(error));
+                this._aiService = new CohereAIService();
                 if (this._contextCompressor) {
                     this._aiService._contextCompressor = this._contextCompressor;
                 }
@@ -580,8 +580,7 @@ export class DependencyContainer {
                     return new ProviderAIService(provider);
                 }
                 catch {
-                    // Fallback to FakeProvider instead of CohereAIService (which has blocking tiktoken imports)
-                    return new ProviderAIService(new FakeProvider());
+                    return new CohereAIService();
                 }
             })();
             this._contextCompressor = new ContextCompressor(tempAIService);
@@ -593,15 +592,5 @@ export class DependencyContainer {
         return this._contextCompressor;
     }
 }
-// Lazy-loaded container to prevent WASM/SQLite initialization during module import
-// The container is only instantiated on first property access
-let _containerInstance;
-export const container = new Proxy({}, {
-    get(_target, prop) {
-        if (!_containerInstance) {
-            _containerInstance = new DependencyContainer();
-        }
-        return _containerInstance[prop];
-    }
-});
+export const container = new DependencyContainer();
 //# sourceMappingURL=dependency-container.js.map

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

@@ -4,6 +4,7 @@
  * 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';
@@ -105,11 +106,8 @@ export class IntelligentRouter {
                 'index': 'index',
                 'plan': 'plan',
                 'find': 'ask',
-                'understand': 'ask', // Open questions → semantic search
+                'understand': 'ask',
                 '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' :
@@ -167,7 +165,8 @@ export class IntelligentRouter {
             });
             // Debug logging for compound instructions
             if (isCompoundInstruction) {
-                console.log(`[IntelligentRouter] Compound instruction detected. Classified: ${classifiedIntent}, Memory: ${memoryInformedIntent}, Using: ${intent}`);
+                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);
@@ -201,55 +200,48 @@ export class IntelligentRouter {
                 };
             }
             // 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':
-                        // Use deterministic workflow for faster performance (no ReAct overhead)
-                        routingResult = await this.handleExplainWithWorkflow(query, symbols, memories);
+                    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':
-                        // 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
+                        // Everything else → ask. The LLM is smart enough.
                         routingResult = await this.handleAsk(query, memories);
                         break;
                 }
@@ -464,18 +456,6 @@ Respond with ONLY the intent word (e.g., "explain", "plan", "understand"):`;
         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 {
@@ -608,10 +588,14 @@ Respond with ONLY the intent word (e.g., "explain", "plan", "understand"):`;
                 };
             }
         }
-        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 (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)
@@ -631,11 +615,14 @@ Respond with ONLY the intent word (e.g., "explain", "plan", "understand"):`;
                     return 1;
                 return b.length - a.length; // Longer names are more specific
             });
-            console.log(`[IntelligentRouter] Filtered symbols: ${prioritizedSymbols.join(', ')}`);
+            if (DEBUG)
+                console.log(`[IntelligentRouter] Filtered symbols: ${prioritizedSymbols.join(', ')}`);
             if (prioritizedSymbols.length > 0) {
-                console.log(`[IntelligentRouter] Searching for file containing symbol: ${prioritizedSymbols[0]}`);
+                if (DEBUG)
+                    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 (DEBUG)
+                    console.log(`[IntelligentRouter] Found filepath: ${filepath || 'none'}`);
             }
         }
         if (!filepath || !instruction) {
@@ -649,7 +636,8 @@ Respond with ONLY the intent word (e.g., "explain", "plan", "understand"):`;
                 memoriesUsed: memories?.length || 0,
             };
         }
-        console.log(`[IntelligentRouter] Proceeding with edit: ${filepath} - ${instruction}`);
+        if (DEBUG)
+            console.log(`[IntelligentRouter] Proceeding with edit: ${filepath} - ${instruction}`);
         try {
             const { container } = await import('./dependency-container.js');
             const useCase = container.editFileUseCase;
@@ -893,7 +881,8 @@ Respond with ONLY the intent word (e.g., "explain", "plan", "understand"):`;
      */
     async findFileBySymbol(symbol, query) {
         try {
-            console.log(`[IntelligentRouter] Searching for symbol: ${symbol}`);
+            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
@@ -904,7 +893,8 @@ Respond with ONLY the intent word (e.g., "explain", "plan", "understand"):`;
                 `${symbol} class or function`,
             ];
             for (const searchQuery of searchQueries) {
-                console.log(`[IntelligentRouter] Trying search query: ${searchQuery}`);
+                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) {
@@ -917,7 +907,8 @@ Respond with ONLY the intent word (e.g., "explain", "plan", "understand"):`;
                         if (filepath.startsWith(cwd)) {
                             filepath = filepath.substring(cwd.length + 1); // Remove leading slash
                         }
-                        console.log(`[IntelligentRouter] Found filepath from search: ${filepath}`);
+                        if (DEBUG)
+                            console.log(`[IntelligentRouter] Found filepath from search: ${filepath}`);
                         return filepath;
                     }
                 }
@@ -925,7 +916,8 @@ Respond with ONLY the intent word (e.g., "explain", "plan", "understand"):`;
                 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]}`);
+                        if (DEBUG)
+                            console.log(`[IntelligentRouter] Found filepath from answer: ${filepathMatch[1]}`);
                         return filepathMatch[1];
                     }
                 }