clavix 4.4.0 → 4.6.0

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

@@ -19,7 +19,8 @@ export declare class InstructionsGenerator {
     private static copyStaticInstructions;
     /**
      * Copy ALL canonical templates to .clavix/instructions/workflows/
-     * This ensures generic integrations have access to complete workflow set
+     * This ensures generic integrations have access to complete workflow set.
+     * v4.5: Uses TemplateAssembler to resolve {{INCLUDE:}} markers.
      */
     private static copyCanonicalWorkflows;
     /**

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

@@ -1,4 +1,5 @@
 import { FileSystem } from '../../utils/file-system.js';
+import { TemplateAssembler } from '../template-assembler.js';
 import * as path from 'path';
 import { fileURLToPath } from 'url';
 import { dirname } from 'path';
@@ -17,7 +18,7 @@ export class InstructionsGenerator {
         'octo-md',
         'warp-md',
         'agents-md',
-        'copilot-instructions'
+        'copilot-instructions',
     ];
     /**
      * Generate .clavix/instructions/ folder with all reference files
@@ -61,7 +62,8 @@ export class InstructionsGenerator {
     }
     /**
      * Copy ALL canonical templates to .clavix/instructions/workflows/
-     * This ensures generic integrations have access to complete workflow set
+     * This ensures generic integrations have access to complete workflow set.
+     * v4.5: Uses TemplateAssembler to resolve {{INCLUDE:}} markers.
      */
     static async copyCanonicalWorkflows() {
         const canonicalPath = path.join(__dirname, '../../templates/slash-commands/_canonical');
@@ -71,14 +73,25 @@ export class InstructionsGenerator {
         }
         // Create workflows directory
         await FileSystem.ensureDir(workflowsTarget);
-        // Copy all .md files from canonical
+        // Create TemplateAssembler for include resolution
+        const templatesBasePath = path.join(__dirname, '../../templates');
+        const assembler = new TemplateAssembler(templatesBasePath);
+        // Copy all .md files from canonical, resolving includes
         const entries = await FileSystem.readdir(canonicalPath, { withFileTypes: true });
-        const mdFiles = entries.filter(f => f.isFile() && f.name.endsWith('.md'));
+        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);
+            try {
+                // v4.5: Use TemplateAssembler to resolve {{INCLUDE:}} markers
+                const result = await assembler.assembleTemplate(file.name);
+                await FileSystem.writeFileAtomic(destPath, result.content);
+            }
+            catch {
+                // Fallback: copy without include resolution if assembly fails
+                const srcPath = path.join(canonicalPath, file.name);
+                const content = await FileSystem.readFile(srcPath);
+                await FileSystem.writeFileAtomic(destPath, content);
+            }
         }
     }
     /**
@@ -109,7 +122,7 @@ export class InstructionsGenerator {
      * Check if any generic integration is selected
      */
     static needsGeneration(selectedIntegrations) {
-        return selectedIntegrations.some(integration => this.GENERIC_INTEGRATIONS.includes(integration));
+        return selectedIntegrations.some((integration) => this.GENERIC_INTEGRATIONS.includes(integration));
     }
     /**
      * Remove instructions folder

package/dist/core/intelligence/confidence-calculator.d.ts

@@ -0,0 +1,93 @@
+/**
+ * v4.5 Confidence Calculator Utilities
+ *
+ * Shared utilities for calculating confidence scores across the intelligence system.
+ * Provides type-safe confidence values and common calculation patterns.
+ */
+/**
+ * Confidence level as a percentage (0-100).
+ * - 0-49: Low confidence
+ * - 50-69: Medium confidence
+ * - 70-84: High confidence
+ * - 85-100: Very high confidence
+ */
+export type ConfidenceLevel = number;
+/**
+ * Confidence category for display purposes
+ */
+export type ConfidenceCategory = 'low' | 'medium' | 'high' | 'very-high';
+/**
+ * Confidence result with category and percentage
+ */
+export interface ConfidenceResult {
+    percentage: ConfidenceLevel;
+    category: ConfidenceCategory;
+}
+export declare const CONFIDENCE_THRESHOLDS: {
+    readonly LOW_MAX: 49;
+    readonly MEDIUM_MAX: 69;
+    readonly HIGH_MAX: 84;
+    readonly VERY_HIGH_MIN: 85;
+};
+/**
+ * Clamp a confidence value to valid range (0-100)
+ */
+export declare function clampConfidence(value: number): ConfidenceLevel;
+/**
+ * Get confidence category from percentage
+ */
+export declare function getConfidenceCategory(percentage: ConfidenceLevel): ConfidenceCategory;
+/**
+ * Create a confidence result from a percentage
+ */
+export declare function createConfidenceResult(percentage: number): ConfidenceResult;
+/**
+ * Calculate additive confidence based on presence of elements.
+ * Common pattern: base + bonus for each element present.
+ *
+ * @example
+ * calculateAdditiveConfidence(50, [
+ *   [hasRequirements, 20],
+ *   [hasGoals, 15],
+ *   [hasConstraints, 15],
+ * ]);
+ */
+export declare function calculateAdditiveConfidence(baseConfidence: number, bonuses: Array<[boolean, number]>): ConfidenceLevel;
+/**
+ * Calculate ratio-based confidence.
+ * Common pattern: primary score as percentage of total score.
+ *
+ * @example
+ * calculateRatioConfidence(primaryScore, totalScore);
+ */
+export declare function calculateRatioConfidence(primaryScore: number, totalScore: number, options?: {
+    minConfidence?: number;
+    fallbackConfidence?: number;
+}): ConfidenceLevel;
+/**
+ * Apply confidence penalty when competing scores are close.
+ * Common pattern: reduce confidence when there's ambiguity.
+ *
+ * @example
+ * applyCompetitionPenalty(confidence, primaryScore, secondaryScore, {
+ *   threshold: 0.15,
+ *   penalty: 15,
+ *   minConfidence: 60,
+ * });
+ */
+export declare function applyCompetitionPenalty(confidence: number, primaryScore: number, secondaryScore: number, options?: {
+    threshold?: number;
+    penalty?: number;
+    minConfidence?: number;
+}): ConfidenceLevel;
+/**
+ * Calculate weighted average confidence from multiple sources.
+ *
+ * @example
+ * calculateWeightedConfidence([
+ *   [intentConfidence, 0.6],
+ *   [qualityConfidence, 0.4],
+ * ]);
+ */
+export declare function calculateWeightedConfidence(scores: Array<[number, number]>): ConfidenceLevel;
+//# sourceMappingURL=confidence-calculator.d.ts.map

