clavix 3.5.0 → 4.0.0

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2025 Bob5k
+Copyright (c) 2025 Clavix
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -12,10 +12,10 @@
 
 | Version | Highlights | Details |
 | --- | --- | --- |
-| **v3.4.0** (Latest) | Provider categorization fixes | [Changelog](CHANGELOG.md#340---2025-11-24) |
-| **v3.3.1** | JSON5/JSON config bug fix | [Changelog](CHANGELOG.md#331---2025-11-23) |
-| **v3.3.0** | Provider management & interactive config | [Changelog](CHANGELOG.md#330---2025-11-23) |
-| **v3.1.0** | Clavix Intelligence™ brand evolution | [Changelog](CHANGELOG.md#310---2025-11-23) |
+| **v3.6.1** (Latest) | Documentation hierarchy & verbosity reduction | [Changelog](CHANGELOG.md#361---2025-11-24) |
+| **v3.6.0** | Enhanced generic connector instructions | [Changelog](CHANGELOG.md#360---2025-11-24) |
+| **v3.5.0** | "Providers" → "Integrations" terminology | [Changelog](CHANGELOG.md#350---2025-01-24) |
+| **v3.4.0** | Provider categorization fixes | [Changelog](CHANGELOG.md#340---2025-11-24) |
 
 **Requirements:** Node.js ≥ 16.0.0 (ESM support required)
 

package/dist/cli/commands/init.js

@@ -8,6 +8,7 @@ import { AgentsMdGenerator } from '../../core/adapters/agents-md-generator.js';
 import { OctoMdGenerator } from '../../core/adapters/octo-md-generator.js';
 import { WarpMdGenerator } from '../../core/adapters/warp-md-generator.js';
 import { CopilotInstructionsGenerator } from '../../core/adapters/copilot-instructions-generator.js';
+import { InstructionsGenerator } from '../../core/adapters/instructions-generator.js';
 import { FileSystem } from '../../utils/file-system.js';
 import { DEFAULT_CONFIG } from '../../types/config.js';
 import { GeminiAdapter } from '../../core/adapters/gemini-adapter.js';
@@ -216,6 +217,12 @@ export default class Init extends Command {
                     await this.injectDocumentation(adapter);
                 }
             }
+            // Generate .clavix/instructions/ folder for generic integrations
+            if (InstructionsGenerator.needsGeneration(selectedIntegrations)) {
+                console.log(chalk.gray('\n📁 Generating .clavix/instructions/ reference folder...'));
+                await InstructionsGenerator.generate();
+                console.log(chalk.gray('  ✓ Created detailed workflow guides for generic integrations'));
+            }
             // Success message
             console.log(chalk.bold.green('\n✅ Clavix initialized successfully!\n'));
             console.log(chalk.gray('Next steps:'));

package/dist/cli/commands/update.js

@@ -10,9 +10,10 @@ import { AgentManager } from '../../core/agent-manager.js';
 import { AgentsMdGenerator } from '../../core/adapters/agents-md-generator.js';
 import { OctoMdGenerator } from '../../core/adapters/octo-md-generator.js';
 import { WarpMdGenerator } from '../../core/adapters/warp-md-generator.js';
+import { InstructionsGenerator } from '../../core/adapters/instructions-generator.js';
 import { collectLegacyCommandFiles } from '../../utils/legacy-command-cleanup.js';
 const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
+const _dirname = dirname(__filename); // eslint-disable-line @typescript-eslint/no-unused-vars
 export default class Update extends Command {
     static description = 'Update managed blocks and slash commands';
     static examples = [
@@ -31,7 +32,7 @@ export default class Update extends Command {
         }),
         force: Flags.boolean({
             char: 'f',
-            description: 'Force update even if files haven\'t changed',
+            description: "Force update even if files haven't changed",
             default: false,
         }),
     };
@@ -91,6 +92,13 @@ export default class Update extends Command {
                 updatedCount += await this.updateCommands(adapter, flags.force);
             }
         }
+        // Update .clavix/instructions/ folder for generic integrations
+        if (updateDocs && InstructionsGenerator.needsGeneration(integrations)) {
+            this.log(chalk.gray('\n📁 Updating .clavix/instructions/ reference folder...'));
+            await InstructionsGenerator.generate();
+            this.log(chalk.gray('  ✓ Updated detailed workflow guides'));
+            updatedCount++;
+        }
         this.log('');
         if (updatedCount > 0) {
             this.log(chalk.green(`✅ Successfully updated ${updatedCount} file(s)`));
@@ -161,7 +169,7 @@ export default class Update extends Command {
         await adapter.generateCommands(templates);
         this.log(chalk.gray(`  ✓ Generated ${templates.length} command(s)`));
         // Handle legacy commands (cleanup old naming patterns)
-        const commandNames = templates.map(t => t.name);
+        const commandNames = templates.map((t) => t.name);
         const legacyRemoved = await this.handleLegacyCommands(adapter, commandNames, force);
         return removed + templates.length + legacyRemoved;
     }
@@ -231,7 +239,7 @@ clavix deep "Build a user auth system"
 clavix start
 \`\`\`
 
-Learn more: https://github.com/Bob5k/Clavix`;
+Learn more: https://github.com/clavixdev/clavix`;
     }
     getClaudeContent() {
         return `## Clavix Integration

package/dist/core/adapters/instructions-generator.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Generator for .clavix/instructions/ reference folder
+ * Provides detailed workflow guides for generic integrations
+ */
+export declare class InstructionsGenerator {
+    static readonly TARGET_DIR = ".clavix/instructions";
+    /**
+     * Generic integrations that need the instructions folder
+     */
+    static readonly GENERIC_INTEGRATIONS: string[];
+    /**
+     * Generate .clavix/instructions/ folder with all reference files
+     */
+    static generate(): Promise<void>;
+    /**
+     * Copy static instruction files (core/, troubleshooting/, README.md)
+     * Excludes workflows/ directory - that comes from canonical templates
+     */
+    private static copyStaticInstructions;
+    /**
+     * Copy ALL canonical templates to .clavix/instructions/workflows/
+     * This ensures generic integrations have access to complete workflow set
+     */
+    private static copyCanonicalWorkflows;
+    /**
+     * Recursively copy directory contents
+     */
+    private static copyDirectory;
+    /**
+     * Check if instructions folder exists
+     */
+    static exists(): Promise<boolean>;
+    /**
+     * Check if any generic integration is selected
+     */
+    static needsGeneration(selectedIntegrations: string[]): boolean;
+    /**
+     * Remove instructions folder
+     */
+    static remove(): Promise<void>;
+}
+//# sourceMappingURL=instructions-generator.d.ts.map

package/dist/core/adapters/instructions-generator.js

@@ -0,0 +1,123 @@
+import { FileSystem } from '../../utils/file-system.js';
+import * as path from 'path';
+import { fileURLToPath } from 'url';
+import { dirname } from 'path';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+/**
+ * Generator for .clavix/instructions/ reference folder
+ * Provides detailed workflow guides for generic integrations
+ */
+export class InstructionsGenerator {
+    static TARGET_DIR = '.clavix/instructions';
+    /**
+     * Generic integrations that need the instructions folder
+     */
+    static GENERIC_INTEGRATIONS = [
+        'octo-md',
+        'warp-md',
+        'agents-md',
+        'copilot-instructions'
+    ];
+    /**
+     * Generate .clavix/instructions/ folder with all reference files
+     */
+    static async generate() {
+        const staticInstructionsPath = path.join(__dirname, '../../templates/instructions');
+        // Check if static template exists
+        if (!(await FileSystem.exists(staticInstructionsPath))) {
+            throw new Error(`.clavix/instructions static files not found at ${staticInstructionsPath}`);
+        }
+        // Create target directory
+        await FileSystem.ensureDir(this.TARGET_DIR);
+        // Step 1: Copy static instruction files (core/, troubleshooting/, README.md)
+        // Note: This skips workflows/ directory if it exists
+        await this.copyStaticInstructions(staticInstructionsPath, this.TARGET_DIR);
+        // Step 2: Copy ALL canonical workflows → .clavix/instructions/workflows/
+        await this.copyCanonicalWorkflows();
+    }
+    /**
+     * Copy static instruction files (core/, troubleshooting/, README.md)
+     * Excludes workflows/ directory - that comes from canonical templates
+     */
+    static async copyStaticInstructions(src, dest) {
+        const entries = await FileSystem.readdir(src, { withFileTypes: true });
+        for (const entry of entries) {
+            // Skip workflows/ directory - it will be populated from canonical
+            if (entry.isDirectory() && entry.name === 'workflows') {
+                continue;
+            }
+            const srcPath = path.join(src, entry.name);
+            const destPath = path.join(dest, entry.name);
+            if (entry.isDirectory()) {
+                await FileSystem.ensureDir(destPath);
+                await this.copyDirectory(srcPath, destPath);
+            }
+            else {
+                const content = await FileSystem.readFile(srcPath);
+                await FileSystem.writeFileAtomic(destPath, content);
+            }
+        }
+    }
+    /**
+     * Copy ALL canonical templates to .clavix/instructions/workflows/
+     * This ensures generic integrations have access to complete workflow set
+     */
+    static async copyCanonicalWorkflows() {
+        const canonicalPath = path.join(__dirname, '../../templates/slash-commands/_canonical');
+        const workflowsTarget = path.join(this.TARGET_DIR, 'workflows');
+        if (!(await FileSystem.exists(canonicalPath))) {
+            throw new Error(`Canonical templates not found at ${canonicalPath}`);
+        }
+        // Create workflows directory
+        await FileSystem.ensureDir(workflowsTarget);
+        // Copy all .md files from canonical
+        const entries = await FileSystem.readdir(canonicalPath, { withFileTypes: true });
+        const mdFiles = entries.filter(f => f.isFile() && f.name.endsWith('.md'));
+        for (const file of mdFiles) {
+            const srcPath = path.join(canonicalPath, file.name);
+            const destPath = path.join(workflowsTarget, file.name);
+            const content = await FileSystem.readFile(srcPath);
+            await FileSystem.writeFileAtomic(destPath, content);
+        }
+    }
+    /**
+     * Recursively copy directory contents
+     */
+    static async copyDirectory(src, dest) {
+        const entries = await FileSystem.readdir(src, { withFileTypes: true });
+        for (const entry of entries) {
+            const srcPath = path.join(src, entry.name);
+            const destPath = path.join(dest, entry.name);
+            if (entry.isDirectory()) {
+                await FileSystem.ensureDir(destPath);
+                await this.copyDirectory(srcPath, destPath);
+            }
+            else {
+                const content = await FileSystem.readFile(srcPath);
+                await FileSystem.writeFileAtomic(destPath, content);
+            }
+        }
+    }
+    /**
+     * Check if instructions folder exists
+     */
+    static async exists() {
+        return await FileSystem.exists(this.TARGET_DIR);
+    }
+    /**
+     * Check if any generic integration is selected
+     */
+    static needsGeneration(selectedIntegrations) {
+        return selectedIntegrations.some(integration => this.GENERIC_INTEGRATIONS.includes(integration));
+    }
+    /**
+     * Remove instructions folder
+     */
+    static async remove() {
+        if (await this.exists()) {
+            await FileSystem.remove(this.TARGET_DIR);
+        }
+    }
+}
+//# sourceMappingURL=instructions-generator.js.map

package/dist/core/git-manager.js

@@ -111,7 +111,8 @@ export class GitManager {
         const errors = [];
         try {
             // Read tasks.md file
-            const fs = await import('fs-extra');
+            const fsExtra = await import('fs-extra');
+            const fs = fsExtra.default || fsExtra;
             if (!(await fs.pathExists(tasksPath))) {
                 errors.push(`Tasks file not found: ${tasksPath}`);
                 return { valid: false, errors };

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

@@ -1,4 +1,4 @@
-import { IntentAnalysis } from './types.js';
+import { IntentAnalysis, EnhancedIntentAnalysis } from './types.js';
 /**
  * Enhanced Intent Detector with weighted scoring and phrase-based detection
  * Target Accuracy: 95%+
@@ -9,11 +9,19 @@ export declare class IntentDetector {
     private readonly STRONG_DEBUGGING_KEYWORDS;
     private readonly STRONG_DOCUMENTATION_KEYWORDS;
     private readonly STRONG_REFINEMENT_KEYWORDS;
+    private readonly STRONG_TESTING_KEYWORDS;
+    private readonly STRONG_MIGRATION_KEYWORDS;
+    private readonly STRONG_SECURITY_KEYWORDS;
+    private readonly STRONG_LEARNING_KEYWORDS;
     private readonly CODE_KEYWORDS;
     private readonly PLANNING_KEYWORDS;
     private readonly REFINEMENT_KEYWORDS;
     private readonly DEBUGGING_KEYWORDS;
     private readonly DOCUMENTATION_KEYWORDS;
+    private readonly TESTING_KEYWORDS;
+    private readonly MIGRATION_KEYWORDS;
+    private readonly SECURITY_KEYWORDS;
+    private readonly LEARNING_KEYWORDS;
     private readonly WEAK_CODE_KEYWORDS;
     private readonly NEGATION_WORDS;
     analyze(prompt: string): IntentAnalysis;
@@ -21,6 +29,9 @@ export declare class IntentDetector {
     private getKeywordsForIntent;
     private applyNegation;
     private getContextBonus;
+    private hasTestingFrameworkTerms;
+    private hasSecurityTerms;
+    private hasMigrationPatterns;
     private selectPrimaryIntent;
     private calculateConfidence;
     private hasCodeContext;
@@ -29,5 +40,11 @@ export declare class IntentDetector {
     private isOpenEnded;
     private needsStructure;
     private suggestMode;
+    /**
+     * v4.0: Enhanced analysis with secondary intents and ambiguity detection
+     */
+    analyzeEnhanced(prompt: string): EnhancedIntentAnalysis;
+    private getSecondaryIntents;
+    private calculateAmbiguity;
 }
 //# sourceMappingURL=intent-detector.d.ts.map

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

@@ -11,7 +11,10 @@ export class IntentDetector {
     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'
+        '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'
     ];
     STRONG_DEBUGGING_KEYWORDS = [
         'fix error', 'debug issue', 'doesn\'t work', 'throws error', 'not working',
@@ -29,6 +32,30 @@ export class IntentDetector {
         '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'
+    ];
+    // 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'
+    ];
+    // 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'
+    ];
+    // 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'
+    ];
     // Medium indicators (10 points)
     CODE_KEYWORDS = [
         'function', 'class', 'component', 'api', 'endpoint', 'database',
@@ -36,7 +63,9 @@ export class IntentDetector {
     ];
     PLANNING_KEYWORDS = [
         'plan', 'design', 'architect', 'strategy', 'approach', 'structure',
-        'organize', 'layout', 'workflow'
+        'organize', 'layout', 'workflow',
+        // v4.0: Spec-driven development keywords
+        'spec', 'specification', 'requirements', 'blueprint', 'outline'
     ];
     REFINEMENT_KEYWORDS = [
         'improve', 'optimize', 'refactor', 'enhance', 'better', 'faster',
@@ -50,6 +79,23 @@ export class IntentDetector {
         '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'
+    ];
+    MIGRATION_KEYWORDS = [
+        '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'
+    ];
+    LEARNING_KEYWORDS = [
+        'understand', 'learn', 'concept', 'basics', 'fundamentals', 'tutorial',
+        'introduction', 'beginner', 'overview', 'theory', 'principle'
+    ];
     // Weak indicators (5 points)
     WEAK_CODE_KEYWORDS = [
         'react', 'vue', 'angular', 'python', 'javascript', 'typescript',
@@ -69,7 +115,12 @@ export class IntentDetector {
             '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
+            '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'),
+            'security-review': this.calculateIntentScore(lowerPrompt, words, 'security-review'),
+            'learning': this.calculateIntentScore(lowerPrompt, words, 'learning')
         };
         // Apply intent priority rules
         const primaryIntent = this.selectPrimaryIntent(scores, lowerPrompt);
@@ -149,6 +200,31 @@ export class IntentDetector {
                     medium: this.REFINEMENT_KEYWORDS,
                     weak: []
                 };
+            // v4.0: New intents
+            case 'testing':
+                return {
+                    strong: this.STRONG_TESTING_KEYWORDS,
+                    medium: this.TESTING_KEYWORDS,
+                    weak: []
+                };
+            case 'migration':
+                return {
+                    strong: this.STRONG_MIGRATION_KEYWORDS,
+                    medium: this.MIGRATION_KEYWORDS,
+                    weak: []
+                };
+            case 'security-review':
+                return {
+                    strong: this.STRONG_SECURITY_KEYWORDS,
+                    medium: this.SECURITY_KEYWORDS,
+                    weak: []
+                };
+            case 'learning':
+                return {
+                    strong: this.STRONG_LEARNING_KEYWORDS,
+                    medium: this.LEARNING_KEYWORDS,
+                    weak: []
+                };
             default:
                 return { strong: [], medium: [], weak: [] };
         }
@@ -169,12 +245,12 @@ export class IntentDetector {
     }
     getContextBonus(prompt, intent) {
         let bonus = 0;
-        // Code snippet bonus for debugging/refinement
-        if ((intent === 'debugging' || intent === 'refinement') && this.hasCodeContext(prompt)) {
+        // Code snippet bonus for debugging/refinement/testing
+        if ((intent === 'debugging' || intent === 'refinement' || intent === 'testing') && this.hasCodeContext(prompt)) {
             bonus += 15;
         }
-        // Question mark bonus for planning/documentation
-        if ((intent === 'planning' || intent === 'documentation') && prompt.includes('?')) {
+        // Question mark bonus for planning/documentation/learning
+        if ((intent === 'planning' || intent === 'documentation' || intent === 'learning') && prompt.includes('?')) {
             bonus += 10;
         }
         // Technical terms bonus for code-generation
@@ -185,25 +261,74 @@ export class IntentDetector {
         if (intent === 'refinement' && this.hasPerformanceTerms(prompt)) {
             bonus += 10;
         }
+        // v4.0: Context bonuses for new intents
+        // Testing framework mentions bonus
+        if (intent === 'testing' && this.hasTestingFrameworkTerms(prompt)) {
+            bonus += 10;
+        }
+        // Security terms bonus for security-review
+        if (intent === 'security-review' && this.hasSecurityTerms(prompt)) {
+            bonus += 15;
+        }
+        // Migration version patterns bonus
+        if (intent === 'migration' && this.hasMigrationPatterns(prompt)) {
+            bonus += 15;
+        }
         return bonus;
     }
+    // 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));
+    }
+    hasSecurityTerms(prompt) {
+        const terms = ['owasp', 'cve', 'vulnerability', 'exploit', 'injection', 'xss', 'csrf'];
+        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"
+        const versionPattern = /\d+\.?\d*\s*(to|->|=>)\s*\d+\.?\d*/i;
+        const versionWords = /from\s+version|to\s+version|upgrade.*\d/i;
+        return versionPattern.test(prompt) || versionWords.test(prompt);
+    }
     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)
+        // 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'))) {
+            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'))) {
+            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))) {
+            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')))) {
             return 'documentation';
         }
-        // Priority 3: Planning (if architecture/design question)
+        // Priority 6: Learning (if conceptual understanding requested)
+        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('what is the best') || prompt.includes('specification') ||
+            (prompt.includes('spec') && !prompt.includes('test')))) {
             return 'planning';
         }
-        // Priority 4: Refinement (if improvement requested)
+        // 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'))) {
             return 'refinement';
@@ -307,5 +432,65 @@ export class IntentDetector {
         }
         return 'fast';
     }
+    /**
+     * v4.0: Enhanced analysis with secondary intents and ambiguity detection
+     */
+    analyzeEnhanced(prompt) {
+        const basicAnalysis = this.analyze(prompt);
+        const lowerPrompt = prompt.toLowerCase();
+        const words = lowerPrompt.split(/\s+/);
+        // 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'),
+            'prd-generation': 0,
+            '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')
+        };
+        // Get secondary intents (top 2-3 after primary, with score > 10)
+        const secondaryIntents = this.getSecondaryIntents(scores, basicAnalysis.primaryIntent);
+        // Calculate intent ambiguity
+        const intentAmbiguity = this.calculateAmbiguity(scores, basicAnalysis.primaryIntent);
+        return {
+            ...basicAnalysis,
+            secondaryIntents,
+            intentAmbiguity
+        };
+    }
+    getSecondaryIntents(scores, primaryIntent) {
+        const primaryScore = scores[primaryIntent];
+        const totalScore = Object.values(scores).reduce((sum, s) => sum + s, 0);
+        if (totalScore === 0)
+            return [];
+        return Object.entries(scores)
+            .filter(([intent, score]) => intent !== primaryIntent && score > 10)
+            .sort(([, a], [, b]) => b - a)
+            .slice(0, 2)
+            .map(([intent, score]) => ({
+            intent: intent,
+            confidence: Math.round((score / totalScore) * 100)
+        }));
+    }
+    calculateAmbiguity(scores, primaryIntent) {
+        const sortedScores = Object.entries(scores)
+            .sort(([, a], [, b]) => b - a);
+        if (sortedScores.length < 2)
+            return 'low';
+        const primaryScore = sortedScores[0][1];
+        const secondaryScore = sortedScores[1][1];
+        if (primaryScore === 0)
+            return 'high';
+        const ratio = secondaryScore / primaryScore;
+        if (ratio > 0.8)
+            return 'high'; // Secondary is 80%+ of primary
+        if (ratio > 0.5)
+            return 'medium'; // Secondary is 50-80% of primary
+        return 'low'; // Clear primary intent
+    }
 }
 //# sourceMappingURL=intent-detector.js.map

package/dist/core/intelligence/pattern-library.js

@@ -4,6 +4,16 @@ import { TechnicalContextEnricher } from './patterns/technical-context-enricher.
 import { StructureOrganizer } from './patterns/structure-organizer.js';
 import { CompletenessValidator } from './patterns/completeness-validator.js';
 import { ActionabilityEnhancer } from './patterns/actionability-enhancer.js';
+// v4.0 Deep mode patterns
+import { AlternativePhrasingGenerator } from './patterns/alternative-phrasing-generator.js';
+import { EdgeCaseIdentifier } from './patterns/edge-case-identifier.js';
+import { ValidationChecklistCreator } from './patterns/validation-checklist-creator.js';
+import { AssumptionExplicitizer } from './patterns/assumption-explicitizer.js';
+import { ScopeDefiner } from './patterns/scope-definer.js';
+import { PRDStructureEnforcer } from './patterns/prd-structure-enforcer.js';
+// v4.0 Both mode patterns
+import { StepDecomposer } from './patterns/step-decomposer.js';
+import { ContextPrecisionBooster } from './patterns/context-precision.js';
 export class PatternLibrary {
     patterns = new Map();
     constructor() {
@@ -17,18 +27,16 @@ export class PatternLibrary {
         this.register(new StructureOrganizer()); // HIGH - Reorder logically
         this.register(new CompletenessValidator()); // MEDIUM - Check missing elements
         this.register(new ActionabilityEnhancer()); // HIGH - Vague to specific
-        // TODO: Register additional patterns for deep mode (future enhancement)
-        // Deep mode exclusive:
-        // - AlternativePhrasingGenerator
-        // - StructureVariationGenerator
-        // - EdgeCaseIdentifier
-        // - ValidationChecklistCreator
-        // - AssumptionExplicitizer
-        // - ScopeDefiner
-        // - StepByStepDecomposer
-        // - TemplatePatternApplier
-        // - ReflectionPrompter
-        // - ContextPrecisionBooster
+        // v4.0 Deep mode patterns
+        this.register(new AlternativePhrasingGenerator()); // P5 - Generate alternative structures
+        this.register(new EdgeCaseIdentifier()); // P4 - Identify edge cases by domain
+        this.register(new ValidationChecklistCreator()); // P3 - Create validation checklists
+        this.register(new AssumptionExplicitizer()); // P6 - Make implicit assumptions explicit
+        this.register(new ScopeDefiner()); // P5 - Add scope boundaries
+        this.register(new PRDStructureEnforcer()); // P9 - Ensure PRD completeness
+        // v4.0 Both mode patterns (fast & deep)
+        this.register(new StepDecomposer()); // P7 - Break complex prompts into steps
+        this.register(new ContextPrecisionBooster()); // P8 - Add precise context when missing
     }
     /**
      * Register a new pattern