clavix 4.4.0 → 4.6.0

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

@@ -33,25 +33,32 @@ import { ImplicitRequirementExtractor } from './patterns/implicit-requirement-ex
 export class PatternLibrary {
     patterns = new Map();
     config = null;
+    priorityOverrides = new Map();
     constructor() {
         this.registerDefaultPatterns();
     }
     /**
-     * v4.4: Apply configuration settings to pattern library
-     * Allows enabling/disabling patterns and adjusting priorities via config
+     * v4.5: Apply configuration settings to pattern library
+     * Allows enabling/disabling patterns and adjusting priorities via config.
+     * Priority overrides are stored separately (pattern.priority is readonly).
      */
     applyConfig(config) {
         this.config = config;
-        // Apply priority overrides
+        // Store priority overrides (patterns have readonly priority)
         if (config.patterns?.priorityOverrides) {
             for (const [patternId, newPriority] of Object.entries(config.patterns.priorityOverrides)) {
-                const pattern = this.patterns.get(patternId);
-                if (pattern && newPriority >= 1 && newPriority <= 10) {
-                    pattern.priority = newPriority;
+                if (this.patterns.has(patternId) && newPriority >= 1 && newPriority <= 10) {
+                    this.priorityOverrides.set(patternId, newPriority);
                 }
             }
         }
     }
+    /**
+     * v4.5: Get effective priority for a pattern (considers overrides)
+     */
+    getEffectivePriority(pattern) {
+        return this.priorityOverrides.get(pattern.id) ?? pattern.priority;
+    }
     /**
      * v4.4: Check if a pattern is disabled via config
      */
@@ -100,9 +107,12 @@ export class PatternLibrary {
         this.register(new ImplicitRequirementExtractor()); // P7 - Surface implicit requirements
     }
     /**
-     * Register a new pattern
+     * Register a new pattern.
+     * v4.5: Injects library reference for config access.
      */
     register(pattern) {
+        // Inject library reference for config access
+        pattern.setPatternLibrary(this);
         this.patterns.set(pattern.id, pattern);
     }
     /**
@@ -150,11 +160,81 @@ export class PatternLibrary {
             }
             applicablePatterns.push(pattern);
         }
-        // Sort by priority (highest first)
-        return applicablePatterns.sort((a, b) => b.priority - a.priority);
+        // v4.5: Sort by priority and respect dependencies
+        return this.sortPatternsWithDependencies(applicablePatterns);
+    }
+    /**
+     * v4.5: Sort patterns by priority while respecting dependency constraints.
+     * Handles runAfter (must run after specified patterns) and excludesWith (mutually exclusive).
+     */
+    sortPatternsWithDependencies(patterns) {
+        // First, handle exclusions - remove patterns that conflict with higher priority ones
+        const filteredPatterns = this.filterExcludedPatterns(patterns);
+        // Sort by priority first
+        const sortedByPriority = [...filteredPatterns].sort((a, b) => this.getEffectivePriority(b) - this.getEffectivePriority(a));
+        // Then adjust for runAfter dependencies
+        return this.adjustForDependencies(sortedByPriority);
+    }
+    /**
+     * v4.5: Filter out patterns that are mutually exclusive with higher priority patterns.
+     */
+    filterExcludedPatterns(patterns) {
+        // Sort by priority (highest first) to determine which exclusion wins
+        const sortedByPriority = [...patterns].sort((a, b) => this.getEffectivePriority(b) - this.getEffectivePriority(a));
+        const excludedIds = new Set();
+        for (const pattern of sortedByPriority) {
+            // Skip if this pattern was already excluded
+            if (excludedIds.has(pattern.id)) {
+                continue;
+            }
+            // Check if this pattern excludes others
+            const excludes = pattern.dependencies?.excludesWith || [];
+            for (const excludedId of excludes) {
+                excludedIds.add(excludedId);
+            }
+        }
+        // Return patterns that weren't excluded
+        return sortedByPriority.filter((p) => !excludedIds.has(p.id));
+    }
+    /**
+     * v4.5: Adjust pattern order to respect runAfter dependencies.
+     * If pattern A declares runAfter: ['B'], ensure B runs before A.
+     */
+    adjustForDependencies(patterns) {
+        const patternMap = new Map(patterns.map((p) => [p.id, p]));
+        const result = [];
+        const processed = new Set();
+        const processing = new Set();
+        // Depth-first processing to handle dependencies
+        const processPattern = (pattern) => {
+            if (processed.has(pattern.id)) {
+                return; // Already processed
+            }
+            if (processing.has(pattern.id)) {
+                // Circular dependency detected - skip to avoid infinite loop
+                return;
+            }
+            processing.add(pattern.id);
+            // Process dependencies first (patterns that must run before this one)
+            const runAfter = pattern.dependencies?.runAfter || [];
+            for (const depId of runAfter) {
+                const depPattern = patternMap.get(depId);
+                if (depPattern && !processed.has(depId)) {
+                    processPattern(depPattern);
+                }
+            }
+            processing.delete(pattern.id);
+            processed.add(pattern.id);
+            result.push(pattern);
+        };
+        // Process all patterns in priority order
+        for (const pattern of patterns) {
+            processPattern(pattern);
+        }
+        return result;
     }
     /**
-     * v4.3.2: Select patterns for specific mode with phase-awareness
+     * v4.5: Select patterns for specific mode with phase-awareness
      * Maps PRD and conversational modes to appropriate base modes and patterns
      */
     selectPatternsForMode(mode, intent, phase) {
@@ -174,22 +254,39 @@ export class PatternLibrary {
             if (!pattern.applicableIntents.includes(intent.primaryIntent)) {
                 continue;
             }
-            // Phase-specific filtering for PRD mode
-            if (mode === 'prd' && phase) {
-                if (!this.isPatternApplicableForPRDPhase(pattern, phase)) {
-                    continue;
-                }
-            }
-            // Phase-specific filtering for conversational mode
-            if (mode === 'conversational' && phase) {
-                if (!this.isPatternApplicableForConversationalPhase(pattern, phase)) {
-                    continue;
-                }
+            // v4.5: Phase-specific filtering using pattern's phases property
+            if (phase && !this.isPatternApplicableForPhase(pattern, phase)) {
+                continue;
             }
             applicablePatterns.push(pattern);
         }
-        // Sort by priority (highest first)
-        return applicablePatterns.sort((a, b) => b.priority - a.priority);
+        // v4.5: Sort by priority and respect dependencies
+        return this.sortPatternsWithDependencies(applicablePatterns);
+    }
+    /**
+     * v4.5: Check if pattern is applicable for a given phase.
+     * Uses pattern's declared phases property instead of hardcoded mappings.
+     */
+    isPatternApplicableForPhase(pattern, phase) {
+        // Map OptimizationPhase to PatternPhase
+        const patternPhase = this.mapOptimizationPhaseToPatternPhase(phase);
+        if (!patternPhase) {
+            return true; // Unknown phase, allow pattern
+        }
+        // Check if pattern applies to this phase or to 'all' phases
+        return pattern.phases.includes('all') || pattern.phases.includes(patternPhase);
+    }
+    /**
+     * v4.5: Map OptimizationPhase string to PatternPhase type
+     */
+    mapOptimizationPhaseToPatternPhase(phase) {
+        const mapping = {
+            'question-validation': 'question-validation',
+            'output-generation': 'output-generation',
+            'conversation-tracking': 'conversation-tracking',
+            summarization: 'summarization',
+        };
+        return mapping[phase] || null;
     }
     /**
      * Map extended modes to base modes for pattern compatibility
@@ -208,68 +305,6 @@ export class PatternLibrary {
                 return mode;
         }
     }
-    /**
-     * Check if pattern is applicable for PRD phase
-     */
-    isPatternApplicableForPRDPhase(pattern, phase) {
-        // Patterns for question validation (lightweight, clarity-focused)
-        const questionValidationPatterns = [
-            'ambiguity-detector',
-            'completeness-validator',
-            'objective-clarifier',
-        ];
-        // Patterns for output generation (comprehensive)
-        const outputGenerationPatterns = [
-            'prd-structure-enforcer',
-            'structure-organizer',
-            'success-criteria-enforcer',
-            'scope-definer',
-            'edge-case-identifier',
-            'assumption-explicitizer',
-            'technical-context-enricher',
-            'domain-context-enricher',
-            // v4.3.2 PRD patterns will be added here
-            'requirement-prioritizer',
-            'user-persona-enricher',
-            'success-metrics-enforcer',
-            'dependency-identifier',
-        ];
-        if (phase === 'question-validation') {
-            return questionValidationPatterns.includes(pattern.id);
-        }
-        if (phase === 'output-generation') {
-            return outputGenerationPatterns.includes(pattern.id);
-        }
-        return true; // Default: allow pattern
-    }
-    /**
-     * Check if pattern is applicable for conversational phase
-     */
-    isPatternApplicableForConversationalPhase(pattern, phase) {
-        // Patterns for conversation tracking (minimal, non-intrusive)
-        const conversationTrackingPatterns = ['ambiguity-detector', 'completeness-validator'];
-        // Patterns for summarization (comprehensive extraction)
-        const summarizationPatterns = [
-            'structure-organizer',
-            'completeness-validator',
-            'success-criteria-enforcer',
-            'edge-case-identifier',
-            'actionability-enhancer',
-            'technical-context-enricher',
-            'domain-context-enricher',
-            // v4.3.2 Conversational patterns will be added here
-            'conversation-summarizer',
-            'topic-coherence-analyzer',
-            'implicit-requirement-extractor',
-        ];
-        if (phase === 'conversation-tracking') {
-            return conversationTrackingPatterns.includes(pattern.id);
-        }
-        if (phase === 'summarization') {
-            return summarizationPatterns.includes(pattern.id);
-        }
-        return true; // Default: allow pattern
-    }
     /**
      * Get all registered patterns
      */

package/dist/core/intelligence/patterns/actionability-enhancer.d.ts

@@ -1,20 +1,20 @@
-import { BasePattern } from './base-pattern.js';
+import { BasePattern, PatternMode, PatternPriority, PatternPhase, PatternConfigSchema } from './base-pattern.js';
 import { PatternContext, PatternResult, PromptIntent } from '../types.js';
 /**
- * Actionability Enhancer Pattern
+ * v4.5 Pattern: Actionability Enhancer
  *
  * Converts vague goals into specific, actionable tasks.
  * Replaces abstract language with concrete requirements.
- *
- * Priority: HIGH (7)
  */
 export declare class ActionabilityEnhancer extends BasePattern {
-    id: string;
-    name: string;
-    description: string;
-    applicableIntents: PromptIntent[];
-    mode: 'fast' | 'deep' | 'both';
-    priority: number;
+    readonly id = "actionability-enhancer";
+    readonly name = "Actionability Enhancer";
+    readonly description = "Converts vague goals into specific, actionable tasks";
+    readonly applicableIntents: PromptIntent[];
+    readonly mode: PatternMode;
+    readonly priority: PatternPriority;
+    readonly phases: PatternPhase[];
+    static readonly configSchema: PatternConfigSchema;
     private readonly VAGUE_WORDS;
     apply(prompt: string, _context: PatternContext): PatternResult;
     private detectVagueWords;

package/dist/core/intelligence/patterns/actionability-enhancer.js

@@ -1,19 +1,44 @@
-import { BasePattern } from './base-pattern.js';
+import { BasePattern, } from './base-pattern.js';
 /**
- * Actionability Enhancer Pattern
+ * v4.5 Pattern: Actionability Enhancer
  *
  * Converts vague goals into specific, actionable tasks.
  * Replaces abstract language with concrete requirements.
- *
- * Priority: HIGH (7)
  */
 export class ActionabilityEnhancer extends BasePattern {
+    // -------------------------------------------------------------------------
+    // Pattern Metadata (v4.5 unified types)
+    // -------------------------------------------------------------------------
     id = 'actionability-enhancer';
     name = 'Actionability Enhancer';
     description = 'Converts vague goals into specific, actionable tasks';
-    applicableIntents = ['code-generation', 'planning', 'refinement', 'debugging'];
+    applicableIntents = [
+        'code-generation',
+        'planning',
+        'refinement',
+        'debugging',
+    ];
     mode = 'both';
-    priority = 7; // High priority
+    priority = 4; // LOW - polish phase
+    phases = ['all'];
+    // -------------------------------------------------------------------------
+    // Configuration Schema (v4.5)
+    // -------------------------------------------------------------------------
+    static configSchema = {
+        replaceVagueWords: {
+            type: 'boolean',
+            default: true,
+            description: 'Replace vague words with specific alternatives',
+        },
+        addMeasurableCriteria: {
+            type: 'boolean',
+            default: true,
+            description: 'Add suggestions for measurable criteria',
+        },
+    };
+    // -------------------------------------------------------------------------
+    // Pattern Data
+    // -------------------------------------------------------------------------
     VAGUE_WORDS = {
         better: ['faster', 'more efficient', 'more reliable', 'more maintainable'],
         improve: [

package/dist/core/intelligence/patterns/alternative-phrasing-generator.d.ts

@@ -1,18 +1,20 @@
-import { BasePattern } from './base-pattern.js';
+import { BasePattern, PatternMode, PatternPriority, PatternPhase, PatternConfigSchema } from './base-pattern.js';
 import { PromptIntent, PatternContext, PatternResult } from '../types.js';
 /**
- * v4.0 Deep Mode Pattern: Alternative Phrasing Generator
+ * v4.5 Pattern: Alternative Phrasing Generator
  *
  * Generates 2-3 alternative prompt structures to give users options
  * for different approaches to the same request.
  */
 export declare class AlternativePhrasingGenerator extends BasePattern {
-    id: string;
-    name: string;
-    description: string;
-    applicableIntents: PromptIntent[];
-    mode: "deep";
-    priority: number;
+    readonly id = "alternative-phrasing-generator";
+    readonly name = "Alternative Phrasing Generator";
+    readonly description = "Generate alternative prompt structures for different approaches";
+    readonly applicableIntents: PromptIntent[];
+    readonly mode: PatternMode;
+    readonly priority: PatternPriority;
+    readonly phases: PatternPhase[];
+    static readonly configSchema: PatternConfigSchema;
     apply(prompt: string, context: PatternContext): PatternResult;
     private generateAlternatives;
     private generateCodeAlternatives;

package/dist/core/intelligence/patterns/alternative-phrasing-generator.js

@@ -1,11 +1,14 @@
-import { BasePattern } from './base-pattern.js';
+import { BasePattern, } from './base-pattern.js';
 /**
- * v4.0 Deep Mode Pattern: Alternative Phrasing Generator
+ * v4.5 Pattern: Alternative Phrasing Generator
  *
  * Generates 2-3 alternative prompt structures to give users options
  * for different approaches to the same request.
  */
 export class AlternativePhrasingGenerator extends BasePattern {
+    // -------------------------------------------------------------------------
+    // Pattern Metadata (v4.5 unified types)
+    // -------------------------------------------------------------------------
     id = 'alternative-phrasing-generator';
     name = 'Alternative Phrasing Generator';
     description = 'Generate alternative prompt structures for different approaches';
@@ -19,7 +22,22 @@ export class AlternativePhrasingGenerator extends BasePattern {
         'documentation',
     ];
     mode = 'deep';
-    priority = 5;
+    priority = 3; // VERY LOW - final touches
+    phases = ['all'];
+    // -------------------------------------------------------------------------
+    // Configuration Schema (v4.5)
+    // -------------------------------------------------------------------------
+    static configSchema = {
+        maxAlternatives: {
+            type: 'number',
+            default: 3,
+            description: 'Maximum number of alternative approaches to generate',
+            validation: { min: 1, max: 5 },
+        },
+    };
+    // -------------------------------------------------------------------------
+    // Pattern Application
+    // -------------------------------------------------------------------------
     apply(prompt, context) {
         const alternatives = this.generateAlternatives(prompt, context.intent.primaryIntent);
         if (alternatives.length === 0) {

package/dist/core/intelligence/patterns/ambiguity-detector.d.ts

@@ -1,18 +1,20 @@
-import { BasePattern } from './base-pattern.js';
+import { BasePattern, PatternMode, PatternPriority, PatternPhase, PatternConfigSchema } from './base-pattern.js';
 import { PatternContext, PatternResult, PromptIntent } from '../types.js';
 /**
- * AmbiguityDetector Pattern (v4.1)
+ * v4.5 Pattern: Ambiguity Detector
  *
  * Identifies and clarifies ambiguous terms, vague references, and unclear
  * specifications in prompts. Helps agents understand exactly what's needed.
  */
 export declare class AmbiguityDetector extends BasePattern {
-    id: string;
-    name: string;
-    description: string;
-    applicableIntents: PromptIntent[];
-    mode: 'fast' | 'deep' | 'both';
-    priority: number;
+    readonly id = "ambiguity-detector";
+    readonly name = "Ambiguity Detector";
+    readonly description = "Identifies and clarifies ambiguous terms and vague references";
+    readonly applicableIntents: PromptIntent[];
+    readonly mode: PatternMode;
+    readonly priority: PatternPriority;
+    readonly phases: PatternPhase[];
+    static readonly configSchema: PatternConfigSchema;
     private ambiguousTerms;
     private vaguePatterns;
     apply(prompt: string, _context: PatternContext): PatternResult;

package/dist/core/intelligence/patterns/ambiguity-detector.js

@@ -1,11 +1,14 @@
-import { BasePattern } from './base-pattern.js';
+import { BasePattern, } from './base-pattern.js';
 /**
- * AmbiguityDetector Pattern (v4.1)
+ * v4.5 Pattern: Ambiguity Detector
  *
  * Identifies and clarifies ambiguous terms, vague references, and unclear
  * specifications in prompts. Helps agents understand exactly what's needed.
  */
 export class AmbiguityDetector extends BasePattern {
+    // -------------------------------------------------------------------------
+    // Pattern Metadata (v4.5 unified types)
+    // -------------------------------------------------------------------------
     id = 'ambiguity-detector';
     name = 'Ambiguity Detector';
     description = 'Identifies and clarifies ambiguous terms and vague references';
@@ -20,7 +23,32 @@ export class AmbiguityDetector extends BasePattern {
         'migration',
     ];
     mode = 'both';
-    priority = 9; // High priority - detect ambiguity early
+    priority = 9; // VERY HIGH - structural integrity
+    phases = ['all'];
+    // -------------------------------------------------------------------------
+    // Configuration Schema (v4.5)
+    // -------------------------------------------------------------------------
+    static configSchema = {
+        checkVaguePatterns: {
+            type: 'boolean',
+            default: true,
+            description: 'Check for vague phrases like "should work", "properly", etc.',
+        },
+        checkUndefinedPronouns: {
+            type: 'boolean',
+            default: true,
+            description: 'Check for unclear pronoun references',
+        },
+        maxClarifications: {
+            type: 'number',
+            default: 10,
+            description: 'Maximum number of clarifications to add',
+            validation: { min: 1, max: 20 },
+        },
+    };
+    // -------------------------------------------------------------------------
+    // Pattern Data
+    // -------------------------------------------------------------------------
     // Common ambiguous terms that need clarification
     ambiguousTerms = {
         // Generic terms needing specificity

package/dist/core/intelligence/patterns/assumption-explicitizer.d.ts

@@ -1,18 +1,20 @@
-import { BasePattern } from './base-pattern.js';
+import { BasePattern, PatternMode, PatternPriority, PatternPhase, PatternConfigSchema } from './base-pattern.js';
 import { PromptIntent, PatternContext, PatternResult } from '../types.js';
 /**
- * v4.0 Deep Mode Pattern: Assumption Explicitizer
+ * v4.5 Pattern: Assumption Explicitizer
  *
  * Makes implicit assumptions explicit to prevent misunderstandings
  * and ensure comprehensive requirement coverage.
  */
 export declare class AssumptionExplicitizer extends BasePattern {
-    id: string;
-    name: string;
-    description: string;
-    applicableIntents: PromptIntent[];
-    mode: "deep";
-    priority: number;
+    readonly id = "assumption-explicitizer";
+    readonly name = "Assumption Explicitizer";
+    readonly description = "Make implicit assumptions explicit to prevent misunderstandings";
+    readonly applicableIntents: PromptIntent[];
+    readonly mode: PatternMode;
+    readonly priority: PatternPriority;
+    readonly phases: PatternPhase[];
+    static readonly configSchema: PatternConfigSchema;
     apply(prompt: string, context: PatternContext): PatternResult;
     private identifyAssumptions;
     private identifyMissingContext;

package/dist/core/intelligence/patterns/assumption-explicitizer.js

@@ -1,11 +1,14 @@
-import { BasePattern } from './base-pattern.js';
+import { BasePattern, } from './base-pattern.js';
 /**
- * v4.0 Deep Mode Pattern: Assumption Explicitizer
+ * v4.5 Pattern: Assumption Explicitizer
  *
  * Makes implicit assumptions explicit to prevent misunderstandings
  * and ensure comprehensive requirement coverage.
  */
 export class AssumptionExplicitizer extends BasePattern {
+    // -------------------------------------------------------------------------
+    // Pattern Metadata (v4.5 unified types)
+    // -------------------------------------------------------------------------
     id = 'assumption-explicitizer';
     name = 'Assumption Explicitizer';
     description = 'Make implicit assumptions explicit to prevent misunderstandings';
@@ -18,7 +21,27 @@ export class AssumptionExplicitizer extends BasePattern {
         'prd-generation',
     ];
     mode = 'deep';
-    priority = 6;
+    priority = 6; // MEDIUM - standard enhancement
+    phases = ['all'];
+    // -------------------------------------------------------------------------
+    // Configuration Schema (v4.5)
+    // -------------------------------------------------------------------------
+    static configSchema = {
+        maxAssumptions: {
+            type: 'number',
+            default: 8,
+            description: 'Maximum number of assumptions to surface',
+            validation: { min: 1, max: 15 },
+        },
+        checkDomainAssumptions: {
+            type: 'boolean',
+            default: true,
+            description: 'Check for domain-specific assumptions (auth, API style, etc.)',
+        },
+    };
+    // -------------------------------------------------------------------------
+    // Pattern Application
+    // -------------------------------------------------------------------------
     apply(prompt, context) {
         const assumptions = this.identifyAssumptions(prompt, context.intent.primaryIntent);
         if (assumptions.length === 0) {