package/dist/core/intelligence/confidence-calculator.js

@@ -0,0 +1,124 @@
+/**
+ * v4.5 Confidence Calculator Utilities
+ *
+ * Shared utilities for calculating confidence scores across the intelligence system.
+ * Provides type-safe confidence values and common calculation patterns.
+ */
+// ============================================================================
+// Thresholds
+// ============================================================================
+export const CONFIDENCE_THRESHOLDS = {
+    LOW_MAX: 49,
+    MEDIUM_MAX: 69,
+    HIGH_MAX: 84,
+    VERY_HIGH_MIN: 85,
+};
+// ============================================================================
+// Utility Functions
+// ============================================================================
+/**
+ * Clamp a confidence value to valid range (0-100)
+ */
+export function clampConfidence(value) {
+    return Math.min(100, Math.max(0, Math.round(value)));
+}
+/**
+ * Get confidence category from percentage
+ */
+export function getConfidenceCategory(percentage) {
+    if (percentage <= CONFIDENCE_THRESHOLDS.LOW_MAX)
+        return 'low';
+    if (percentage <= CONFIDENCE_THRESHOLDS.MEDIUM_MAX)
+        return 'medium';
+    if (percentage <= CONFIDENCE_THRESHOLDS.HIGH_MAX)
+        return 'high';
+    return 'very-high';
+}
+/**
+ * Create a confidence result from a percentage
+ */
+export function createConfidenceResult(percentage) {
+    const clamped = clampConfidence(percentage);
+    return {
+        percentage: clamped,
+        category: getConfidenceCategory(clamped),
+    };
+}
+// ============================================================================
+// Calculation Patterns
+// ============================================================================
+/**
+ * Calculate additive confidence based on presence of elements.
+ * Common pattern: base + bonus for each element present.
+ *
+ * @example
+ * calculateAdditiveConfidence(50, [
+ *   [hasRequirements, 20],
+ *   [hasGoals, 15],
+ *   [hasConstraints, 15],
+ * ]);
+ */
+export function calculateAdditiveConfidence(baseConfidence, bonuses) {
+    let total = baseConfidence;
+    for (const [condition, bonus] of bonuses) {
+        if (condition) {
+            total += bonus;
+        }
+    }
+    return clampConfidence(total);
+}
+/**
+ * Calculate ratio-based confidence.
+ * Common pattern: primary score as percentage of total score.
+ *
+ * @example
+ * calculateRatioConfidence(primaryScore, totalScore);
+ */
+export function calculateRatioConfidence(primaryScore, totalScore, options = {}) {
+    const { minConfidence = 0, fallbackConfidence = 50 } = options;
+    if (totalScore === 0) {
+        return fallbackConfidence;
+    }
+    const ratio = primaryScore / totalScore;
+    const percentage = Math.round(ratio * 100);
+    return clampConfidence(Math.max(minConfidence, percentage));
+}
+/**
+ * Apply confidence penalty when competing scores are close.
+ * Common pattern: reduce confidence when there's ambiguity.
+ *
+ * @example
+ * applyCompetitionPenalty(confidence, primaryScore, secondaryScore, {
+ *   threshold: 0.15,
+ *   penalty: 15,
+ *   minConfidence: 60,
+ * });
+ */
+export function applyCompetitionPenalty(confidence, primaryScore, secondaryScore, options = {}) {
+    const { threshold = 0.15, penalty = 15, minConfidence = 60 } = options;
+    const difference = primaryScore - secondaryScore;
+    // If scores are within threshold, apply penalty
+    if (primaryScore > 0 && difference < primaryScore * threshold) {
+        return clampConfidence(Math.max(minConfidence, confidence - penalty));
+    }
+    return clampConfidence(confidence);
+}
+/**
+ * Calculate weighted average confidence from multiple sources.
+ *
+ * @example
+ * calculateWeightedConfidence([
+ *   [intentConfidence, 0.6],
+ *   [qualityConfidence, 0.4],
+ * ]);
+ */
+export function calculateWeightedConfidence(scores // [confidence, weight]
+) {
+    const totalWeight = scores.reduce((sum, [, weight]) => sum + weight, 0);
+    if (totalWeight === 0) {
+        return 50;
+    }
+    const weightedSum = scores.reduce((sum, [confidence, weight]) => sum + confidence * weight, 0);
+    return clampConfidence(weightedSum / totalWeight);
+}
+//# sourceMappingURL=confidence-calculator.js.map

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

