clavix 4.0.0 → 4.1.1

package/dist/core/intelligence/intent-detector.js

@@ -5,122 +5,307 @@
 export class IntentDetector {
     // Strong indicators (20 points)
     STRONG_CODE_KEYWORDS = [
-        'create function', 'build component', 'implement feature', 'add endpoint',
-        'write class', 'develop api', 'generate code'
+        'create function',
+        'build component',
+        'implement feature',
+        'add endpoint',
+        'write class',
+        'develop api',
+        'generate code',
     ];
     STRONG_PLANNING_KEYWORDS = [
-        'how should i', 'what\'s the best way', 'pros and cons', 'architecture for',
-        'design pattern', 'system design', 'should i use', 'help me choose',
-        'design the database', 'plan the', 'requirements document',
+        'how should i',
+        "what's the best way",
+        'pros and cons',
+        'architecture for',
+        'design pattern',
+        'system design',
+        'should i use',
+        'help me choose',
+        'design the database',
+        'plan the',
+        'requirements document',
         // v4.0: Spec-driven development keywords
-        'write spec', 'create spec', 'spec document', 'functional spec', 'technical spec',
-        'design spec', 'specification for', 'write specification'
+        'write spec',
+        'create spec',
+        'spec document',
+        'functional spec',
+        'technical spec',
+        'design spec',
+        'specification for',
+        'write specification',
     ];
     STRONG_DEBUGGING_KEYWORDS = [
-        'fix error', 'debug issue', 'doesn\'t work', 'throws error', 'not working',
-        'returns null', 'undefined error', 'stack trace', 'error message',
-        'causing this bug', 'how do i fix', 'fix this error', 'resolve the', 'memory leak',
-        'not rendering', 'why is my'
+        'fix error',
+        'debug issue',
+        "doesn't work",
+        'throws error',
+        'not working',
+        'returns null',
+        'undefined error',
+        'stack trace',
+        'error message',
+        'causing this bug',
+        'how do i fix',
+        'fix this error',
+        'resolve the',
+        'memory leak',
+        'not rendering',
+        'why is my',
     ];
     STRONG_DOCUMENTATION_KEYWORDS = [
-        'explain how', 'walk me through', 'how does this work', 'show me how',
-        'document this', 'describe how', 'what does this do', 'write documentation',
-        'create documentation', 'add documentation', 'api documentation', 'add comments'
+        'explain how',
+        'walk me through',
+        'how does this work',
+        'show me how',
+        'document this',
+        'describe how',
+        'what does this do',
+        'write documentation',
+        'create documentation',
+        'add documentation',
+        'api documentation',
+        'add comments',
     ];
     STRONG_REFINEMENT_KEYWORDS = [
-        'make it faster', 'speed up', 'reduce time', 'optimize performance',
-        'clean up code', 'refactor this', 'improve efficiency', 'make this component',
-        'make it more', 'enhance the', 'update the styling', 'more reusable', 'more modern'
+        'make it faster',
+        'speed up',
+        'reduce time',
+        'optimize performance',
+        'clean up code',
+        'refactor this',
+        'improve efficiency',
+        'make this component',
+        'make it more',
+        'enhance the',
+        'update the styling',
+        'more reusable',
+        'more modern',
     ];
     // v4.0: New intent - Testing
     STRONG_TESTING_KEYWORDS = [
-        'write test', 'unit test', 'integration test', 'test coverage', 'add test',
-        'create test', 'write tests for', 'add tests for', 'test this', 'e2e test',
-        'end to end test', 'snapshot test', 'test suite'
+        'write test',
+        'unit test',
+        'integration test',
+        'test coverage',
+        'add test',
+        'create test',
+        'write tests for',
+        'add tests for',
+        'test this',
+        'e2e test',
+        'end to end test',
+        'snapshot test',
+        'test suite',
     ];
     // v4.0: New intent - Migration
     STRONG_MIGRATION_KEYWORDS = [
-        'migrate from', 'migrate to', 'upgrade from', 'upgrade to', 'port from',
-        'port to', 'convert from', 'convert to', 'transition from', 'move from',
-        'update from version', 'upgrade version'
+        'migrate from',
+        'migrate to',
+        'upgrade from',
+        'upgrade to',
+        'port from',
+        'port to',
+        'convert from',
+        'convert to',
+        'transition from',
+        'move from',
+        'update from version',
+        'upgrade version',
     ];
     // v4.0: New intent - Security Review
     STRONG_SECURITY_KEYWORDS = [
-        'security audit', 'find vulnerabilities', 'check for injection', 'security scan',
-        'audit security', 'review for security', 'penetration test', 'security review',
-        'check for xss', 'check for csrf', 'vulnerability scan', 'security assessment'
+        'security audit',
+        'find vulnerabilities',
+        'check for injection',
+        'security scan',
+        'audit security',
+        'review for security',
+        'penetration test',
+        'security review',
+        'check for xss',
+        'check for csrf',
+        'vulnerability scan',
+        'security assessment',
     ];
     // v4.0: New intent - Learning
     STRONG_LEARNING_KEYWORDS = [
-        'teach me', 'explain how', 'help me understand', 'what is the concept',
-        'how does', 'why does', 'learn about', 'understand how', 'what are',
-        'difference between', 'when should i use', 'best practices for'
+        'teach me',
+        'explain how',
+        'help me understand',
+        'what is the concept',
+        'how does',
+        'why does',
+        'learn about',
+        'understand how',
+        'what are',
+        'difference between',
+        'when should i use',
+        'best practices for',
     ];
     // Medium indicators (10 points)
     CODE_KEYWORDS = [
-        'function', 'class', 'component', 'api', 'endpoint', 'database',
-        'implement', 'build', 'create', 'write', 'code', 'develop'
+        'function',
+        'class',
+        'component',
+        'api',
+        'endpoint',
+        'database',
+        'implement',
+        'build',
+        'create',
+        'write',
+        'code',
+        'develop',
     ];
     PLANNING_KEYWORDS = [
-        'plan', 'design', 'architect', 'strategy', 'approach', 'structure',
-        'organize', 'layout', 'workflow',
+        'plan',
+        'design',
+        'architect',
+        'strategy',
+        'approach',
+        'structure',
+        'organize',
+        'layout',
+        'workflow',
         // v4.0: Spec-driven development keywords
-        'spec', 'specification', 'requirements', 'blueprint', 'outline'
+        'spec',
+        'specification',
+        'requirements',
+        'blueprint',
+        'outline',
     ];
     REFINEMENT_KEYWORDS = [
-        'improve', 'optimize', 'refactor', 'enhance', 'better', 'faster',
-        'cleaner', 'simplify', 'reduce', 'increase'
+        'improve',
+        'optimize',
+        'refactor',
+        'enhance',
+        'better',
+        'faster',
+        'cleaner',
+        'simplify',
+        'reduce',
+        'increase',
     ];
     DEBUGGING_KEYWORDS = [
-        'fix', 'debug', 'error', 'bug', 'issue', 'problem', 'failing',
-        'broken', 'crash', 'exception', 'incorrect', 'wrong'
+        'fix',
+        'debug',
+        'error',
+        'bug',
+        'issue',
+        'problem',
+        'failing',
+        'broken',
+        'crash',
+        'exception',
+        'incorrect',
+        'wrong',
     ];
     DOCUMENTATION_KEYWORDS = [
-        'explain', 'document', 'describe', 'understand',
-        'clarify', 'comment', 'documentation', 'guide', 'tutorial'
+        'explain',
+        'document',
+        'describe',
+        'understand',
+        'clarify',
+        'comment',
+        'documentation',
+        'guide',
+        'tutorial',
     ];
     // v4.0: Medium keywords for new intents
     TESTING_KEYWORDS = [
-        'test', 'coverage', 'jest', 'pytest', 'mocha', 'vitest', 'mock',
-        'assertion', 'expect', 'describe', 'spec', 'fixture', 'stub', 'spy'
+        'test',
+        'coverage',
+        'jest',
+        'pytest',
+        'mocha',
+        'vitest',
+        'mock',
+        'assertion',
+        'expect',
+        'describe',
+        'spec',
+        'fixture',
+        'stub',
+        'spy',
     ];
     MIGRATION_KEYWORDS = [
-        'migrate', 'migration', 'upgrade', 'port', 'convert', 'transition',
-        'legacy', 'deprecated', 'version', 'breaking change', 'compatibility'
+        'migrate',
+        'migration',
+        'upgrade',
+        'port',
+        'convert',
+        'transition',
+        'legacy',
+        'deprecated',
+        'version',
+        'breaking change',
+        'compatibility',
     ];
     SECURITY_KEYWORDS = [
-        'security', 'vulnerability', 'xss', 'csrf', 'injection', 'sanitize',
-        'escape', 'owasp', 'cve', 'exploit', 'attack', 'threat', 'risk'
+        'security',
+        'vulnerability',
+        'xss',
+        'csrf',
+        'injection',
+        'sanitize',
+        'escape',
+        'owasp',
+        'cve',
+        'exploit',
+        'attack',
+        'threat',
+        'risk',
     ];
     LEARNING_KEYWORDS = [
-        'understand', 'learn', 'concept', 'basics', 'fundamentals', 'tutorial',
-        'introduction', 'beginner', 'overview', 'theory', 'principle'
+        'understand',
+        'learn',
+        'concept',
+        'basics',
+        'fundamentals',
+        'tutorial',
+        'introduction',
+        'beginner',
+        'overview',
+        'theory',
+        'principle',
     ];
     // Weak indicators (5 points)
     WEAK_CODE_KEYWORDS = [
-        'react', 'vue', 'angular', 'python', 'javascript', 'typescript',
-        'java', 'rust', 'go', 'php', 'ruby', 'swift', 'kotlin', 'system', 'feature'
+        'react',
+        'vue',
+        'angular',
+        'python',
+        'javascript',
+        'typescript',
+        'java',
+        'rust',
+        'go',
+        'php',
+        'ruby',
+        'swift',
+        'kotlin',
+        'system',
+        'feature',
     ];
     // Negation words (reduces score by 50%)
-    NEGATION_WORDS = [
-        'don\'t', 'dont', 'not', 'avoid', 'without', 'never', 'no'
-    ];
+    NEGATION_WORDS = ["don't", 'dont', 'not', 'avoid', 'without', 'never', 'no'];
     analyze(prompt) {
         const lowerPrompt = prompt.toLowerCase();
         const words = lowerPrompt.split(/\s+/);
         // Calculate weighted scores for each intent
         const scores = {
             'code-generation': this.calculateIntentScore(lowerPrompt, words, 'code-generation'),
-            'planning': this.calculateIntentScore(lowerPrompt, words, 'planning'),
-            'refinement': this.calculateIntentScore(lowerPrompt, words, 'refinement'),
-            'debugging': this.calculateIntentScore(lowerPrompt, words, 'debugging'),
-            'documentation': this.calculateIntentScore(lowerPrompt, words, 'documentation'),
+            planning: this.calculateIntentScore(lowerPrompt, words, 'planning'),
+            refinement: this.calculateIntentScore(lowerPrompt, words, 'refinement'),
+            debugging: this.calculateIntentScore(lowerPrompt, words, 'debugging'),
+            documentation: this.calculateIntentScore(lowerPrompt, words, 'documentation'),
             'prd-generation': 0, // PRD is explicit command, not inferred
             // v4.0: New intents
-            'testing': this.calculateIntentScore(lowerPrompt, words, 'testing'),
-            'migration': this.calculateIntentScore(lowerPrompt, words, 'migration'),
+            testing: this.calculateIntentScore(lowerPrompt, words, 'testing'),
+            migration: this.calculateIntentScore(lowerPrompt, words, 'migration'),
             'security-review': this.calculateIntentScore(lowerPrompt, words, 'security-review'),
-            'learning': this.calculateIntentScore(lowerPrompt, words, 'learning')
+            learning: this.calculateIntentScore(lowerPrompt, words, 'learning'),
         };
         // Apply intent priority rules
         const primaryIntent = this.selectPrimaryIntent(scores, lowerPrompt);
@@ -131,7 +316,7 @@ export class IntentDetector {
             hasCodeContext: this.hasCodeContext(prompt),
             hasTechnicalTerms: this.hasTechnicalTerms(lowerPrompt),
             isOpenEnded: this.isOpenEnded(prompt),
-            needsStructure: this.needsStructure(prompt, primaryIntent)
+            needsStructure: this.needsStructure(prompt, primaryIntent),
         };
         // Suggest mode
         const suggestedMode = this.suggestMode(primaryIntent, characteristics, prompt.length, confidence);
@@ -139,7 +324,7 @@ export class IntentDetector {
             primaryIntent,
             confidence,
             characteristics,
-            suggestedMode
+            suggestedMode,
         };
     }
     calculateIntentScore(prompt, words, intent) {
@@ -174,56 +359,56 @@ export class IntentDetector {
                 return {
                     strong: this.STRONG_CODE_KEYWORDS,
                     medium: this.CODE_KEYWORDS,
-                    weak: this.WEAK_CODE_KEYWORDS
+                    weak: this.WEAK_CODE_KEYWORDS,
                 };
             case 'planning':
                 return {
                     strong: this.STRONG_PLANNING_KEYWORDS,
                     medium: this.PLANNING_KEYWORDS,
-                    weak: []
+                    weak: [],
                 };
             case 'debugging':
                 return {
                     strong: this.STRONG_DEBUGGING_KEYWORDS,
                     medium: this.DEBUGGING_KEYWORDS,
-                    weak: []
+                    weak: [],
                 };
             case 'documentation':
                 return {
                     strong: this.STRONG_DOCUMENTATION_KEYWORDS,
                     medium: this.DOCUMENTATION_KEYWORDS,
-                    weak: []
+                    weak: [],
                 };
             case 'refinement':
                 return {
                     strong: this.STRONG_REFINEMENT_KEYWORDS,
                     medium: this.REFINEMENT_KEYWORDS,
-                    weak: []
+                    weak: [],
                 };
             // v4.0: New intents
             case 'testing':
                 return {
                     strong: this.STRONG_TESTING_KEYWORDS,
                     medium: this.TESTING_KEYWORDS,
-                    weak: []
+                    weak: [],
                 };
             case 'migration':
                 return {
                     strong: this.STRONG_MIGRATION_KEYWORDS,
                     medium: this.MIGRATION_KEYWORDS,
-                    weak: []
+                    weak: [],
                 };
             case 'security-review':
                 return {
                     strong: this.STRONG_SECURITY_KEYWORDS,
                     medium: this.SECURITY_KEYWORDS,
-                    weak: []
+                    weak: [],
                 };
             case 'learning':
                 return {
                     strong: this.STRONG_LEARNING_KEYWORDS,
                     medium: this.LEARNING_KEYWORDS,
-                    weak: []
+                    weak: [],
                 };
             default:
                 return { strong: [], medium: [], weak: [] };
@@ -246,11 +431,13 @@ export class IntentDetector {
     getContextBonus(prompt, intent) {
         let bonus = 0;
         // Code snippet bonus for debugging/refinement/testing
-        if ((intent === 'debugging' || intent === 'refinement' || intent === 'testing') && this.hasCodeContext(prompt)) {
+        if ((intent === 'debugging' || intent === 'refinement' || intent === 'testing') &&
+            this.hasCodeContext(prompt)) {
             bonus += 15;
         }
         // Question mark bonus for planning/documentation/learning
-        if ((intent === 'planning' || intent === 'documentation' || intent === 'learning') && prompt.includes('?')) {
+        if ((intent === 'planning' || intent === 'documentation' || intent === 'learning') &&
+            prompt.includes('?')) {
             bonus += 10;
         }
         // Technical terms bonus for code-generation
@@ -279,11 +466,11 @@ export class IntentDetector {
     // v4.0: Helper methods for new intent bonuses
     hasTestingFrameworkTerms(prompt) {
         const terms = ['jest', 'mocha', 'pytest', 'vitest', 'cypress', 'playwright', 'testing-library'];
-        return terms.some(term => prompt.includes(term));
+        return terms.some((term) => prompt.includes(term));
     }
     hasSecurityTerms(prompt) {
         const terms = ['owasp', 'cve', 'vulnerability', 'exploit', 'injection', 'xss', 'csrf'];
-        return terms.some(term => prompt.includes(term));
+        return terms.some((term) => prompt.includes(term));
     }
     hasMigrationPatterns(prompt) {
         // Check for version patterns like "v1 to v2", "17 to 18", "2.x to 3.x"
@@ -293,49 +480,75 @@ export class IntentDetector {
     }
     selectPrimaryIntent(scores, prompt) {
         // Priority 1: Debugging (if strong indicators present)
-        if (scores.debugging >= 20 && (prompt.includes('error') || prompt.includes('bug') || prompt.includes('fix') ||
-            prompt.includes('debug') || prompt.includes('issue') || prompt.includes('resolve'))) {
+        if (scores.debugging >= 20 &&
+            (prompt.includes('error') ||
+                prompt.includes('bug') ||
+                prompt.includes('fix') ||
+                prompt.includes('debug') ||
+                prompt.includes('issue') ||
+                prompt.includes('resolve'))) {
             return 'debugging';
         }
         // Priority 2: Security Review (if security audit explicitly requested)
-        if (scores['security-review'] >= 20 && (prompt.includes('security') || prompt.includes('vulnerability') ||
-            prompt.includes('audit') || prompt.includes('owasp'))) {
+        if (scores['security-review'] >= 20 &&
+            (prompt.includes('security') ||
+                prompt.includes('vulnerability') ||
+                prompt.includes('audit') ||
+                prompt.includes('owasp'))) {
             return 'security-review';
         }
         // Priority 3: Testing (if test creation explicitly requested)
-        if (scores.testing >= 20 && (prompt.includes('test') || prompt.includes('coverage') ||
-            prompt.includes('spec') && !prompt.includes('specification'))) {
+        if (scores.testing >= 20 &&
+            (prompt.includes('test') ||
+                prompt.includes('coverage') ||
+                (prompt.includes('spec') && !prompt.includes('specification')))) {
             return 'testing';
         }
         // Priority 4: Migration (if version upgrade explicitly requested)
-        if (scores.migration >= 20 && (prompt.includes('migrate') || prompt.includes('upgrade') ||
-            prompt.includes('port') || this.hasMigrationPatterns(prompt))) {
+        if (scores.migration >= 20 &&
+            (prompt.includes('migrate') ||
+                prompt.includes('upgrade') ||
+                prompt.includes('port') ||
+                this.hasMigrationPatterns(prompt))) {
             return 'migration';
         }
         // Priority 5: Documentation (if explanation requested or write documentation)
-        if (scores.documentation >= 20 && (prompt.includes('explain') || prompt.includes('how does') ||
-            prompt.includes('documentation') || (prompt.includes('write') && prompt.includes('document')))) {
+        if (scores.documentation >= 20 &&
+            (prompt.includes('explain') ||
+                prompt.includes('how does') ||
+                prompt.includes('documentation') ||
+                (prompt.includes('write') && prompt.includes('document')))) {
             return 'documentation';
         }
         // Priority 6: Learning (if conceptual understanding requested)
-        if (scores.learning >= 20 && (prompt.includes('teach') || prompt.includes('learn') ||
-            prompt.includes('understand') || prompt.includes('concept'))) {
+        if (scores.learning >= 20 &&
+            (prompt.includes('teach') ||
+                prompt.includes('learn') ||
+                prompt.includes('understand') ||
+                prompt.includes('concept'))) {
             return 'learning';
         }
         // Priority 7: Planning (if architecture/design question or spec-driven)
-        if (scores.planning >= 20 && (prompt.includes('how should') || prompt.includes('architecture') ||
-            prompt.includes('what is the best') || prompt.includes('specification') ||
-            (prompt.includes('spec') && !prompt.includes('test')))) {
+        if (scores.planning >= 20 &&
+            (prompt.includes('how should') ||
+                prompt.includes('architecture') ||
+                prompt.includes('what is the best') ||
+                prompt.includes('specification') ||
+                (prompt.includes('spec') && !prompt.includes('test')))) {
             return 'planning';
         }
         // Priority 8: Refinement (if improvement requested)
-        if (scores.refinement >= 15 && (prompt.includes('improve') || prompt.includes('optimize') ||
-            prompt.includes('enhance') || prompt.includes('make') || prompt.includes('refactor'))) {
+        if (scores.refinement >= 15 &&
+            (prompt.includes('improve') ||
+                prompt.includes('optimize') ||
+                prompt.includes('enhance') ||
+                prompt.includes('make') ||
+                prompt.includes('refactor'))) {
             return 'refinement';
         }
         // Default: Highest score
         const entries = Object.entries(scores);
-        const [primaryIntent] = entries.reduce((max, current) => current[1] > max[1] ? current : max);
+        const [primaryIntent] = entries.reduce((max, current) => (current[1] > max[1] ? current : max));
         return primaryIntent;
     }
     calculateConfidence(scores, primaryIntent) {
@@ -375,32 +588,54 @@ export class IntentDetector {
             /def\s+\w+\s*\(/,
             /import\s+/,
             /<\w+>/,
-            /\w+\.\w+\(/
+            /\w+\.\w+\(/,
         ];
-        return codePatterns.some(pattern => pattern.test(prompt));
+        return codePatterns.some((pattern) => pattern.test(prompt));
     }
     hasTechnicalTerms(prompt) {
         const terms = [
-            'api', 'database', 'sql', 'rest', 'graphql', 'jwt',
-            'authentication', 'middleware', 'framework', 'library',
-            'npm', 'docker', 'aws', 'frontend', 'backend', 'microservice'
+            'api',
+            'database',
+            'sql',
+            'rest',
+            'graphql',
+            'jwt',
+            'authentication',
+            'middleware',
+            'framework',
+            'library',
+            'npm',
+            'docker',
+            'aws',
+            'frontend',
+            'backend',
+            'microservice',
         ];
-        return terms.some(term => prompt.includes(term));
+        return terms.some((term) => prompt.includes(term));
     }
     hasPerformanceTerms(prompt) {
         const terms = [
-            'performance', 'speed', 'fast', 'slow', 'optimize', 'latency',
-            'throughput', 'memory', 'cpu', 'load time', 'response time'
+            'performance',
+            'speed',
+            'fast',
+            'slow',
+            'optimize',
+            'latency',
+            'throughput',
+            'memory',
+            'cpu',
+            'load time',
+            'response time',
         ];
-        return terms.some(term => prompt.includes(term));
+        return terms.some((term) => prompt.includes(term));
     }
     isOpenEnded(prompt) {
         const questionWords = ['how', 'what', 'why', 'when', 'where', 'which', 'should'];
         const lowerPrompt = prompt.toLowerCase();
-        const hasQuestionWord = questionWords.some(word => lowerPrompt.startsWith(word));
+        const hasQuestionWord = questionWords.some((word) => lowerPrompt.startsWith(word));
         const hasQuestionMark = prompt.includes('?');
         const vaguePatterns = ['help me', 'i need', 'not sure', 'maybe', 'somehow'];
-        const hasVague = vaguePatterns.some(pattern => lowerPrompt.includes(pattern));
+        const hasVague = vaguePatterns.some((pattern) => lowerPrompt.includes(pattern));
         return hasQuestionWord || hasQuestionMark || hasVague;
     }
     needsStructure(prompt, intent) {
@@ -409,8 +644,7 @@ export class IntentDetector {
         const hasObjective = /objective|goal|purpose|need to|want to/i.test(prompt);
         const hasRequirements = /requirement|must|should|need|expect/i.test(prompt);
         const hasConstraints = /constraint|limit|within|must not|cannot/i.test(prompt);
-        const structureScore = [hasObjective, hasRequirements, hasConstraints]
-            .filter(Boolean).length;
+        const structureScore = [hasObjective, hasRequirements, hasConstraints].filter(Boolean).length;
         return structureScore < 2;
     }
     suggestMode(intent, characteristics, promptLength, confidence) {
@@ -442,15 +676,15 @@ export class IntentDetector {
         // Calculate all scores for secondary intent detection
         const scores = {
             'code-generation': this.calculateIntentScore(lowerPrompt, words, 'code-generation'),
-            'planning': this.calculateIntentScore(lowerPrompt, words, 'planning'),
-            'refinement': this.calculateIntentScore(lowerPrompt, words, 'refinement'),
-            'debugging': this.calculateIntentScore(lowerPrompt, words, 'debugging'),
-            'documentation': this.calculateIntentScore(lowerPrompt, words, 'documentation'),
+            planning: this.calculateIntentScore(lowerPrompt, words, 'planning'),
+            refinement: this.calculateIntentScore(lowerPrompt, words, 'refinement'),
+            debugging: this.calculateIntentScore(lowerPrompt, words, 'debugging'),
+            documentation: this.calculateIntentScore(lowerPrompt, words, 'documentation'),
             'prd-generation': 0,
-            'testing': this.calculateIntentScore(lowerPrompt, words, 'testing'),
-            'migration': this.calculateIntentScore(lowerPrompt, words, 'migration'),
+            testing: this.calculateIntentScore(lowerPrompt, words, 'testing'),
+            migration: this.calculateIntentScore(lowerPrompt, words, 'migration'),
             'security-review': this.calculateIntentScore(lowerPrompt, words, 'security-review'),
-            'learning': this.calculateIntentScore(lowerPrompt, words, 'learning')
+            learning: this.calculateIntentScore(lowerPrompt, words, 'learning'),
         };
         // Get secondary intents (top 2-3 after primary, with score > 10)
         const secondaryIntents = this.getSecondaryIntents(scores, basicAnalysis.primaryIntent);
@@ -459,11 +693,10 @@ export class IntentDetector {
         return {
             ...basicAnalysis,
             secondaryIntents,
-            intentAmbiguity
+            intentAmbiguity,
         };
     }
     getSecondaryIntents(scores, primaryIntent) {
-        const primaryScore = scores[primaryIntent];
         const totalScore = Object.values(scores).reduce((sum, s) => sum + s, 0);
         if (totalScore === 0)
             return [];
@@ -473,12 +706,11 @@ export class IntentDetector {
             .slice(0, 2)
             .map(([intent, score]) => ({
             intent: intent,
-            confidence: Math.round((score / totalScore) * 100)
+            confidence: Math.round((score / totalScore) * 100),
         }));
     }
-    calculateAmbiguity(scores, primaryIntent) {
-        const sortedScores = Object.entries(scores)
-            .sort(([, a], [, b]) => b - a);
+    calculateAmbiguity(scores, _primaryIntent) {
+        const sortedScores = Object.entries(scores).sort(([, a], [, b]) => b - a);
         if (sortedScores.length < 2)
             return 'low';
         const primaryScore = sortedScores[0][1];