clavix 4.3.2 → 4.5.0

package/dist/core/intelligence/patterns/base-pattern.d.ts

@@ -1,14 +1,172 @@
-import { PromptIntent, OptimizationMode, PatternContext, PatternResult } from '../types.js';
+import { PromptIntent, PatternContext, PatternResult } from '../types.js';
+/**
+ * Pattern mode determines when a pattern is active.
+ * - 'fast': Only in fast optimization mode
+ * - 'deep': Only in deep analysis mode
+ * - 'both': Available in both modes
+ */
+export type PatternMode = 'fast' | 'deep' | 'both';
+/**
+ * Pattern phases for PRD and Conversational modes.
+ * Patterns declare which phases they apply to.
+ *
+ * - 'question-validation': PRD mode - validating individual answers
+ * - 'output-generation': PRD mode - generating final PRD documents
+ * - 'conversation-tracking': Conversational mode - analyzing messages in real-time
+ * - 'summarization': Conversational mode - extracting requirements from conversation
+ * - 'all': Pattern applies to all phases (default for basic patterns)
+ */
+export type PatternPhase = 'question-validation' | 'output-generation' | 'conversation-tracking' | 'summarization' | 'all';
+/**
+ * Pattern Priority Scale (1-10)
+ *
+ * Higher priority patterns run FIRST (sorted descending).
+ *
+ * 10: CRITICAL - Must run before everything else
+ *     Use case: Mode detection, fundamental structure validation
+ *
+ * 9:  VERY HIGH - Structural integrity
+ *     Use case: Ambiguity detection, completeness validation, PRD structure
+ *
+ * 8:  HIGH - Core enhancement
+ *     Use case: Objective clarification, structure organization, summarization
+ *
+ * 7:  MEDIUM-HIGH - Important enrichment
+ *     Use case: Output format, success criteria, requirement prioritization
+ *
+ * 6:  MEDIUM - Standard enhancement
+ *     Use case: Context enrichment, topic coherence, user personas
+ *
+ * 5:  MEDIUM-LOW - Supplementary
+ *     Use case: Step decomposition, technical context, implicit requirements
+ *
+ * 4:  LOW - Polish
+ *     Use case: Conciseness filtering, actionability enhancement
+ *
+ * 3:  VERY LOW - Final touches
+ *     Use case: Phrasing alternatives, edge cases, validation checklists
+ *
+ * 2:  MINIMAL - Only if nothing else applies
+ *     Use case: Reserved for future
+ *
+ * 1:  LOWEST - Last resort
+ *     Use case: Reserved for future
+ *
+ * Collision Resolution: When priorities are equal, patterns run
+ * in registration order (first registered runs first).
+ */
+export type PatternPriority = 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10;
+/**
+ * Pattern dependency configuration.
+ * Allows patterns to express execution order constraints.
+ */
+export interface PatternDependency {
+    /**
+     * Patterns that must run before this one.
+     * Uses pattern IDs.
+     */
+    runAfter?: string[];
+    /**
+     * Patterns that are mutually exclusive with this one.
+     * If one runs, the other won't.
+     */
+    excludesWith?: string[];
+    /**
+     * Patterns that enhance this one when both run.
+     * Informational only, no enforcement.
+     */
+    enhancedBy?: string[];
+}
+/**
+ * Schema field types for pattern configuration
+ */
+export type PatternConfigFieldType = 'string' | 'number' | 'boolean' | 'array' | 'enum';
+/**
+ * Single field in a pattern's configuration schema
+ */
+export interface PatternConfigField {
+    type: PatternConfigFieldType;
+    default: unknown;
+    description: string;
+    validation?: {
+        min?: number;
+        max?: number;
+        enum?: string[];
+        minLength?: number;
+        maxLength?: number;
+    };
+}
+/**
+ * Configuration schema for a pattern.
+ * Each pattern declares its configurable options.
+ * Empty object `{}` means no configuration available.
+ */
+export interface PatternConfigSchema {
+    [fieldName: string]: PatternConfigField;
+}
+/**
+ * Interface for PatternLibrary to avoid circular dependency.
+ * Used by patterns to access their configuration.
+ */
+export interface IPatternLibrary {
+    getPatternSettings(patternId: string): Record<string, unknown> | undefined;
+}
 export declare abstract class BasePattern {
-    abstract id: string;
-    abstract name: string;
-    abstract description: string;
-    abstract applicableIntents: PromptIntent[];
-    abstract mode: OptimizationMode | 'both';
-    abstract priority: number;
+    /** Unique identifier for this pattern (e.g., 'conciseness-filter') */
+    abstract readonly id: string;
+    /** Human-readable name (e.g., 'Conciseness Filter') */
+    abstract readonly name: string;
+    /** Brief description of what this pattern does */
+    abstract readonly description: string;
+    /** Which intents this pattern is applicable to */
+    abstract readonly applicableIntents: PromptIntent[];
+    /** Which mode(s) this pattern runs in */
+    abstract readonly mode: PatternMode;
+    /** Execution priority (1-10, higher runs first) */
+    abstract readonly priority: PatternPriority;
+    /** Which phases this pattern applies to (PRD/conversational modes) */
+    abstract readonly phases: PatternPhase[];
+    /** Optional dependency configuration */
+    readonly dependencies?: PatternDependency;
+    /**
+     * Configuration schema for this pattern.
+     * Override in subclass to define configurable options.
+     * Empty object means no configuration available.
+     */
+    static readonly configSchema: PatternConfigSchema;
+    /**
+     * Reference to pattern library for accessing configuration.
+     * Injected by PatternLibrary on registration.
+     */
+    private patternLibraryRef?;
+    /**
+     * Inject PatternLibrary reference for config access.
+     * Called by PatternLibrary during registration.
+     */
+    setPatternLibrary(library: IPatternLibrary): void;
+    /**
+     * Get settings for this pattern with defaults applied.
+     * Use in apply() method to access user configuration.
+     *
+     * @example
+     * ```typescript
+     * apply(prompt: string, context: PatternContext): PatternResult {
+     *   const settings = this.getSettings();
+     *   if (fluffCount > settings.fluffThreshold) {
+     *     // ...
+     *   }
+     * }
+     * ```
+     */
+    protected getSettings(): Record<string, unknown>;
+    /**
+     * Apply this pattern to the given prompt.
+     * Must be implemented by all concrete patterns.
+     */
     abstract apply(prompt: string, context: PatternContext): PatternResult;
     /**
-     * Check if this pattern is applicable for the given context
+     * Check if this pattern is applicable for the given context.
+     * Can be overridden for custom applicability logic.
      */
     isApplicable(context: PatternContext): boolean;
     /**

package/dist/core/intelligence/patterns/base-pattern.js

@@ -1,6 +1,63 @@
+// ============================================================================
+// Base Pattern Abstract Class
+// ============================================================================
 export class BasePattern {
+    // -------------------------------------------------------------------------
+    // Optional Pattern Metadata
+    // -------------------------------------------------------------------------
+    /** Optional dependency configuration */
+    dependencies;
+    // -------------------------------------------------------------------------
+    // Configuration Support (v4.5)
+    // -------------------------------------------------------------------------
     /**
-     * Check if this pattern is applicable for the given context
+     * Configuration schema for this pattern.
+     * Override in subclass to define configurable options.
+     * Empty object means no configuration available.
+     */
+    static configSchema = {};
+    /**
+     * Reference to pattern library for accessing configuration.
+     * Injected by PatternLibrary on registration.
+     */
+    patternLibraryRef;
+    /**
+     * Inject PatternLibrary reference for config access.
+     * Called by PatternLibrary during registration.
+     */
+    setPatternLibrary(library) {
+        this.patternLibraryRef = library;
+    }
+    /**
+     * Get settings for this pattern with defaults applied.
+     * Use in apply() method to access user configuration.
+     *
+     * @example
+     * ```typescript
+     * apply(prompt: string, context: PatternContext): PatternResult {
+     *   const settings = this.getSettings();
+     *   if (fluffCount > settings.fluffThreshold) {
+     *     // ...
+     *   }
+     * }
+     * ```
+     */
+    getSettings() {
+        // Get the static configSchema from the concrete class
+        const ConcreteClass = this.constructor;
+        const schema = ConcreteClass.configSchema;
+        // Build defaults from schema
+        const defaults = {};
+        for (const [key, field] of Object.entries(schema)) {
+            defaults[key] = field.default;
+        }
+        // Merge with user config (user config overrides defaults)
+        const userConfig = this.patternLibraryRef?.getPatternSettings(this.id) || {};
+        return { ...defaults, ...userConfig };
+    }
+    /**
+     * Check if this pattern is applicable for the given context.
+     * Can be overridden for custom applicability logic.
      */
     isApplicable(context) {
         // Check mode compatibility
@@ -10,6 +67,9 @@ export class BasePattern {
         // Check intent compatibility
         return this.applicableIntents.includes(context.intent.primaryIntent);
     }
+    // -------------------------------------------------------------------------
+    // Utility Methods
+    // -------------------------------------------------------------------------
     /**
      * Utility: Remove extra whitespace
      */
@@ -21,19 +81,19 @@ export class BasePattern {
      */
     hasSection(prompt, keywords) {
         const lowerPrompt = prompt.toLowerCase();
-        return keywords.some(keyword => lowerPrompt.includes(keyword.toLowerCase()));
+        return keywords.some((keyword) => lowerPrompt.includes(keyword.toLowerCase()));
     }
     /**
      * Utility: Count words
      */
     countWords(text) {
-        return text.split(/\s+/).filter(word => word.length > 0).length;
+        return text.split(/\s+/).filter((word) => word.length > 0).length;
     }
     /**
      * Utility: Extract sentences
      */
     extractSentences(text) {
-        return text.split(/[.!?]+/).filter(s => s.trim().length > 0);
+        return text.split(/[.!?]+/).filter((s) => s.trim().length > 0);
     }
 }
 //# sourceMappingURL=base-pattern.js.map

package/dist/core/intelligence/patterns/completeness-validator.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';
 /**
- * Completeness Validator Pattern
+ * v4.5 Pattern: Completeness Validator
  *
  * Ensures all necessary requirements are present.
  * Adds placeholder sections for missing critical elements.
- *
- * Priority: MEDIUM (6)
  */
 export declare class CompletenessValidator extends BasePattern {
-    id: string;
-    name: string;
-    description: string;
-    applicableIntents: PromptIntent[];
-    mode: 'fast' | 'deep' | 'both';
-    priority: number;
+    readonly id = "completeness-validator";
+    readonly name = "Completeness Validator";
+    readonly description = "Ensures all necessary requirements are present";
+    readonly applicableIntents: PromptIntent[];
+    readonly mode: PatternMode;
+    readonly priority: PatternPriority;
+    readonly phases: PatternPhase[];
+    static readonly configSchema: PatternConfigSchema;
     apply(prompt: string, _context: PatternContext): PatternResult;
     private findMissingElements;
     private hasObjective;

package/dist/core/intelligence/patterns/completeness-validator.js

@@ -1,19 +1,40 @@
-import { BasePattern } from './base-pattern.js';
+import { BasePattern, } from './base-pattern.js';
 /**
- * Completeness Validator Pattern
+ * v4.5 Pattern: Completeness Validator
  *
  * Ensures all necessary requirements are present.
  * Adds placeholder sections for missing critical elements.
- *
- * Priority: MEDIUM (6)
  */
 export class CompletenessValidator extends BasePattern {
+    // -------------------------------------------------------------------------
+    // Pattern Metadata (v4.5 unified types)
+    // -------------------------------------------------------------------------
     id = 'completeness-validator';
     name = 'Completeness Validator';
     description = 'Ensures all necessary requirements are present';
     applicableIntents = ['code-generation', 'planning', 'refinement'];
     mode = 'both';
-    priority = 6; // Medium priority
+    priority = 6; // MEDIUM - standard enhancement
+    phases = ['all'];
+    // -------------------------------------------------------------------------
+    // Configuration Schema (v4.5)
+    // -------------------------------------------------------------------------
+    static configSchema = {
+        showCompletenessScore: {
+            type: 'boolean',
+            default: true,
+            description: 'Display completeness percentage in output',
+        },
+        minCompletenessThreshold: {
+            type: 'number',
+            default: 60,
+            description: 'Minimum completeness percentage to consider prompt adequate',
+            validation: { min: 0, max: 100 },
+        },
+    };
+    // -------------------------------------------------------------------------
+    // Pattern Application
+    // -------------------------------------------------------------------------
     apply(prompt, _context) {
         const missing = this.findMissingElements(prompt);
         if (missing.length === 0) {

package/dist/core/intelligence/patterns/conciseness-filter.d.ts

@@ -1,12 +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';
+/**
+ * v4.5 Pattern: Conciseness Filter
+ *
+ * Removes unnecessary pleasantries, fluff words, and redundancy
+ * to make prompts more direct and efficient.
+ */
 export declare class ConcisenessFilter extends BasePattern {
-    id: string;
-    name: string;
-    description: string;
-    applicableIntents: PromptIntent[];
-    mode: 'fast' | 'deep' | 'both';
-    priority: number;
+    readonly id = "conciseness-filter";
+    readonly name = "Conciseness Filter";
+    readonly description = "Removes unnecessary pleasantries, fluff words, and redundancy";
+    readonly applicableIntents: PromptIntent[];
+    readonly mode: PatternMode;
+    readonly priority: PatternPriority;
+    readonly phases: PatternPhase[];
+    static readonly configSchema: PatternConfigSchema;
     apply(prompt: string, _context: PatternContext): PatternResult;
 }
 //# sourceMappingURL=conciseness-filter.d.ts.map

package/dist/core/intelligence/patterns/conciseness-filter.js

@@ -1,5 +1,14 @@
-import { BasePattern } from './base-pattern.js';
+import { BasePattern, } from './base-pattern.js';
+/**
+ * v4.5 Pattern: Conciseness Filter
+ *
+ * Removes unnecessary pleasantries, fluff words, and redundancy
+ * to make prompts more direct and efficient.
+ */
 export class ConcisenessFilter extends BasePattern {
+    // -------------------------------------------------------------------------
+    // Pattern Metadata (v4.5 unified types)
+    // -------------------------------------------------------------------------
     id = 'conciseness-filter';
     name = 'Conciseness Filter';
     description = 'Removes unnecessary pleasantries, fluff words, and redundancy';
@@ -11,8 +20,30 @@ export class ConcisenessFilter extends BasePattern {
         'documentation',
     ];
     mode = 'both';
-    priority = 10; // High priority - run early
+    priority = 4; // LOW - Polish phase
+    phases = ['all'];
+    // -------------------------------------------------------------------------
+    // Configuration Schema (v4.5)
+    // -------------------------------------------------------------------------
+    static configSchema = {
+        fluffThreshold: {
+            type: 'number',
+            default: 3,
+            description: 'Number of fluff words to tolerate before applying filter',
+            validation: { min: 1, max: 10 },
+        },
+        preserveTechnicalTerms: {
+            type: 'boolean',
+            default: true,
+            description: 'Keep technical terms even if they appear verbose',
+        },
+    };
+    // -------------------------------------------------------------------------
+    // Pattern Application
+    // -------------------------------------------------------------------------
     apply(prompt, _context) {
+        const settings = this.getSettings();
+        const fluffThreshold = settings.fluffThreshold ?? 3;
         let cleaned = prompt;
         let changesCount = 0;
         // Remove pleasantries at start
@@ -45,9 +76,10 @@ export class ConcisenessFilter extends BasePattern {
         cleaned = cleaned.replace(/in the event that/gi, 'if');
         // Clean up extra whitespace
         cleaned = this.cleanWhitespace(cleaned);
-        const applied = changesCount > 0 || cleaned !== prompt;
+        // Only apply if changes exceed threshold
+        const applied = changesCount >= fluffThreshold || cleaned !== prompt;
         return {
-            enhancedPrompt: cleaned,
+            enhancedPrompt: applied ? cleaned : prompt,
             improvement: {
                 dimension: 'efficiency',
                 description: `Removed ${changesCount} unnecessary phrases for conciseness`,

package/dist/core/intelligence/patterns/context-precision.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 Both Mode Pattern: Context Precision Booster
+ * v4.5 Pattern: Context Precision Booster
  *
  * Adds precise context when missing to ensure
  * the AI has sufficient information for accurate responses.
  */
 export declare class ContextPrecisionBooster extends BasePattern {
-    id: string;
-    name: string;
-    description: string;
-    applicableIntents: PromptIntent[];
-    mode: "both";
-    priority: number;
+    readonly id = "context-precision";
+    readonly name = "Context Precision Booster";
+    readonly description = "Add precise context when missing";
+    readonly applicableIntents: PromptIntent[];
+    readonly mode: PatternMode;
+    readonly priority: PatternPriority;
+    readonly phases: PatternPhase[];
+    static readonly configSchema: PatternConfigSchema;
     apply(prompt: string, context: PatternContext): PatternResult;
     private identifyMissingContext;
     private checkGeneralContext;

package/dist/core/intelligence/patterns/context-precision.js

@@ -1,25 +1,48 @@
-import { BasePattern } from './base-pattern.js';
+import { BasePattern, } from './base-pattern.js';
 /**
- * v4.0 Both Mode Pattern: Context Precision Booster
+ * v4.5 Pattern: Context Precision Booster
  *
  * Adds precise context when missing to ensure
  * the AI has sufficient information for accurate responses.
  */
 export class ContextPrecisionBooster extends BasePattern {
+    // -------------------------------------------------------------------------
+    // Pattern Metadata (v4.5 unified types)
+    // -------------------------------------------------------------------------
     id = 'context-precision';
     name = 'Context Precision Booster';
     description = 'Add precise context when missing';
     applicableIntents = [
         'code-generation',
         'debugging',
-        'refinement', // Includes code review and refactoring
-        'documentation', // Includes explanations
+        'refinement',
+        'documentation',
         'testing',
         'migration',
         'security-review',
     ];
     mode = 'both';
-    priority = 8;
+    priority = 6; // MEDIUM - standard enhancement
+    phases = ['all'];
+    // -------------------------------------------------------------------------
+    // Configuration Schema (v4.5)
+    // -------------------------------------------------------------------------
+    static configSchema = {
+        maxContextGaps: {
+            type: 'number',
+            default: 6,
+            description: 'Maximum number of context gaps to surface',
+            validation: { min: 1, max: 10 },
+        },
+        checkVersionInfo: {
+            type: 'boolean',
+            default: true,
+            description: 'Check for missing version information',
+        },
+    };
+    // -------------------------------------------------------------------------
+    // Pattern Application
+    // -------------------------------------------------------------------------
     apply(prompt, context) {
         const missingContext = this.identifyMissingContext(prompt, context.intent.primaryIntent);
         if (missingContext.length === 0) {

package/dist/core/intelligence/patterns/conversation-summarizer.d.ts

@@ -1,21 +1,26 @@
-import { BasePattern } from './base-pattern.js';
-import { PromptIntent, OptimizationMode, PatternContext, PatternResult } from '../types.js';
+import { BasePattern, PatternMode, PatternPriority, PatternPhase, PatternConfigSchema } from './base-pattern.js';
+import { PromptIntent, PatternContext, PatternResult } from '../types.js';
 /**
- * v4.3.2 Conversational Pattern: ConversationSummarizer
+ * v4.5 Pattern: Conversation Summarizer
  *
  * Extracts structured requirements from conversational messages.
  * Organizes free-form discussion into actionable requirements.
+ * Enhanced with expanded marker detection and confidence scoring.
  */
 export declare class ConversationSummarizer extends BasePattern {
-    id: string;
-    name: string;
-    description: string;
-    applicableIntents: PromptIntent[];
-    mode: OptimizationMode | 'both';
-    priority: number;
+    readonly id = "conversation-summarizer";
+    readonly name = "Conversation Summarizer";
+    readonly description = "Extracts structured requirements from messages";
+    readonly applicableIntents: PromptIntent[];
+    readonly mode: PatternMode;
+    readonly priority: PatternPriority;
+    readonly phases: PatternPhase[];
+    static readonly configSchema: PatternConfigSchema;
+    private readonly conversationalMarkers;
     apply(prompt: string, _context: PatternContext): PatternResult;
     private isAlreadyStructured;
     private isConversationalContent;
+    private calculateConfidence;
     private extractAndStructure;
     private extractRequirements;
     private extractConstraints;