@visualprd/mcp-server 1.1.0

package/dist/intelligence/index.js

@@ -0,0 +1,683 @@
+"use strict";
+/**
+ * Intelligence Layer
+ *
+ * The brain of the MCP server - orchestrates context optimization,
+ * error analysis, gap filling, and guidance generation.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GuidanceGenerator = exports.GapFiller = exports.ErrorAnalyzer = exports.ContextOptimizer = exports.IntelligenceLayer = void 0;
+const context_optimizer_js_1 = require("./context-optimizer.js");
+const error_analyzer_js_1 = require("./error-analyzer.js");
+const gap_filler_js_1 = require("./gap-filler.js");
+const guidance_generator_js_1 = require("./guidance-generator.js");
+const llm_client_js_1 = require("../services/llm-client.js");
+class IntelligenceLayer {
+    contextOptimizer;
+    errorAnalyzer;
+    gapFiller;
+    guidanceGenerator;
+    client;
+    llmClient = null;
+    config;
+    // Intelligence cache
+    cache = new Map();
+    CACHE_TTL_MS = 10 * 60 * 1000; // 10 minutes
+    constructor(client, config) {
+        this.client = client;
+        this.config = config || { projectId: '', apiKey: '', apiUrl: '' };
+        this.contextOptimizer = new context_optimizer_js_1.ContextOptimizer();
+        this.errorAnalyzer = new error_analyzer_js_1.ErrorAnalyzer();
+        this.gapFiller = new gap_filler_js_1.GapFiller();
+        this.guidanceGenerator = new guidance_generator_js_1.GuidanceGenerator();
+        // Initialize LLM client if API key is available
+        const openRouterKey = process.env.OPENROUTER_API_KEY;
+        if (openRouterKey) {
+            this.llmClient = new llm_client_js_1.LLMClient({
+                apiKey: openRouterKey,
+                model: config?.thinkingModel || 'anthropic/claude-3.5-sonnet',
+            });
+            console.error(`[Intelligence] LLM initialized with model: ${this.llmClient.getModel()}`);
+        }
+        else {
+            console.error('[Intelligence] No OPENROUTER_API_KEY - running in rule-based mode only');
+        }
+    }
+    /**
+     * Update the thinking model dynamically
+     */
+    setThinkingModel(model) {
+        if (this.llmClient) {
+            this.llmClient.setModel(model);
+            this.config.thinkingModel = model;
+        }
+        else {
+            console.error('[Intelligence] Cannot set model - LLM client not initialized');
+        }
+    }
+    /**
+     * Set intelligence mode (fast = rule-based, deep = AI)
+     */
+    setIntelligenceMode(mode) {
+        this.config.intelligenceMode = mode;
+        console.error(`[Intelligence] Mode set to: ${mode}`);
+    }
+    /**
+     * Get the underlying VisualPRD client for direct V2 method access
+     */
+    getClient() {
+        return this.client;
+    }
+    /**
+     * Check if AI mode is available and enabled
+     */
+    isAIModeEnabled() {
+        return this.llmClient !== null && this.config.intelligenceMode === 'deep';
+    }
+    // ============================================================================
+    // MAIN INTELLIGENCE METHODS
+    // ============================================================================
+    /**
+     * Get the next build step with full intelligent context
+     */
+    async getNextBuildStep() {
+        const startTime = Date.now();
+        // 1. Load project data
+        const projectData = await this.client.loadProjectData();
+        // 2. Get next available prompt
+        const nextPrompt = await this.client.getNextBuildPrompt();
+        if (!nextPrompt) {
+            // All steps complete!
+            return {
+                step: null,
+                relatedEntities: {
+                    pages: [],
+                    schemas: [],
+                    endpoints: [],
+                    techStack: [],
+                },
+                contextualGuidance: {
+                    technicalConsiderations: [],
+                    potentialIssues: [],
+                    testingCriteria: [],
+                },
+                buildProgress: await this.client.getBuildProgress(),
+                message: '🎉 All build steps complete! Your project is ready.',
+            };
+        }
+        // 3. Decide on intelligence tier for this request
+        const decision = this.selectIntelligenceTier('get_next_step', nextPrompt);
+        // 4. Optimize context for this prompt
+        const optimizedContext = await this.contextOptimizer.optimizeContext(nextPrompt, projectData);
+        // 5. Analyze for gaps (lightweight)
+        const gapReport = await this.gapFiller.analyzeGaps(nextPrompt, projectData);
+        // 6. Generate guidance (rule-based or AI-powered)
+        let guidance;
+        if (this.isAIModeEnabled()) {
+            guidance = await this.generateAIGuidance(nextPrompt, projectData, optimizedContext, gapReport);
+        }
+        else {
+            guidance = this.guidanceGenerator.generateGuidance({
+                prompt: nextPrompt,
+                projectData,
+                relatedPages: optimizedContext.pages,
+                relatedSchemas: optimizedContext.schemas,
+                relatedEndpoints: optimizedContext.endpoints,
+                relatedTechStack: optimizedContext.techStack,
+            });
+        }
+        // 7. Add gap warnings to guidance
+        if (gapReport.gaps.length > 0) {
+            const highPriorityGaps = gapReport.gaps.filter(g => g.severity === 'high');
+            if (highPriorityGaps.length > 0) {
+                guidance.potentialIssues.unshift(...highPriorityGaps.map(g => `⚠️ ${g.description}`));
+            }
+        }
+        // 8. Get build progress
+        const buildProgress = await this.client.getBuildProgress();
+        const processingTime = Date.now() - startTime;
+        return {
+            step: nextPrompt,
+            relatedEntities: {
+                pages: optimizedContext.pages,
+                schemas: optimizedContext.schemas,
+                endpoints: optimizedContext.endpoints,
+                techStack: optimizedContext.techStack,
+                designSystem: optimizedContext.designSystem,
+            },
+            contextualGuidance: guidance,
+            buildProgress,
+            message: `Ready to work on step ${buildProgress.currentStep} of ${buildProgress.totalSteps}: "${nextPrompt.title}"`,
+        };
+    }
+    /**
+     * Validate and mark a step as complete
+     */
+    async markStepComplete(promptId, completionData) {
+        const validationIssues = [];
+        // 1. Get project data and prompt
+        const projectData = await this.client.loadProjectData();
+        const prompt = projectData.buildPrompts.find(p => p.promptId === promptId);
+        if (!prompt) {
+            return {
+                success: false,
+                validationIssues: [{ type: 'error', message: 'Prompt not found' }],
+                message: `Could not find prompt with ID: ${promptId}`,
+            };
+        }
+        // 2. Validate completion (lightweight checks)
+        if (!completionData.filesCreated?.length) {
+            validationIssues.push({
+                type: 'warning',
+                message: 'No files were created - are you sure this step is complete?'
+            });
+        }
+        if (completionData.testResults?.failed && completionData.testResults.failed > 0) {
+            validationIssues.push({
+                type: 'warning',
+                message: `${completionData.testResults.failed} tests are failing - consider fixing before marking complete`
+            });
+        }
+        // 3. Check test criteria (if any)
+        if (prompt.testCriteria?.length && !completionData.completionNotes) {
+            validationIssues.push({
+                type: 'warning',
+                message: 'This step has test criteria - please provide completion notes about how they were met'
+            });
+        }
+        // 4. Mark complete (even with warnings - user can override)
+        const success = await this.client.markPromptComplete(promptId, completionData);
+        if (!success) {
+            return {
+                success: false,
+                validationIssues: [{ type: 'error', message: 'Failed to update database' }],
+                message: 'Could not mark step as complete. Please try again.',
+            };
+        }
+        // 5. Get next step automatically
+        const nextStepResponse = await this.getNextBuildStep();
+        return {
+            success: true,
+            validationIssues,
+            nextStep: nextStepResponse,
+            message: validationIssues.length > 0
+                ? `✅ Step "${prompt.title}" marked complete with ${validationIssues.length} warning(s).`
+                : `✅ Step "${prompt.title}" marked complete!`,
+        };
+    }
+    /**
+     * Analyze an error and provide fixes
+     */
+    async analyzeError(error) {
+        // 1. Get project data and prompt
+        const projectData = await this.client.loadProjectData();
+        const prompt = projectData.buildPrompts.find(p => p.promptId === error.promptId);
+        if (!prompt) {
+            return {
+                diagnosis: {
+                    rootCause: 'Unknown prompt',
+                    explanation: `Could not find prompt ${error.promptId} for context`,
+                    errorCategory: error.errorType,
+                    severity: 'medium',
+                },
+                suggestedFixes: [{
+                        approach: 'Provide Context',
+                        steps: ['Ensure the promptId is correct', 'Try again with valid prompt ID'],
+                        confidence: 0.5,
+                    }],
+                relatedDocs: {},
+                shouldUncheckStep: false,
+                shouldInjectNewStep: false,
+                message: 'Could not find prompt for error context.',
+            };
+        }
+        // 2. Analyze the error
+        const analysis = await this.errorAnalyzer.analyzeError(error, {
+            prompt,
+            projectData,
+        });
+        // 3. Should we inject a new step?
+        if (analysis.shouldInjectNewStep && analysis.newStep) {
+            const newStep = await this.client.injectBuildPrompt(error.promptId, {
+                title: analysis.newStep.title || 'Fix Required Issue',
+                category: analysis.newStep.category || 'bugfix',
+                instruction: analysis.newStep.instruction || 'Address the error before continuing',
+                reason: `Automatically injected due to error: ${error.errorMessage.substring(0, 100)}`,
+            });
+            if (newStep) {
+                analysis.newStep = newStep;
+            }
+        }
+        // 4. Should we uncheck current step?
+        if (analysis.shouldUncheckStep) {
+            await this.client.uncheckPrompt(error.promptId);
+        }
+        // 5. Log the error
+        await this.client.logError('current-session', // TODO: Get actual session ID
+        error.promptId, error, analysis.diagnosis);
+        return {
+            ...analysis,
+            message: this.formatErrorMessage(analysis),
+        };
+    }
+    /**
+     * Get detailed information about an entity
+     */
+    async getEntityDetails(entityType, entityId, options = {}) {
+        const projectData = await this.client.loadProjectData();
+        let entity;
+        // Find the entity
+        switch (entityType) {
+            case 'page':
+                entity = await this.client.getPage(entityId);
+                break;
+            case 'schema':
+                entity = await this.client.getSchema(entityId);
+                break;
+            case 'endpoint':
+                entity = await this.client.getEndpoint(entityId);
+                break;
+            case 'tech':
+                entity = await this.client.getTechStackItem(entityId);
+                break;
+        }
+        if (!entity) {
+            throw new Error(`${entityType} with ID "${entityId}" not found`);
+        }
+        const result = { entity, entityType };
+        // Get relationships if requested
+        if (options.includeRelationships && entityType === 'schema') {
+            const schema = entity;
+            result.relationships = schema.relationships || [];
+            // Find reverse relationships
+            const reverseRels = projectData.schemas
+                .filter(s => s.id !== entity.id)
+                .flatMap(s => (s.relationships || [])
+                .filter(r => this.normalize(r.target) === this.normalize(schema.collectionName))
+                .map(r => ({
+                ...r,
+                source: s.collectionName,
+            })));
+            result.relationships.push(...reverseRels);
+        }
+        // Get usage information
+        if (options.includeRelationships) {
+            const usedBy = {};
+            // Find prompts that reference this entity
+            const relatedPrompts = projectData.buildPrompts.filter(p => {
+                const refs = p.relatedDocuments || {};
+                switch (entityType) {
+                    case 'page':
+                        return refs.pages?.some(ref => this.normalize(ref) === this.normalize(entityId));
+                    case 'schema':
+                        return refs.schemas?.some(ref => this.normalize(ref) === this.normalize(entityId));
+                    case 'endpoint':
+                        return refs.endpoints?.some(ref => this.normalize(ref) === this.normalize(entityId));
+                    case 'tech':
+                        return refs.techStack?.some(ref => this.normalize(ref) === this.normalize(entityId));
+                    default:
+                        return false;
+                }
+            });
+            if (relatedPrompts.length > 0) {
+                usedBy.prompts = relatedPrompts.map(p => p.title);
+            }
+            result.usedBy = usedBy;
+        }
+        // Generate usage examples if requested
+        if (options.includeUsageExamples) {
+            result.usageExamples = this.generateUsageExamples(entityType, entity);
+        }
+        return result;
+    }
+    /**
+     * Get debugging suggestions when stuck
+     */
+    async getDebugSuggestions(currentTask, issue, context) {
+        const projectData = await this.client.loadProjectData();
+        const suggestions = [];
+        const fullContext = `${currentTask} ${issue} ${context || ''}`.toLowerCase();
+        // Pattern-based suggestions
+        if (fullContext.includes('not loading') || fullContext.includes("doesn't load")) {
+            suggestions.push({
+                approach: 'Check Data Fetching',
+                reasoning: 'Loading issues are often related to async data fetching',
+                steps: [
+                    'Add console.log before and after fetch calls',
+                    'Check browser Network tab for failed requests',
+                    'Verify the endpoint URL is correct',
+                    'Check for CORS issues in console',
+                ],
+                confidence: 0.85,
+            });
+        }
+        if (fullContext.includes('style') || fullContext.includes('css') || fullContext.includes('layout')) {
+            const designSystem = await this.client.getDesignSystem();
+            suggestions.push({
+                approach: 'Review Design System',
+                reasoning: 'Styling issues may be due to design system misalignment',
+                steps: [
+                    'Check design-system.md for correct color/spacing values',
+                    'Use browser DevTools to inspect computed styles',
+                    'Verify Tailwind classes are correct',
+                    'Check for CSS specificity conflicts',
+                ],
+                confidence: 0.8,
+            });
+        }
+        if (fullContext.includes('auth') || fullContext.includes('login') || fullContext.includes('permission')) {
+            suggestions.push({
+                approach: 'Debug Authentication',
+                reasoning: 'Auth issues often stem from token or permission problems',
+                steps: [
+                    'Check if auth token exists: console.log(auth.currentUser)',
+                    'Verify token hasn\'t expired',
+                    'Review Firestore security rules',
+                    'Check if user has required role/permissions',
+                ],
+                confidence: 0.9,
+            });
+        }
+        if (fullContext.includes('upload') || fullContext.includes('file') || fullContext.includes('image')) {
+            const firebaseTech = projectData.techStack.find(t => t.name.toLowerCase().includes('firebase'));
+            suggestions.push({
+                approach: 'Debug File Upload',
+                reasoning: 'File uploads require Storage configuration',
+                steps: [
+                    'Verify Firebase Storage is initialized',
+                    'Check Storage security rules allow uploads',
+                    'Ensure file size is within limits',
+                    'Verify correct MIME type handling',
+                ],
+                confidence: 0.85,
+            });
+        }
+        // Fallback suggestion
+        if (suggestions.length === 0) {
+            suggestions.push({
+                approach: 'Systematic Debugging',
+                reasoning: 'General debugging approach for unknown issues',
+                steps: [
+                    'Add console.log statements to trace execution flow',
+                    'Check browser console for errors',
+                    'Review recent code changes',
+                    'Try to reproduce with minimal example',
+                    'Search error message online for solutions',
+                ],
+                confidence: 0.6,
+            });
+        }
+        // Add relevant context from project
+        const additionalContext = {};
+        // Find relevant schemas based on keywords
+        const relevantSchemas = projectData.schemas.filter(s => fullContext.includes(this.normalize(s.collectionName)));
+        if (relevantSchemas.length > 0) {
+            additionalContext.schemas = relevantSchemas.map(s => ({
+                collectionName: s.collectionName,
+                fields: s.fields?.map(f => f.fieldName),
+            }));
+        }
+        // Find relevant endpoints
+        const relevantEndpoints = projectData.endpoints.filter(e => fullContext.includes(this.normalize(e.name)) ||
+            fullContext.includes(this.normalize(e.path || '')));
+        if (relevantEndpoints.length > 0) {
+            additionalContext.endpoints = relevantEndpoints.map(e => ({
+                name: e.name,
+                method: e.method,
+                path: e.path,
+            }));
+        }
+        return { suggestions, additionalContext, missingInformation: [] };
+    }
+    /**
+     * Inject a new build step dynamically
+     */
+    async injectDynamicStep(insertAfterPromptId, stepData) {
+        const newStep = await this.client.injectBuildPrompt(insertAfterPromptId, {
+            title: stepData.title,
+            category: stepData.category,
+            instruction: stepData.instruction,
+            reason: stepData.reason,
+            estimatedMinutes: stepData.estimatedMinutes,
+        });
+        if (!newStep) {
+            return {
+                success: false,
+                message: 'Failed to inject new step. Check that the insertAfter prompt exists.',
+            };
+        }
+        return {
+            success: true,
+            newStep,
+            message: `✅ New step "${stepData.title}" injected after prompt ${insertAfterPromptId}`,
+        };
+    }
+    // ============================================================================
+    // INTELLIGENCE DECISION MAKING
+    // ============================================================================
+    /**
+     * Select appropriate intelligence tier based on task
+     */
+    selectIntelligenceTier(task, context) {
+        // Simple tasks use rule-based logic (free)
+        const simpleTaskPatterns = [
+            'get_next_step',
+            'mark_complete',
+            'get_entity',
+            'get_progress',
+        ];
+        if (simpleTaskPatterns.some(p => task.includes(p))) {
+            return {
+                action: 'rule_based',
+                reasoning: 'Simple lookup or status change - no AI needed',
+                cost: 'free',
+            };
+        }
+        // Pattern matching for known error types
+        if (task === 'analyze_error' && context?.errorType) {
+            return {
+                action: 'pattern_match',
+                reasoning: 'Error analysis using known patterns',
+                cost: 'free',
+            };
+        }
+        // Complex reasoning tasks may need AI
+        if (task === 'debug_suggestions' || task === 'gap_analysis') {
+            return {
+                action: 'lightweight_ai',
+                reasoning: 'Requires contextual understanding',
+                cost: 'cheap',
+            };
+        }
+        // Default to rule-based
+        return {
+            action: 'rule_based',
+            reasoning: 'Default to rules to minimize cost',
+            cost: 'free',
+        };
+    }
+    // ============================================================================
+    // UTILITY METHODS
+    // ============================================================================
+    normalize(str) {
+        return (str || '')
+            .toLowerCase()
+            .replace(/[^a-z0-9]/g, '')
+            .trim();
+    }
+    formatErrorMessage(analysis) {
+        const parts = [];
+        parts.push(`**Diagnosis:** ${analysis.diagnosis.rootCause}`);
+        parts.push(`**Severity:** ${analysis.diagnosis.severity}`);
+        parts.push('');
+        parts.push('**Suggested Fixes:**');
+        for (const fix of analysis.suggestedFixes.slice(0, 3)) {
+            parts.push(`- ${fix.approach} (${Math.round(fix.confidence * 100)}% confidence)`);
+            for (const step of fix.steps.slice(0, 3)) {
+                parts.push(`  • ${step}`);
+            }
+        }
+        if (analysis.shouldInjectNewStep && analysis.newStep) {
+            parts.push('');
+            parts.push(`⚠️ **New step injected:** "${analysis.newStep.title}"`);
+        }
+        if (analysis.shouldUncheckStep) {
+            parts.push('');
+            parts.push('⚠️ **Current step unchecked** - needs to be completed after fix');
+        }
+        return parts.join('\n');
+    }
+    generateUsageExamples(entityType, entity) {
+        const examples = [];
+        switch (entityType) {
+            case 'schema':
+                examples.push({
+                    context: 'Fetching documents',
+                    code: `const snapshot = await db.collection('${entity.collectionName}').get();\nconst items = snapshot.docs.map(doc => ({ id: doc.id, ...doc.data() }));`,
+                });
+                examples.push({
+                    context: 'Adding a document',
+                    code: `await db.collection('${entity.collectionName}').add({\n  // ${entity.fields?.map((f) => f.fieldName).join(', ')}\n});`,
+                });
+                break;
+            case 'endpoint':
+                examples.push({
+                    context: 'Calling the API',
+                    code: `const response = await fetch('${entity.path}', {\n  method: '${entity.method}',\n  headers: { 'Content-Type': 'application/json' },\n  ${entity.method !== 'GET' ? 'body: JSON.stringify(data),' : ''}\n});\nconst result = await response.json();`,
+                });
+                break;
+            case 'page':
+                examples.push({
+                    context: 'Routing to page',
+                    code: entity.route
+                        ? `import { useRouter } from 'next/navigation';\n// ...\nrouter.push('${entity.route}');`
+                        : '// Define route in app router',
+                });
+                break;
+        }
+        return examples;
+    }
+    /**
+     * Generate AI-powered guidance for a build step
+     * Uses completely generic prompts that adapt to any project type
+     */
+    async generateAIGuidance(prompt, projectData, context, gapReport) {
+        if (!this.llmClient) {
+            // Fallback to rule-based if LLM not available
+            return this.guidanceGenerator.generateGuidance({
+                prompt,
+                projectData,
+                relatedPages: context.pages,
+                relatedSchemas: context.schemas,
+                relatedEndpoints: context.endpoints,
+                relatedTechStack: context.techStack,
+            });
+        }
+        // Generic system prompt - no project-type assumptions
+        const systemPrompt = `You are an expert software engineer assistant.
+
+Your role is to provide practical, actionable guidance for development tasks.
+Analyze the provided context carefully and identify:
+1. What technical considerations apply to this specific task
+2. What issues the developer might face based on the actual project structure
+3. How to verify the task is complete correctly
+4. What implicit requirements exist that aren't explicitly stated
+
+Be specific to the actual project data provided. Do not make assumptions about the project type.
+Do not provide generic advice - every suggestion must be grounded in the actual context.
+Focus on what's relevant to THIS specific task in THIS specific project.`;
+        // Build context dynamically from actual project data
+        const techStackList = projectData.techStack.map(t => `${t.name}${t.version ? ` v${t.version}` : ''} (${t.category})`).join('\n- ') || 'Not specified';
+        const schemaContext = context.schemas.length > 0
+            ? context.schemas.map(s => `${s.collectionName}: fields=[${s.fields.map(f => `${f.fieldName}:${f.dataType}${f.required ? '*' : ''}`).join(', ')}]`).join('\n- ')
+            : 'No schemas relevant to this task';
+        const pageContext = context.pages.length > 0
+            ? context.pages.map(p => `${p.pageName}${p.route ? ` (${p.route})` : ''}: ${p.purpose || p.description || 'No description'}`).join('\n- ')
+            : 'No pages relevant to this task';
+        const endpointContext = context.endpoints.length > 0
+            ? context.endpoints.map(e => `${e.method} ${e.path}: ${e.description || e.name}`).join('\n- ')
+            : 'No endpoints relevant to this task';
+        const gapContext = gapReport.gaps.length > 0
+            ? gapReport.gaps.map(g => `[${g.severity.toUpperCase()}] ${g.description}`).join('\n- ')
+            : 'None identified';
+        const userPrompt = `# Current Task
+Title: ${prompt.title}
+Category: ${prompt.category}
+Instruction: ${prompt.instruction || 'Complete this step as described'}
+${prompt.expectedOutcome ? `Expected Outcome: ${prompt.expectedOutcome}` : ''}
+${prompt.testCriteria?.length ? `Test Criteria:\n- ${prompt.testCriteria.join('\n- ')}` : ''}
+
+# Project Context
+Name: ${projectData.projectName}
+Description: ${projectData.description || 'No description provided'}
+
+## Technology Stack
+- ${techStackList}
+
+## Relevant Database Schemas
+- ${schemaContext}
+
+## Relevant Pages/Views
+- ${pageContext}
+
+## Relevant API Endpoints
+- ${endpointContext}
+
+## Identified Gaps
+- ${gapContext}
+
+# Your Task
+Provide guidance in JSON format:
+{
+  "technicalConsiderations": ["specific considerations for this task based on the context"],
+  "potentialIssues": ["specific issues that could arise based on the actual project structure"],
+  "testingCriteria": ["specific ways to verify this task is complete"],
+  "suggestedApproach": "A step-by-step approach specific to this task",
+  "implicitRequirements": ["Things not stated but implied by the context"]
+}`;
+        try {
+            const { result } = await this.llmClient.analyzeJSON(systemPrompt, userPrompt, { maxTokens: 2000 });
+            // Add implicit requirements as potential issues
+            const allIssues = [...(result.potentialIssues || [])];
+            if (result.implicitRequirements?.length) {
+                allIssues.push(...result.implicitRequirements.map(r => `⚠️ Implicit: ${r}`));
+            }
+            return {
+                technicalConsiderations: result.technicalConsiderations || [],
+                potentialIssues: allIssues,
+                testingCriteria: result.testingCriteria || [],
+                suggestedApproach: result.suggestedApproach,
+                relatedPatterns: result.relatedPatterns,
+            };
+        }
+        catch (error) {
+            console.error('[Intelligence] AI guidance failed, falling back to rules:', error);
+            return this.guidanceGenerator.generateGuidance({
+                prompt,
+                projectData,
+                relatedPages: context.pages,
+                relatedSchemas: context.schemas,
+                relatedEndpoints: context.endpoints,
+                relatedTechStack: context.techStack,
+            });
+        }
+    }
+    /**
+     * Clear intelligence cache
+     */
+    clearCache() {
+        this.cache.clear();
+        this.client.clearCache();
+    }
+}
+exports.IntelligenceLayer = IntelligenceLayer;
+// Re-export individual components
+var context_optimizer_js_2 = require("./context-optimizer.js");
+Object.defineProperty(exports, "ContextOptimizer", { enumerable: true, get: function () { return context_optimizer_js_2.ContextOptimizer; } });
+var error_analyzer_js_2 = require("./error-analyzer.js");
+Object.defineProperty(exports, "ErrorAnalyzer", { enumerable: true, get: function () { return error_analyzer_js_2.ErrorAnalyzer; } });
+var gap_filler_js_2 = require("./gap-filler.js");
+Object.defineProperty(exports, "GapFiller", { enumerable: true, get: function () { return gap_filler_js_2.GapFiller; } });
+var guidance_generator_js_2 = require("./guidance-generator.js");
+Object.defineProperty(exports, "GuidanceGenerator", { enumerable: true, get: function () { return guidance_generator_js_2.GuidanceGenerator; } });
+//# sourceMappingURL=index.js.map