@@ -3,6 +3,7 @@ export { IntentDetector } from './intent-detector.js';
 export { PatternLibrary } from './pattern-library.js';
 export { QualityAssessor } from './quality-assessor.js';
 export * from './types.js';
+export * from './confidence-calculator.js';
 export { BasePattern } from './patterns/base-pattern.js';
 export { ConcisenessFilter } from './patterns/conciseness-filter.js';
 export { ObjectiveClarifier } from './patterns/objective-clarifier.js';

package/dist/core/intelligence/index.js

@@ -5,6 +5,8 @@ export { PatternLibrary } from './pattern-library.js';
 export { QualityAssessor } from './quality-assessor.js';
 // Type exports
 export * from './types.js';
+// v4.5: Confidence calculation utilities
+export * from './confidence-calculator.js';
 // Pattern exports
 export { BasePattern } from './patterns/base-pattern.js';
 export { ConcisenessFilter } from './patterns/conciseness-filter.js';

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

@@ -1,3 +1,4 @@
+import { calculateRatioConfidence, applyCompetitionPenalty } from './confidence-calculator.js';
 /**
  * Enhanced Intent Detector with weighted scoring and phrase-based detection
  * Target Accuracy: 95%+
@@ -556,22 +557,23 @@ export class IntentDetector {
     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
-        }
+        // v4.5: Use shared confidence calculator
         // Calculate confidence as percentage of primary vs total
-        let confidence = Math.min(100, Math.round((primaryScore / totalScore) * 100));
+        let confidence = calculateRatioConfidence(primaryScore, totalScore, {
+            fallbackConfidence: 50, // Low confidence if no keywords matched
+        });
         // 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);
-            }
+            confidence = applyCompetitionPenalty(confidence, primaryScore, secondaryScore, {
+                threshold: 0.15,
+                penalty: 15,
+                minConfidence: 60,
+            });
         }
         return confidence;
     }

package/dist/core/intelligence/pattern-library.d.ts

@@ -1,15 +1,21 @@
-import { BasePattern } from './patterns/base-pattern.js';
+import { BasePattern, IPatternLibrary } from './patterns/base-pattern.js';
 import { IntentAnalysis, OptimizationMode, OptimizationPhase } from './types.js';
 import { IntelligenceConfig } from '../../types/config.js';
-export declare class PatternLibrary {
+export declare class PatternLibrary implements IPatternLibrary {
     private patterns;
     private config;
+    private priorityOverrides;
     constructor();
     /**
-     * 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: IntelligenceConfig): void;
+    /**
+     * v4.5: Get effective priority for a pattern (considers overrides)
+     */
+    private getEffectivePriority;
     /**
      * v4.4: Check if a pattern is disabled via config
      */
