@visualprd/mcp-server 1.1.0

package/dist/intelligence/error-analyzer.js

@@ -0,0 +1,765 @@
+"use strict";
+/**
+ * Error Analyzer
+ *
+ * Intelligently analyzes errors reported during the build process
+ * and provides actionable fixes, migrations, or new build steps.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ErrorAnalyzer = void 0;
+class ErrorAnalyzer {
+    patterns = [];
+    constructor() {
+        this.registerPatterns();
+    }
+    /**
+     * Analyze an error and provide diagnosis + fixes
+     */
+    async analyzeError(error, context) {
+        // Try to match against known patterns
+        for (const pattern of this.patterns) {
+            const matches = typeof pattern.pattern === 'string'
+                ? error.errorMessage.includes(pattern.pattern)
+                : pattern.pattern.test(error.errorMessage);
+            if (matches) {
+                const partialResult = await pattern.analyzer(error, context);
+                return this.buildFullResult(error, context, partialResult, pattern.type);
+            }
+        }
+        // Fallback: Generic analysis
+        return this.genericAnalysis(error, context);
+    }
+    /**
+     * Register known error patterns
+     */
+    registerPatterns() {
+        // Null/undefined reference errors
+        this.patterns.push({
+            pattern: /Cannot read propert(y|ies) .* of (undefined|null)/i,
+            type: 'null_reference',
+            analyzer: this.analyzeNullReference.bind(this),
+        });
+        this.patterns.push({
+            pattern: /TypeError:.*is (undefined|null)/i,
+            type: 'null_reference',
+            analyzer: this.analyzeNullReference.bind(this),
+        });
+        // Module/import errors
+        this.patterns.push({
+            pattern: /Module not found|Cannot find module/i,
+            type: 'missing_module',
+            analyzer: this.analyzeMissingModule.bind(this),
+        });
+        this.patterns.push({
+            pattern: /is not exported from/i,
+            type: 'export_error',
+            analyzer: this.analyzeExportError.bind(this),
+        });
+        // Schema/field mismatch errors
+        this.patterns.push({
+            pattern: /field .* does not exist|unknown field|property .* does not exist on type/i,
+            type: 'schema_mismatch',
+            analyzer: this.analyzeSchemaMismatch.bind(this),
+        });
+        this.patterns.push({
+            pattern: /Expected .* but received|Type .* is not assignable/i,
+            type: 'type_mismatch',
+            analyzer: this.analyzeTypeMismatch.bind(this),
+        });
+        // Firebase/Firestore errors
+        this.patterns.push({
+            pattern: /PERMISSION_DENIED|Missing or insufficient permissions/i,
+            type: 'permission_error',
+            analyzer: this.analyzePermissionError.bind(this),
+        });
+        this.patterns.push({
+            pattern: /FirebaseError|Firebase:.*Error/i,
+            type: 'firebase_error',
+            analyzer: this.analyzeFirebaseError.bind(this),
+        });
+        // API/Network errors
+        this.patterns.push({
+            pattern: /fetch failed|network error|ECONNREFUSED/i,
+            type: 'network_error',
+            analyzer: this.analyzeNetworkError.bind(this),
+        });
+        this.patterns.push({
+            pattern: /4\d{2}|5\d{2}.*error|HTTP Error/i,
+            type: 'http_error',
+            analyzer: this.analyzeHTTPError.bind(this),
+        });
+        // Test failures
+        this.patterns.push({
+            pattern: /test failed|assertion.*failed|expect.*to/i,
+            type: 'test_failure',
+            analyzer: this.analyzeTestFailure.bind(this),
+        });
+        // Syntax/compilation errors
+        this.patterns.push({
+            pattern: /SyntaxError|Unexpected token/i,
+            type: 'syntax_error',
+            analyzer: this.analyzeSyntaxError.bind(this),
+        });
+    }
+    // ============================================================================
+    // PATTERN-SPECIFIC ANALYZERS
+    // ============================================================================
+    async analyzeNullReference(error, context) {
+        // Extract property name from error
+        const propertyMatch = error.errorMessage.match(/Cannot read propert(?:y|ies) ['"]?(\w+)['"]?/i);
+        const propertyName = propertyMatch?.[1];
+        // Check if property exists in any schema
+        let relatedSchema;
+        let fieldExists = false;
+        if (propertyName) {
+            for (const schema of context.projectData.schemas) {
+                const field = schema.fields?.find((f) => f.fieldName.toLowerCase() === propertyName.toLowerCase());
+                if (field) {
+                    relatedSchema = schema;
+                    fieldExists = true;
+                    break;
+                }
+            }
+        }
+        const diagnosis = {
+            rootCause: fieldExists
+                ? `The field "${propertyName}" is defined in schema but the object is null/undefined at runtime`
+                : `Attempting to access property "${propertyName || 'unknown'}" on a null or undefined object`,
+            explanation: fieldExists
+                ? 'This usually means the data hasn\'t been fetched yet, or the query returned no results. Add null checks or ensure data is loaded before accessing.'
+                : 'The code assumes an object exists but it\'s actually null/undefined. Add defensive checks.',
+            errorCategory: 'null_reference',
+            severity: 'medium',
+        };
+        const fixes = [
+            {
+                approach: 'Optional Chaining',
+                steps: [
+                    `Use optional chaining (?.) when accessing ${propertyName || 'the property'}`,
+                    'Add nullish coalescing (??) for default values',
+                ],
+                code: propertyName
+                    ? {
+                        filename: 'fix.ts',
+                        content: `// Instead of:\nconst value = obj.${propertyName};\n\n// Use:\nconst value = obj?.${propertyName} ?? defaultValue;`,
+                        language: 'typescript',
+                    }
+                    : undefined,
+                confidence: 0.9,
+            },
+            {
+                approach: 'Early Return Guard',
+                steps: [
+                    'Add a guard clause at the start of the function',
+                    'Return early or throw a meaningful error if data is missing',
+                ],
+                code: {
+                    filename: 'fix.ts',
+                    content: `// Add at the start of your function:\nif (!data) {\n  console.warn('Data not loaded yet');\n  return null; // or throw new Error('Data required');\n}`,
+                    language: 'typescript',
+                },
+                confidence: 0.85,
+            },
+        ];
+        // If it's a schema field issue, suggest checking data loading
+        if (fieldExists && relatedSchema) {
+            fixes.unshift({
+                approach: 'Verify Data Loading',
+                steps: [
+                    `Check that ${relatedSchema.collectionName} data is being fetched correctly`,
+                    'Verify the document exists in Firestore',
+                    'Ensure the query is returning the expected document',
+                ],
+                confidence: 0.95,
+            });
+        }
+        return {
+            diagnosis,
+            suggestedFixes: fixes,
+            relatedDocs: relatedSchema ? { schemas: [relatedSchema] } : {},
+            shouldUncheckStep: false,
+            shouldInjectNewStep: false,
+        };
+    }
+    async analyzeMissingModule(error, context) {
+        // Extract module name
+        const moduleMatch = error.errorMessage.match(/Cannot find module ['"]([^'"]+)['"]/i);
+        const moduleName = moduleMatch?.[1] || 'unknown';
+        const isLocalModule = moduleName.startsWith('.') || moduleName.startsWith('@/');
+        const isNodeModule = !isLocalModule;
+        const diagnosis = {
+            rootCause: isNodeModule
+                ? `The npm package "${moduleName}" is not installed`
+                : `The local module "${moduleName}" doesn't exist or path is incorrect`,
+            explanation: isNodeModule
+                ? 'You need to install this dependency using npm or yarn'
+                : 'Check the file path and ensure the file exists at that location',
+            errorCategory: 'missing_module',
+            severity: 'high',
+        };
+        const fixes = [];
+        if (isNodeModule) {
+            // Check if it's in tech stack
+            const techItem = context.projectData.techStack.find((t) => moduleName.toLowerCase().includes(t.name.toLowerCase()) ||
+                t.name.toLowerCase().includes(moduleName.split('/')[0].replace('@', '')));
+            fixes.push({
+                approach: 'Install Package',
+                steps: [
+                    `Run: npm install ${moduleName}`,
+                    'Or with yarn: yarn add ' + moduleName,
+                    'Restart your development server after installation',
+                ],
+                code: {
+                    filename: 'terminal',
+                    content: `npm install ${moduleName}`,
+                    language: 'bash',
+                },
+                confidence: 0.95,
+            });
+            if (techItem) {
+                fixes[0].steps.push(`Note: "${techItem.name}" is in your tech stack - ensure version matches: ${techItem.version || 'latest'}`);
+            }
+        }
+        else {
+            fixes.push({
+                approach: 'Fix Import Path',
+                steps: [
+                    'Verify the file exists at the specified path',
+                    'Check for typos in the filename or path',
+                    'Ensure the file extension is correct (.ts, .tsx, .js)',
+                    'If using path aliases (@/), check tsconfig.json paths configuration',
+                ],
+                confidence: 0.8,
+            });
+            fixes.push({
+                approach: 'Create Missing File',
+                steps: [
+                    `Create the missing file at: ${moduleName}`,
+                    'Export the required functions/components',
+                ],
+                confidence: 0.7,
+            });
+        }
+        return {
+            diagnosis,
+            suggestedFixes: fixes,
+            shouldUncheckStep: false,
+            shouldInjectNewStep: false,
+        };
+    }
+    async analyzeExportError(error, context) {
+        const exportMatch = error.errorMessage.match(/['"](\w+)['"] is not exported from ['"]([^'"]+)['"]/i);
+        const exportName = exportMatch?.[1] || 'unknown';
+        const modulePath = exportMatch?.[2] || 'unknown';
+        const diagnosis = {
+            rootCause: `The export "${exportName}" doesn't exist in module "${modulePath}"`,
+            explanation: 'Either the export name is wrong, or the module needs to export this item',
+            errorCategory: 'export_error',
+            severity: 'medium',
+        };
+        const fixes = [
+            {
+                approach: 'Check Export Name',
+                steps: [
+                    `Open ${modulePath} and check available exports`,
+                    'Look for typos in the export name',
+                    'Check if it\'s a default vs named export',
+                ],
+                confidence: 0.85,
+            },
+            {
+                approach: 'Add Missing Export',
+                steps: [
+                    `Add the export to ${modulePath}`,
+                    `export const ${exportName} = ...;`,
+                    'Or: export { ${exportName} };',
+                ],
+                code: {
+                    filename: modulePath,
+                    content: `// Add this export to ${modulePath}:\nexport const ${exportName} = /* your implementation */;`,
+                    language: 'typescript',
+                },
+                confidence: 0.8,
+            },
+        ];
+        return {
+            diagnosis,
+            suggestedFixes: fixes,
+            shouldUncheckStep: false,
+            shouldInjectNewStep: false,
+        };
+    }
+    async analyzeSchemaMismatch(error, context) {
+        // Extract field name
+        const fieldMatch = error.errorMessage.match(/(?:field|property) ['"]?(\w+)['"]?/i);
+        const fieldName = fieldMatch?.[1];
+        // Find schema that might have this field
+        let relatedSchema;
+        let fieldDefinedInSchema = false;
+        if (fieldName) {
+            for (const schema of context.projectData.schemas) {
+                const field = schema.fields?.find((f) => f.fieldName.toLowerCase() === fieldName.toLowerCase());
+                if (field) {
+                    relatedSchema = schema;
+                    fieldDefinedInSchema = true;
+                    break;
+                }
+            }
+        }
+        const diagnosis = {
+            rootCause: fieldDefinedInSchema
+                ? `Field "${fieldName}" is defined in schema but not present in the actual database document`
+                : `Code references field "${fieldName || 'unknown'}" which doesn't exist in any schema`,
+            explanation: fieldDefinedInSchema
+                ? 'The schema definition is ahead of the actual database state. You need to migrate existing documents or add the field to new documents.'
+                : 'Either add this field to the appropriate schema, or fix the code to use an existing field.',
+            errorCategory: 'schema_mismatch',
+            severity: fieldDefinedInSchema ? 'high' : 'medium',
+        };
+        const fixes = [];
+        if (fieldDefinedInSchema && relatedSchema) {
+            // Field is in schema but not in DB - need migration
+            fixes.push({
+                approach: 'Database Migration',
+                steps: [
+                    `Create a migration script for ${relatedSchema.collectionName} collection`,
+                    `Add default value for "${fieldName}" to existing documents`,
+                    'Run the migration before continuing',
+                ],
+                code: {
+                    filename: `migrations/add-${fieldName}-to-${relatedSchema.collectionName}.ts`,
+                    content: `// Migration script\nimport { getFirestore } from 'firebase-admin/firestore';\n\nconst db = getFirestore();\n\nexport async function migrate() {\n  const snapshot = await db.collection('${relatedSchema.collectionName}').get();\n  \n  const batch = db.batch();\n  snapshot.docs.forEach(doc => {\n    if (doc.data().${fieldName} === undefined) {\n      batch.update(doc.ref, { ${fieldName}: /* default value */ });\n    }\n  });\n  \n  await batch.commit();\n  console.log('Migration complete');\n}`,
+                    language: 'typescript',
+                },
+                confidence: 0.9,
+            });
+            // Should inject a migration step
+            return {
+                diagnosis,
+                suggestedFixes: fixes,
+                relatedDocs: { schemas: [relatedSchema] },
+                shouldUncheckStep: true,
+                shouldInjectNewStep: true,
+                newStep: {
+                    title: `Database Migration: Add ${fieldName} to ${relatedSchema.collectionName}`,
+                    category: 'database',
+                    instruction: `Run a migration to add the "${fieldName}" field to existing documents in the ${relatedSchema.collectionName} collection.\n\nSteps:\n1. Create migration script\n2. Test on a few documents first\n3. Run for all documents\n4. Verify the field exists in documents`,
+                },
+            };
+        }
+        // Field not in schema - add defensive coding
+        fixes.push({
+            approach: 'Defensive Coding',
+            steps: [
+                'Add null check before accessing the field',
+                'Provide a sensible default value',
+            ],
+            code: fieldName
+                ? {
+                    filename: 'fix.ts',
+                    content: `// Safe access with default:\nconst ${fieldName} = document?.${fieldName} ?? defaultValue;`,
+                    language: 'typescript',
+                }
+                : undefined,
+            confidence: 0.85,
+        });
+        return {
+            diagnosis,
+            suggestedFixes: fixes,
+            relatedDocs: relatedSchema ? { schemas: [relatedSchema] } : {},
+            shouldUncheckStep: false,
+            shouldInjectNewStep: false,
+        };
+    }
+    async analyzeTypeMismatch(error, context) {
+        const diagnosis = {
+            rootCause: 'Type mismatch between expected and actual values',
+            explanation: 'TypeScript is detecting that the types don\'t match. This could be a data transformation issue or incorrect type definition.',
+            errorCategory: 'type_mismatch',
+            severity: 'medium',
+        };
+        const fixes = [
+            {
+                approach: 'Type Assertion',
+                steps: [
+                    'If you\'re sure about the type, use type assertion',
+                    'But first verify the data actually matches',
+                ],
+                code: {
+                    filename: 'fix.ts',
+                    content: `// Type assertion (use carefully):\nconst value = data as ExpectedType;\n\n// Or with validation:\nif (isExpectedType(data)) {\n  const value = data;\n}`,
+                    language: 'typescript',
+                },
+                confidence: 0.7,
+            },
+            {
+                approach: 'Add Type Guard',
+                steps: [
+                    'Create a type guard function to validate the data',
+                    'Use it before processing',
+                ],
+                code: {
+                    filename: 'fix.ts',
+                    content: `function isExpectedType(data: unknown): data is ExpectedType {\n  return (\n    typeof data === 'object' &&\n    data !== null &&\n    'requiredField' in data\n  );\n}`,
+                    language: 'typescript',
+                },
+                confidence: 0.85,
+            },
+        ];
+        return {
+            diagnosis,
+            suggestedFixes: fixes,
+            shouldUncheckStep: false,
+            shouldInjectNewStep: false,
+        };
+    }
+    async analyzePermissionError(error, context) {
+        const diagnosis = {
+            rootCause: 'Firestore security rules are blocking this operation',
+            explanation: 'The current user doesn\'t have permission to read/write this data. Check your Firestore security rules.',
+            errorCategory: 'permission_error',
+            severity: 'high',
+        };
+        // Find relevant tech stack (Firebase)
+        const firebaseTech = context.projectData.techStack.find((t) => t.name.toLowerCase().includes('firebase'));
+        const fixes = [
+            {
+                approach: 'Update Security Rules',
+                steps: [
+                    'Review firestore.rules file',
+                    'Ensure the rule allows the current user to perform this operation',
+                    'Check if authentication is required and user is logged in',
+                ],
+                code: {
+                    filename: 'firestore.rules',
+                    content: `rules_version = '2';\nservice cloud.firestore {\n  match /databases/{database}/documents {\n    // Example rule - adjust for your needs:\n    match /collection/{docId} {\n      allow read: if request.auth != null;\n      allow write: if request.auth != null && request.auth.uid == resource.data.userId;\n    }\n  }\n}`,
+                    language: 'text',
+                },
+                confidence: 0.85,
+            },
+            {
+                approach: 'Verify Authentication',
+                steps: [
+                    'Ensure user is authenticated before this operation',
+                    'Check if auth state is initialized',
+                    'Verify the auth token hasn\'t expired',
+                ],
+                code: {
+                    filename: 'auth-check.ts',
+                    content: `// Verify auth before Firestore operation:\nimport { auth } from './firebase';\n\nconst user = auth.currentUser;\nif (!user) {\n  throw new Error('User must be authenticated');\n}\n\n// Now proceed with Firestore operation`,
+                    language: 'typescript',
+                },
+                confidence: 0.8,
+            },
+        ];
+        return {
+            diagnosis,
+            suggestedFixes: fixes,
+            shouldUncheckStep: false,
+            shouldInjectNewStep: false,
+        };
+    }
+    async analyzeFirebaseError(error, context) {
+        // Try to extract specific Firebase error code
+        const codeMatch = error.errorMessage.match(/auth\/[\w-]+/);
+        const errorCode = codeMatch?.[0];
+        let specificFix;
+        // Common Firebase Auth errors
+        const authErrorFixes = {
+            'auth/user-not-found': {
+                approach: 'Handle User Not Found',
+                steps: ['Check if user exists before operation', 'Provide user-friendly error message'],
+                confidence: 0.9,
+            },
+            'auth/wrong-password': {
+                approach: 'Handle Wrong Password',
+                steps: ['Show generic "invalid credentials" message for security', 'Offer password reset'],
+                confidence: 0.9,
+            },
+            'auth/email-already-in-use': {
+                approach: 'Handle Existing Email',
+                steps: ['Inform user the email is taken', 'Offer login option instead'],
+                confidence: 0.9,
+            },
+            'auth/weak-password': {
+                approach: 'Enforce Password Requirements',
+                steps: ['Show password requirements to user', 'Validate before submission'],
+                confidence: 0.9,
+            },
+        };
+        if (errorCode && authErrorFixes[errorCode]) {
+            specificFix = authErrorFixes[errorCode];
+        }
+        const diagnosis = {
+            rootCause: errorCode
+                ? `Firebase error: ${errorCode}`
+                : 'Firebase operation failed',
+            explanation: 'A Firebase service encountered an error. Check the specific error code for details.',
+            errorCategory: 'firebase_error',
+            severity: 'medium',
+        };
+        const fixes = specificFix
+            ? [specificFix]
+            : [
+                {
+                    approach: 'Add Error Handling',
+                    steps: [
+                        'Wrap Firebase calls in try-catch',
+                        'Check error.code for specific handling',
+                        'Provide user-friendly error messages',
+                    ],
+                    code: {
+                        filename: 'firebase-error-handling.ts',
+                        content: `try {\n  await firebaseOperation();\n} catch (error: any) {\n  switch (error.code) {\n    case 'auth/user-not-found':\n      // Handle specific error\n      break;\n    default:\n      console.error('Firebase error:', error);\n  }\n}`,
+                        language: 'typescript',
+                    },
+                    confidence: 0.75,
+                },
+            ];
+        return {
+            diagnosis,
+            suggestedFixes: fixes,
+            shouldUncheckStep: false,
+            shouldInjectNewStep: false,
+        };
+    }
+    async analyzeNetworkError(error, context) {
+        const diagnosis = {
+            rootCause: 'Network request failed - server unreachable or connection issue',
+            explanation: 'The API endpoint or server is not responding. This could be a server issue, CORS problem, or network connectivity.',
+            errorCategory: 'network_error',
+            severity: 'high',
+        };
+        const fixes = [
+            {
+                approach: 'Check API Server',
+                steps: [
+                    'Verify the API server is running',
+                    'Check the URL is correct',
+                    'Try the endpoint directly in browser or Postman',
+                ],
+                confidence: 0.8,
+            },
+            {
+                approach: 'Handle Network Errors',
+                steps: [
+                    'Add retry logic for transient failures',
+                    'Show user-friendly offline message',
+                    'Consider using a library like axios with interceptors',
+                ],
+                code: {
+                    filename: 'network-retry.ts',
+                    content: `async function fetchWithRetry(url: string, retries = 3): Promise<Response> {\n  for (let i = 0; i < retries; i++) {\n    try {\n      return await fetch(url);\n    } catch (error) {\n      if (i === retries - 1) throw error;\n      await new Promise(r => setTimeout(r, 1000 * (i + 1)));\n    }\n  }\n  throw new Error('Max retries reached');\n}`,
+                    language: 'typescript',
+                },
+                confidence: 0.85,
+            },
+        ];
+        return {
+            diagnosis,
+            suggestedFixes: fixes,
+            shouldUncheckStep: false,
+            shouldInjectNewStep: false,
+        };
+    }
+    async analyzeHTTPError(error, context) {
+        // Extract status code
+        const statusMatch = error.errorMessage.match(/\b([45]\d{2})\b/);
+        const statusCode = statusMatch ? parseInt(statusMatch[1]) : 500;
+        const statusMessages = {
+            400: 'Bad request - check your request payload',
+            401: 'Unauthorized - authentication required or token expired',
+            403: 'Forbidden - user lacks permission',
+            404: 'Not found - check the endpoint URL',
+            422: 'Validation error - check request data format',
+            429: 'Too many requests - implement rate limiting',
+            500: 'Server error - check server logs',
+            502: 'Bad gateway - upstream server issue',
+            503: 'Service unavailable - server may be down',
+        };
+        const diagnosis = {
+            rootCause: `HTTP ${statusCode}: ${statusMessages[statusCode] || 'Request failed'}`,
+            explanation: 'The API returned an error status code. Check the response body for details.',
+            errorCategory: 'http_error',
+            severity: statusCode >= 500 ? 'high' : 'medium',
+        };
+        const fixes = [];
+        if (statusCode === 401) {
+            fixes.push({
+                approach: 'Refresh Authentication',
+                steps: [
+                    'Check if auth token exists and is valid',
+                    'Implement token refresh logic',
+                    'Redirect to login if refresh fails',
+                ],
+                confidence: 0.9,
+            });
+        }
+        else if (statusCode === 404) {
+            fixes.push({
+                approach: 'Verify Endpoint',
+                steps: [
+                    'Check the API URL is correct',
+                    'Verify the resource ID exists',
+                    'Check if the endpoint is deployed',
+                ],
+                confidence: 0.85,
+            });
+        }
+        else {
+            fixes.push({
+                approach: 'Add Error Response Handling',
+                steps: [
+                    'Parse the error response body',
+                    'Display specific error message to user',
+                    'Log detailed error for debugging',
+                ],
+                code: {
+                    filename: 'http-error-handling.ts',
+                    content: `const response = await fetch(url);\nif (!response.ok) {\n  const errorData = await response.json().catch(() => ({}));\n  throw new Error(errorData.message || \`HTTP \${response.status}\`);\n}`,
+                    language: 'typescript',
+                },
+                confidence: 0.8,
+            });
+        }
+        return {
+            diagnosis,
+            suggestedFixes: fixes,
+            shouldUncheckStep: false,
+            shouldInjectNewStep: false,
+        };
+    }
+    async analyzeTestFailure(error, context) {
+        const diagnosis = {
+            rootCause: 'Test assertion failed',
+            explanation: 'A test expectation was not met. Either the test is wrong or the implementation needs fixing.',
+            errorCategory: 'test_failure',
+            severity: 'medium',
+        };
+        const fixes = [
+            {
+                approach: 'Review Test vs Implementation',
+                steps: [
+                    'Read the test to understand expected behavior',
+                    'Check if implementation matches requirements',
+                    'Verify test data and mocks are correct',
+                ],
+                confidence: 0.7,
+            },
+            {
+                approach: 'Debug with Console Logs',
+                steps: [
+                    'Add console.log to see actual values',
+                    'Compare with expected values',
+                    'Check for edge cases',
+                ],
+                confidence: 0.75,
+            },
+        ];
+        return {
+            diagnosis,
+            suggestedFixes: fixes,
+            shouldUncheckStep: false, // Tests failing doesn't necessarily mean step should be unchecked
+            shouldInjectNewStep: false,
+        };
+    }
+    async analyzeSyntaxError(error, context) {
+        // Try to extract line info
+        const lineMatch = error.stackTrace?.match(/:(\d+):\d+/);
+        const lineNumber = lineMatch?.[1];
+        const diagnosis = {
+            rootCause: 'Syntax error in code',
+            explanation: lineNumber
+                ? `There's a syntax error around line ${lineNumber}. Check for missing brackets, semicolons, or typos.`
+                : 'There\'s a syntax error in the code. Check for missing brackets, semicolons, or typos.',
+            errorCategory: 'syntax_error',
+            severity: 'high',
+        };
+        const fixes = [
+            {
+                approach: 'Check Common Syntax Issues',
+                steps: [
+                    'Look for unmatched brackets: { }, ( ), [ ]',
+                    'Check for missing commas in objects/arrays',
+                    'Verify template literal backticks are paired',
+                    'Check for missing semicolons (if required)',
+                ],
+                confidence: 0.9,
+            },
+            {
+                approach: 'Use IDE Features',
+                steps: [
+                    'Let your IDE highlight the syntax error',
+                    'Use "Format Document" to auto-fix some issues',
+                    'Check the Problems panel for details',
+                ],
+                confidence: 0.85,
+            },
+        ];
+        return {
+            diagnosis,
+            suggestedFixes: fixes,
+            shouldUncheckStep: false,
+            shouldInjectNewStep: false,
+        };
+    }
+    // ============================================================================
+    // GENERIC FALLBACK ANALYZER
+    // ============================================================================
+    async genericAnalysis(error, context) {
+        const diagnosis = {
+            rootCause: 'Error encountered during build step',
+            explanation: `An error occurred: "${error.errorMessage.substring(0, 200)}". Review the stack trace for more details.`,
+            errorCategory: error.errorType,
+            severity: 'medium',
+        };
+        const fixes = [
+            {
+                approach: 'Debug the Error',
+                steps: [
+                    'Review the full stack trace',
+                    'Add logging around the failing code',
+                    'Check recent changes that might have caused this',
+                    'Search for the error message online',
+                ],
+                confidence: 0.5,
+            },
+            {
+                approach: 'Isolate the Problem',
+                steps: [
+                    'Comment out recent code changes',
+                    'Test each piece individually',
+                    'Narrow down to the specific line causing issues',
+                ],
+                confidence: 0.6,
+            },
+        ];
+        return {
+            diagnosis,
+            suggestedFixes: fixes,
+            relatedDocs: {},
+            shouldUncheckStep: false,
+            shouldInjectNewStep: false,
+        };
+    }
+    // ============================================================================
+    // HELPER METHODS
+    // ============================================================================
+    buildFullResult(error, context, partialResult, errorType) {
+        return {
+            diagnosis: partialResult.diagnosis || {
+                rootCause: 'Unknown error',
+                explanation: error.errorMessage,
+                errorCategory: errorType,
+                severity: 'medium',
+            },
+            suggestedFixes: partialResult.suggestedFixes || [],
+            relatedDocs: partialResult.relatedDocs || {},
+            shouldUncheckStep: partialResult.shouldUncheckStep || false,
+            shouldInjectNewStep: partialResult.shouldInjectNewStep || false,
+            newStep: partialResult.newStep,
+        };
+    }
+}
+exports.ErrorAnalyzer = ErrorAnalyzer;
+//# sourceMappingURL=error-analyzer.js.map