clavix 2.8.2 → 3.0.1

package/dist/cli/commands/summarize.js

@@ -4,9 +4,9 @@ import * as path from 'path';
 import { SessionManager } from '../../core/session-manager.js';
 import { ConversationAnalyzer } from '../../core/conversation-analyzer.js';
 import { FileSystem } from '../../utils/file-system.js';
-import { PromptOptimizer } from '../../core/prompt-optimizer.js';
+import { UniversalOptimizer } from '../../core/intelligence/index.js';
 export default class Summarize extends Command {
-    static description = 'Analyze a conversation session and extract structured requirements';
+    static description = 'Analyze a conversation session and extract structured requirements with automatic optimization';
     static examples = [
         '<%= config.bin %> <%= command.id %>',
         '<%= config.bin %> <%= command.id %> <session-id>',
@@ -28,14 +28,10 @@ export default class Summarize extends Command {
             char: 'o',
             description: 'Output directory (defaults to .clavix/outputs/[session-name])',
         }),
-        'skip-clear': Flags.boolean({
-            description: 'Skip CLEAR framework optimization of extracted prompt',
-            default: false,
-        }),
     };
     async run() {
         const { args, flags } = await this.parse(Summarize);
-        console.log(chalk.bold.cyan('\nConversation Summarizer\n'));
+        console.log(chalk.bold.cyan('\n📊 Conversation Summarizer\n'));
         try {
             const manager = new SessionManager();
             const analyzer = new ConversationAnalyzer();
@@ -91,35 +87,27 @@ export default class Summarize extends Command {
             const miniPrdContent = analyzer.generateMiniPrd(session, analysis);
             const miniPrdPath = path.join(outputDir, 'mini-prd.md');
             await FileSystem.writeFileAtomic(miniPrdPath, miniPrdContent);
-            // Generate optimized prompt
-            const optimizedPromptContent = analyzer.generateOptimizedPrompt(session, analysis);
-            const optimizedPromptPath = path.join(outputDir, 'optimized-prompt.md');
-            await FileSystem.writeFileAtomic(optimizedPromptPath, optimizedPromptContent);
-            // CLEAR optimization (unless skipped)
-            if (!flags['skip-clear']) {
-                await this.applyClearOptimization(optimizedPromptContent, outputDir);
-            }
+            // Generate optimized prompt (initial extraction)
+            const rawPromptContent = analyzer.generateOptimizedPrompt(session, analysis);
+            // Save original extracted version
+            const originalPromptPath = path.join(outputDir, 'original-prompt.md');
+            await FileSystem.writeFileAtomic(originalPromptPath, rawPromptContent);
+            // Always apply optimization with Universal Optimizer
+            await this.applyOptimization(rawPromptContent, outputDir);
             // Display success
-            console.log(chalk.bold.green('Analysis complete!\n'));
+            console.log(chalk.bold.green('\n✓ Analysis complete!\n'));
             console.log(chalk.bold('Generated files:'));
             console.log(chalk.gray('  • ') + chalk.cyan('mini-prd.md') + chalk.dim(' - Structured requirements document'));
-            console.log(chalk.gray('  • ') + chalk.cyan('optimized-prompt.md') + chalk.dim(' - AI-ready development prompt'));
-            if (!flags['skip-clear']) {
-                console.log(chalk.gray('  • ') + chalk.cyan('clear-optimized-prompt.md') + chalk.dim(' - CLEAR-enhanced version (C, L, E)'));
-            }
+            console.log(chalk.gray('  • ') + chalk.cyan('original-prompt.md') + chalk.dim(' - Raw extracted prompt'));
+            console.log(chalk.gray('  • ') + chalk.cyan('optimized-prompt.md') + chalk.dim(' - Enhanced AI-ready prompt'));
             console.log();
             console.log(chalk.bold('Output location:'));
             console.log(chalk.dim(`  ${outputDir}`));
             console.log();
-            console.log(chalk.bold('Next steps:'));
-            if (!flags['skip-clear']) {
-                console.log(chalk.gray('  • Use ') + chalk.cyan('clear-optimized-prompt.md') + chalk.gray(' for best AI results (CLEAR-optimized)'));
-                console.log(chalk.gray('  • Or use ') + chalk.cyan('optimized-prompt.md') + chalk.gray(' for the original extracted version'));
-            }
-            else {
-                console.log(chalk.gray('  • Use ') + chalk.cyan('optimized-prompt.md') + chalk.gray(' as input for your AI agent'));
-            }
+            console.log(chalk.bold('💡 Next steps:'));
+            console.log(chalk.gray('  • Use ') + chalk.cyan('optimized-prompt.md') + chalk.gray(' for best AI results'));
             console.log(chalk.gray('  • Share ') + chalk.cyan('mini-prd.md') + chalk.gray(' with your team for alignment'));
+            console.log(chalk.gray('  • Run ') + chalk.cyan('clavix implement') + chalk.gray(' to start development'));
             console.log();
         }
         catch (error) {
@@ -127,129 +115,73 @@ export default class Summarize extends Command {
             this.error(errorMessage);
         }
     }
-    /**
-     * Display analysis summary
-     */
     displayAnalysisSummary(analysis) {
-        console.log(chalk.bold('Analysis Summary:'));
-        console.log();
+        console.log(chalk.bold.cyan('Analysis Summary:\n'));
         if (analysis.keyRequirements.length > 0) {
-            console.log(chalk.bold.cyan('Key Requirements:'));
-            analysis.keyRequirements.forEach((req) => {
-                console.log(chalk.gray('  • ') + req);
+            console.log(chalk.bold('Key Requirements:'));
+            analysis.keyRequirements.slice(0, 5).forEach((req, i) => {
+                console.log(chalk.gray(`  ${i + 1}. ${req}`));
             });
+            if (analysis.keyRequirements.length > 5) {
+                console.log(chalk.dim(`  ... and ${analysis.keyRequirements.length - 5} more`));
+            }
             console.log();
         }
         if (analysis.technicalConstraints.length > 0) {
-            console.log(chalk.bold.cyan('Technical Constraints:'));
-            analysis.technicalConstraints.forEach((constraint) => {
-                console.log(chalk.gray('  • ') + constraint);
+            console.log(chalk.bold('Technical Constraints:'));
+            analysis.technicalConstraints.slice(0, 3).forEach(constraint => {
+                console.log(chalk.gray(`  • ${constraint}`));
             });
+            if (analysis.technicalConstraints.length > 3) {
+                console.log(chalk.dim(`  ... and ${analysis.technicalConstraints.length - 3} more`));
+            }
             console.log();
         }
         if (analysis.successCriteria.length > 0) {
-            console.log(chalk.bold.cyan('Success Criteria:'));
-            analysis.successCriteria.forEach((criteria) => {
-                console.log(chalk.gray('  • ') + criteria);
-            });
-            console.log();
-        }
-        if (analysis.outOfScope.length > 0) {
-            console.log(chalk.bold.yellow('Out of Scope:'));
-            analysis.outOfScope.forEach((item) => {
-                console.log(chalk.gray('  • ') + item);
+            console.log(chalk.bold('Success Criteria:'));
+            analysis.successCriteria.slice(0, 3).forEach(criterion => {
+                console.log(chalk.gray(`  ✓ ${criterion}`));
             });
+            if (analysis.successCriteria.length > 3) {
+                console.log(chalk.dim(`  ... and ${analysis.successCriteria.length - 3} more`));
+            }
             console.log();
         }
     }
-    /**
-     * Sanitize project name for directory name
-     */
-    sanitizeProjectName(name) {
-        return name
-            .toLowerCase()
-            .replace(/[^a-z0-9-]/g, '-')
-            .replace(/-+/g, '-')
-            .replace(/^-|-$/g, '')
-            .substring(0, 50);
-    }
-    /**
-     * Apply CLEAR framework optimization to extracted prompt
-     * Shows both raw extraction and CLEAR-enhanced version
-     */
-    async applyClearOptimization(rawPrompt, outputDir) {
+    async applyOptimization(rawPrompt, outputDir) {
         try {
-            console.log(chalk.bold.cyan('\n🎯 CLEAR Framework Optimization\n'));
-            console.log(chalk.gray('Applying CLEAR framework to extracted prompt...\n'));
-            const optimizer = new PromptOptimizer();
-            const clearResult = optimizer.applyCLEARFramework(rawPrompt, 'fast');
-            const clearScore = optimizer.calculateCLEARScore(clearResult);
-            const getScoreColor = (score) => {
-                if (score >= 80)
-                    return chalk.green;
-                if (score >= 60)
-                    return chalk.yellow;
-                return chalk.red;
-            };
-            // Display comparison
-            console.log(chalk.bold('CLEAR Analysis of Extracted Prompt:\n'));
-            // Conciseness
-            const cColor = getScoreColor(clearScore.conciseness);
-            console.log(cColor(`  [C] Concise: ${clearScore.conciseness.toFixed(0)}%`));
-            if (clearResult.conciseness.suggestions.length > 0) {
-                console.log(cColor(`      ${clearResult.conciseness.suggestions[0]}`));
-            }
-            console.log();
-            // Logic
-            const lColor = getScoreColor(clearScore.logic);
-            console.log(lColor(`  [L] Logical: ${clearScore.logic.toFixed(0)}%`));
-            if (clearResult.logic.suggestions.length > 0) {
-                console.log(lColor(`      ${clearResult.logic.suggestions[0]}`));
-            }
-            console.log();
-            // Explicitness
-            const eColor = getScoreColor(clearScore.explicitness);
-            console.log(eColor(`  [E] Explicit: ${clearScore.explicitness.toFixed(0)}%`));
-            if (clearResult.explicitness.suggestions.length > 0) {
-                console.log(eColor(`      ${clearResult.explicitness.suggestions[0]}`));
+            console.log(chalk.dim('Optimizing extracted prompt...\n'));
+            const optimizer = new UniversalOptimizer();
+            const result = await optimizer.optimize(rawPrompt, 'fast');
+            // Display optimization results
+            console.log(chalk.bold('✨ Optimization Results:\n'));
+            console.log(chalk.cyan(`  Intent: ${result.intent.primaryIntent}`));
+            console.log(chalk.cyan(`  Quality: ${result.quality.overall.toFixed(0)}%`));
+            if (result.improvements.length > 0) {
+                console.log(chalk.cyan(`  Improvements: ${result.improvements.length} applied\n`));
             }
-            console.log();
-            // Overall
-            const overallColor = getScoreColor(clearScore.overall);
-            console.log(overallColor(`  Overall: ${clearScore.overall.toFixed(0)}% (${clearScore.rating})\n`));
-            // Display CLEAR changes made
-            if (clearResult.changesSummary && clearResult.changesSummary.length > 0) {
-                console.log(chalk.bold.magenta('CLEAR Improvements Applied:\n'));
-                clearResult.changesSummary.slice(0, 3).forEach((change) => {
-                    console.log(chalk.magenta(`  [${change.component}] ${change.change}`));
-                });
+            else {
                 console.log();
             }
-            // Save CLEAR-optimized version
-            const clearOptimizedPath = path.join(outputDir, 'clear-optimized-prompt.md');
-            const clearOptimizedContent = `# CLEAR-Optimized Prompt
-
-${clearResult.improvedPrompt}
-
----
-
-## CLEAR Framework Assessment
-
-- **[C] Concise**: ${clearScore.conciseness.toFixed(0)}% - ${clearResult.conciseness.suggestions[0] || 'Good'}
-- **[L] Logical**: ${clearScore.logic.toFixed(0)}% - ${clearResult.logic.suggestions[0] || 'Good'}
-- **[E] Explicit**: ${clearScore.explicitness.toFixed(0)}% - ${clearResult.explicitness.suggestions[0] || 'Good'}
-- **Overall**: ${clearScore.overall.toFixed(0)}% (${clearScore.rating})
-
-## Changes Applied
-
-${clearResult.changesSummary.map((c) => `- **[${c.component}]** ${c.change}`).join('\n')}
-`;
-            await FileSystem.writeFileAtomic(clearOptimizedPath, clearOptimizedContent);
-            console.log(chalk.green('✓ CLEAR-optimized version saved\n'));
+            // Save optimized version
+            const optimizedPath = path.join(outputDir, 'optimized-prompt.md');
+            await FileSystem.writeFileAtomic(optimizedPath, result.enhanced);
         }
-        catch {
-            console.log(chalk.yellow('⚠ Could not apply CLEAR optimization\n'));
+        catch (error) {
+            console.log(chalk.yellow('⚠️  Could not optimize prompt'));
+            console.log(chalk.gray('Using original extracted version...\n'));
+            // Fallback: copy original to optimized
+            const originalPath = path.join(outputDir, 'original-prompt.md');
+            const optimizedPath = path.join(outputDir, 'optimized-prompt.md');
+            await FileSystem.writeFileAtomic(optimizedPath, rawPrompt);
         }
     }
+    sanitizeProjectName(name) {
+        return name
+            .toLowerCase()
+            .replace(/[^a-z0-9-]/g, '-')
+            .replace(/-+/g, '-')
+            .replace(/^-|-$/g, '') || 'unnamed-project';
+    }
 }
 //# sourceMappingURL=summarize.js.map

package/dist/core/intelligence/index.d.ts

@@ -0,0 +1,10 @@
+export { UniversalOptimizer } from './universal-optimizer.js';
+export { IntentDetector } from './intent-detector.js';
+export { PatternLibrary } from './pattern-library.js';
+export { QualityAssessor } from './quality-assessor.js';
+export * from './types.js';
+export { BasePattern } from './patterns/base-pattern.js';
+export { ConcisenessFilter } from './patterns/conciseness-filter.js';
+export { ObjectiveClarifier } from './patterns/objective-clarifier.js';
+export { TechnicalContextEnricher } from './patterns/technical-context-enricher.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/core/intelligence/index.js

@@ -0,0 +1,13 @@
+// Main exports for the universal prompt intelligence system
+export { UniversalOptimizer } from './universal-optimizer.js';
+export { IntentDetector } from './intent-detector.js';
+export { PatternLibrary } from './pattern-library.js';
+export { QualityAssessor } from './quality-assessor.js';
+// Type exports
+export * from './types.js';
+// Pattern exports
+export { BasePattern } from './patterns/base-pattern.js';
+export { ConcisenessFilter } from './patterns/conciseness-filter.js';
+export { ObjectiveClarifier } from './patterns/objective-clarifier.js';
+export { TechnicalContextEnricher } from './patterns/technical-context-enricher.js';
+//# sourceMappingURL=index.js.map

package/dist/core/intelligence/intent-detector.d.ts

@@ -0,0 +1,33 @@
+import { IntentAnalysis } from './types.js';
+/**
+ * Enhanced Intent Detector with weighted scoring and phrase-based detection
+ * Target Accuracy: 95%+
+ */
+export declare class IntentDetector {
+    private readonly STRONG_CODE_KEYWORDS;
+    private readonly STRONG_PLANNING_KEYWORDS;
+    private readonly STRONG_DEBUGGING_KEYWORDS;
+    private readonly STRONG_DOCUMENTATION_KEYWORDS;
+    private readonly STRONG_REFINEMENT_KEYWORDS;
+    private readonly CODE_KEYWORDS;
+    private readonly PLANNING_KEYWORDS;
+    private readonly REFINEMENT_KEYWORDS;
+    private readonly DEBUGGING_KEYWORDS;
+    private readonly DOCUMENTATION_KEYWORDS;
+    private readonly WEAK_CODE_KEYWORDS;
+    private readonly NEGATION_WORDS;
+    analyze(prompt: string): IntentAnalysis;
+    private calculateIntentScore;
+    private getKeywordsForIntent;
+    private applyNegation;
+    private getContextBonus;
+    private selectPrimaryIntent;
+    private calculateConfidence;
+    private hasCodeContext;
+    private hasTechnicalTerms;
+    private hasPerformanceTerms;
+    private isOpenEnded;
+    private needsStructure;
+    private suggestMode;
+}
+//# sourceMappingURL=intent-detector.d.ts.map

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

@@ -0,0 +1,311 @@
+/**
+ * Enhanced Intent Detector with weighted scoring and phrase-based detection
+ * Target Accuracy: 95%+
+ */
+export class IntentDetector {
+    // Strong indicators (20 points)
+    STRONG_CODE_KEYWORDS = [
+        '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'
+    ];
+    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'
+    ];
+    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'
+    ];
+    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'
+    ];
+    // Medium indicators (10 points)
+    CODE_KEYWORDS = [
+        'function', 'class', 'component', 'api', 'endpoint', 'database',
+        'implement', 'build', 'create', 'write', 'code', 'develop'
+    ];
+    PLANNING_KEYWORDS = [
+        'plan', 'design', 'architect', 'strategy', 'approach', 'structure',
+        'organize', 'layout', 'workflow'
+    ];
+    REFINEMENT_KEYWORDS = [
+        'improve', 'optimize', 'refactor', 'enhance', 'better', 'faster',
+        'cleaner', 'simplify', 'reduce', 'increase'
+    ];
+    DEBUGGING_KEYWORDS = [
+        'fix', 'debug', 'error', 'bug', 'issue', 'problem', 'failing',
+        'broken', 'crash', 'exception', 'incorrect', 'wrong'
+    ];
+    DOCUMENTATION_KEYWORDS = [
+        'explain', 'document', 'describe', 'understand',
+        'clarify', 'comment', 'documentation', 'guide', 'tutorial'
+    ];
+    // Weak indicators (5 points)
+    WEAK_CODE_KEYWORDS = [
+        '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'
+    ];
+    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'),
+            'prd-generation': 0 // PRD is explicit command, not inferred
+        };
+        // Apply intent priority rules
+        const primaryIntent = this.selectPrimaryIntent(scores, lowerPrompt);
+        // Calculate confidence
+        const confidence = this.calculateConfidence(scores, primaryIntent);
+        // Analyze characteristics
+        const characteristics = {
+            hasCodeContext: this.hasCodeContext(prompt),
+            hasTechnicalTerms: this.hasTechnicalTerms(lowerPrompt),
+            isOpenEnded: this.isOpenEnded(prompt),
+            needsStructure: this.needsStructure(prompt, primaryIntent)
+        };
+        // Suggest mode
+        const suggestedMode = this.suggestMode(primaryIntent, characteristics, prompt.length, confidence);
+        return {
+            primaryIntent,
+            confidence,
+            characteristics,
+            suggestedMode
+        };
+    }
+    calculateIntentScore(prompt, words, intent) {
+        let score = 0;
+        // Get keywords for this intent
+        const { strong, medium, weak } = this.getKeywordsForIntent(intent);
+        // Check strong indicators (phrases) - 20 points each
+        for (const phrase of strong) {
+            if (prompt.includes(phrase)) {
+                score += this.applyNegation(phrase, prompt, 20);
+            }
+        }
+        // Check medium indicators - 10 points each
+        for (const keyword of medium) {
+            if (words.includes(keyword) || prompt.includes(keyword)) {
+                score += this.applyNegation(keyword, prompt, 10);
+            }
+        }
+        // Check weak indicators - 5 points each
+        for (const keyword of weak) {
+            if (words.includes(keyword)) {
+                score += 5;
+            }
+        }
+        // Context bonus
+        score += this.getContextBonus(prompt, intent);
+        return score;
+    }
+    getKeywordsForIntent(intent) {
+        switch (intent) {
+            case 'code-generation':
+                return {
+                    strong: this.STRONG_CODE_KEYWORDS,
+                    medium: this.CODE_KEYWORDS,
+                    weak: this.WEAK_CODE_KEYWORDS
+                };
+            case 'planning':
+                return {
+                    strong: this.STRONG_PLANNING_KEYWORDS,
+                    medium: this.PLANNING_KEYWORDS,
+                    weak: []
+                };
+            case 'debugging':
+                return {
+                    strong: this.STRONG_DEBUGGING_KEYWORDS,
+                    medium: this.DEBUGGING_KEYWORDS,
+                    weak: []
+                };
+            case 'documentation':
+                return {
+                    strong: this.STRONG_DOCUMENTATION_KEYWORDS,
+                    medium: this.DOCUMENTATION_KEYWORDS,
+                    weak: []
+                };
+            case 'refinement':
+                return {
+                    strong: this.STRONG_REFINEMENT_KEYWORDS,
+                    medium: this.REFINEMENT_KEYWORDS,
+                    weak: []
+                };
+            default:
+                return { strong: [], medium: [], weak: [] };
+        }
+    }
+    applyNegation(keyword, prompt, baseScore) {
+        // Find keyword position
+        const keywordIndex = prompt.indexOf(keyword);
+        if (keywordIndex === -1)
+            return baseScore;
+        // Check 2 words before keyword for negation
+        const before = prompt.substring(Math.max(0, keywordIndex - 20), keywordIndex);
+        for (const negation of this.NEGATION_WORDS) {
+            if (before.includes(negation)) {
+                return Math.round(baseScore * 0.5); // Reduce by 50%
+            }
+        }
+        return baseScore;
+    }
+    getContextBonus(prompt, intent) {
+        let bonus = 0;
+        // Code snippet bonus for debugging/refinement
+        if ((intent === 'debugging' || intent === 'refinement') && this.hasCodeContext(prompt)) {
+            bonus += 15;
+        }
+        // Question mark bonus for planning/documentation
+        if ((intent === 'planning' || intent === 'documentation') && prompt.includes('?')) {
+            bonus += 10;
+        }
+        // Technical terms bonus for code-generation
+        if (intent === 'code-generation' && this.hasTechnicalTerms(prompt)) {
+            bonus += 5;
+        }
+        // Performance terms bonus for refinement
+        if (intent === 'refinement' && this.hasPerformanceTerms(prompt)) {
+            bonus += 10;
+        }
+        return bonus;
+    }
+    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'))) {
+            return 'debugging';
+        }
+        // Priority 2: 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')))) {
+            return 'documentation';
+        }
+        // Priority 3: Planning (if architecture/design question)
+        if (scores.planning >= 20 && (prompt.includes('how should') || prompt.includes('architecture') ||
+            prompt.includes('what is the best'))) {
+            return 'planning';
+        }
+        // Priority 4: Refinement (if improvement requested)
+        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);
+        return primaryIntent;
+    }
+    calculateConfidence(scores, primaryIntent) {
+        const primaryScore = scores[primaryIntent];
+        const totalScore = Object.values(scores).reduce((sum, score) => sum + score, 0);
+        if (totalScore === 0) {
+            return 50; // Low confidence if no keywords matched
+        }
+        // Calculate confidence as percentage of primary vs total
+        let confidence = Math.min(100, Math.round((primaryScore / totalScore) * 100));
+        // Check if secondary intent is close
+        const sortedScores = Object.entries(scores)
+            .filter(([intent]) => intent !== primaryIntent)
+            .sort(([, a], [, b]) => b - a);
+        if (sortedScores.length > 0) {
+            const secondaryScore = sortedScores[0][1];
+            const difference = primaryScore - secondaryScore;
+            // If top 2 are within 15%, reduce confidence
+            if (difference < primaryScore * 0.15) {
+                confidence = Math.max(60, confidence - 15);
+            }
+        }
+        return confidence;
+    }
+    hasCodeContext(prompt) {
+        // Check for code blocks
+        if (prompt.includes('```') || prompt.includes('`')) {
+            return true;
+        }
+        // Check for code patterns
+        const codePatterns = [
+            /function\s+\w+\s*\(/,
+            /class\s+\w+/,
+            /const\s+\w+\s*=/,
+            /let\s+\w+\s*=/,
+            /var\s+\w+\s*=/,
+            /def\s+\w+\s*\(/,
+            /import\s+/,
+            /<\w+>/,
+            /\w+\.\w+\(/
+        ];
+        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'
+        ];
+        return terms.some(term => prompt.includes(term));
+    }
+    hasPerformanceTerms(prompt) {
+        const terms = [
+            'performance', 'speed', 'fast', 'slow', 'optimize', 'latency',
+            'throughput', 'memory', 'cpu', 'load time', 'response time'
+        ];
+        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 hasQuestionMark = prompt.includes('?');
+        const vaguePatterns = ['help me', 'i need', 'not sure', 'maybe', 'somehow'];
+        const hasVague = vaguePatterns.some(pattern => lowerPrompt.includes(pattern));
+        return hasQuestionWord || hasQuestionMark || hasVague;
+    }
+    needsStructure(prompt, intent) {
+        if (intent === 'planning')
+            return true;
+        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;
+        return structureScore < 2;
+    }
+    suggestMode(intent, characteristics, promptLength, confidence) {
+        // Low confidence suggests deep mode
+        if (confidence < 60) {
+            return 'deep';
+        }
+        // Planning always benefits from deep mode
+        if (intent === 'planning') {
+            return 'deep';
+        }
+        // Open-ended without code context suggests deep mode
+        if (characteristics.isOpenEnded && !characteristics.hasCodeContext) {
+            return 'deep';
+        }
+        // Very short prompts needing structure suggest deep mode
+        if (promptLength < 50 && characteristics.needsStructure) {
+            return 'deep';
+        }
+        return 'fast';
+    }
+}
+//# sourceMappingURL=intent-detector.js.map