@@ -20,7 +26,8 @@ export declare class PatternLibrary {
     getPatternSettings(patternId: string): Record<string, unknown> | undefined;
     private registerDefaultPatterns;
     /**
-     * Register a new pattern
+     * Register a new pattern.
+     * v4.5: Injects library reference for config access.
      */
     register(pattern: BasePattern): void;
     /**
@@ -44,22 +51,37 @@ export declare class PatternLibrary {
      */
     selectPatterns(intent: IntentAnalysis, mode: OptimizationMode): BasePattern[];
     /**
-     * v4.3.2: Select patterns for specific mode with phase-awareness
+     * v4.5: Sort patterns by priority while respecting dependency constraints.
+     * Handles runAfter (must run after specified patterns) and excludesWith (mutually exclusive).
+     */
+    private sortPatternsWithDependencies;
+    /**
+     * v4.5: Filter out patterns that are mutually exclusive with higher priority patterns.
+     */
+    private filterExcludedPatterns;
+    /**
+     * v4.5: Adjust pattern order to respect runAfter dependencies.
+     * If pattern A declares runAfter: ['B'], ensure B runs before A.
+     */
+    private adjustForDependencies;
+    /**
+     * v4.5: Select patterns for specific mode with phase-awareness
      * Maps PRD and conversational modes to appropriate base modes and patterns
      */
     selectPatternsForMode(mode: OptimizationMode, intent: IntentAnalysis, phase?: OptimizationPhase): BasePattern[];
     /**
-     * Map extended modes to base modes for pattern compatibility
+     * v4.5: Check if pattern is applicable for a given phase.
+     * Uses pattern's declared phases property instead of hardcoded mappings.
      */
-    private mapToBaseMode;
+    private isPatternApplicableForPhase;
     /**
-     * Check if pattern is applicable for PRD phase
+     * v4.5: Map OptimizationPhase string to PatternPhase type
      */
-    private isPatternApplicableForPRDPhase;
+    private mapOptimizationPhaseToPatternPhase;
     /**
-     * Check if pattern is applicable for conversational phase
+     * Map extended modes to base modes for pattern compatibility
      */
-    private isPatternApplicableForConversationalPhase;
+    private mapToBaseMode;
     /**
      * Get all registered patterns
      */