clavix 4.3.2 → 4.5.0

package/dist/core/intelligence/patterns/conversation-summarizer.js

@@ -1,17 +1,89 @@
-import { BasePattern } from './base-pattern.js';
+import { BasePattern, } from './base-pattern.js';
+import { calculateAdditiveConfidence } from '../confidence-calculator.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 class ConversationSummarizer extends BasePattern {
+    // -------------------------------------------------------------------------
+    // Pattern Metadata (v4.5 unified types)
+    // -------------------------------------------------------------------------
     id = 'conversation-summarizer';
-    name = 'ConversationSummarizer';
+    name = 'Conversation Summarizer';
     description = 'Extracts structured requirements from messages';
     applicableIntents = ['summarization', 'planning', 'prd-generation'];
     mode = 'deep';
-    priority = 8;
+    priority = 8; // HIGH - core enhancement
+    phases = ['summarization'];
+    // -------------------------------------------------------------------------
+    // Configuration Schema (v4.5)
+    // -------------------------------------------------------------------------
+    static configSchema = {
+        maxRequirements: {
+            type: 'number',
+            default: 10,
+            description: 'Maximum number of requirements to extract',
+            validation: { min: 1, max: 20 },
+        },
+        maxGoals: {
+            type: 'number',
+            default: 3,
+            description: 'Maximum number of goals to extract',
+            validation: { min: 1, max: 5 },
+        },
+        showConfidence: {
+            type: 'boolean',
+            default: true,
+            description: 'Show extraction confidence percentage',
+        },
+    };
+    // -------------------------------------------------------------------------
+    // Pattern Data
+    // -------------------------------------------------------------------------
+    // Expanded conversational markers (~30 markers)
+    conversationalMarkers = [
+        // Intent expressions
+        'i want',
+        'i need',
+        'we need',
+        'we want',
+        'i would like',
+        'we would like',
+        'would like to',
+        'should be able to',
+        'needs to',
+        // Thinking/exploring
+        'thinking about',
+        'maybe we could',
+        'what if',
+        'how about',
+        'perhaps we',
+        'considering',
+        'wondering if',
+        // Conversational connectors
+        "let's",
+        'let me',
+        'also',
+        'and then',
+        'plus',
+        'another thing',
+        'oh and',
+        'by the way',
+        // Informal markers
+        'basically',
+        'so basically',
+        'essentially',
+        'kind of like',
+        'sort of',
+        'something like',
+        // Collaborative
+        'can we',
+        'could we',
+        'shall we',
+    ];
     apply(prompt, _context) {
         // Check if content is already well-structured
         if (this.isAlreadyStructured(prompt)) {
@@ -65,36 +137,29 @@ export class ConversationSummarizer extends BasePattern {
         return matches.length >= 3;
     }
     isConversationalContent(prompt) {
-        // Conversational markers
-        const conversationalMarkers = [
-            'i want',
-            'i need',
-            'we need',
-            'should be able to',
-            'would like',
-            'thinking about',
-            'maybe we could',
-            'what if',
-            'how about',
-            'let me',
-            "let's",
-            'also',
-            'and then',
-            'basically',
-            'so basically',
-        ];
         const lowerPrompt = prompt.toLowerCase();
-        const matches = conversationalMarkers.filter((marker) => lowerPrompt.includes(marker));
+        const matches = this.conversationalMarkers.filter((marker) => lowerPrompt.includes(marker));
         // Also check for lack of structure (sentences without bullet points)
         const sentences = this.extractSentences(prompt);
         const hasBulletPoints = prompt.includes('- ') || prompt.includes('* ');
+        // More lenient threshold with expanded markers
         return matches.length >= 2 || (sentences.length > 3 && !hasBulletPoints);
     }
+    calculateConfidence(requirements, goals, constraints) {
+        // v4.5: Use shared confidence calculator
+        return calculateAdditiveConfidence(50, [
+            [requirements.length > 0, 20],
+            [goals.length > 0, 15],
+            [constraints.length > 0, 15],
+        ]);
+    }
     extractAndStructure(prompt) {
         const requirements = this.extractRequirements(prompt);
         const constraints = this.extractConstraints(prompt);
         const goals = this.extractGoals(prompt);
+        const confidence = this.calculateConfidence(requirements, goals, constraints);
         let structured = '### Extracted Requirements\n\n';
+        structured += `*Extraction confidence: ${confidence}%*\n\n`;
         if (goals.length > 0) {
             structured += '**Goals:**\n';
             structured += goals.map((g) => `- ${g}`).join('\n');
@@ -110,16 +175,27 @@ export class ConversationSummarizer extends BasePattern {
             structured += constraints.map((c) => `- ${c}`).join('\n');
             structured += '\n\n';
         }
+        // Add verification prompt if confidence is below 80%
+        if (confidence < 80) {
+            structured +=
+                '> **Note:** Please verify these extracted requirements are complete and accurate.\n\n';
+        }
         structured += '---\n\n**Original Context:**\n' + prompt;
         return structured;
     }
     extractRequirements(prompt) {
         const requirements = [];
         const sentences = this.extractSentences(prompt);
+        // Expanded requirement patterns
         const requirementPatterns = [
-            /(?:need|want|should|must|require)\s+(?:to\s+)?(.+)/i,
-            /(?:should be able to|needs to)\s+(.+)/i,
-            /(?:feature|functionality):\s*(.+)/i,
+            /(?:i |we )?(?:need|want|should|must|require)\s+(?:to\s+)?(.+)/i,
+            /(?:should be able to|needs to|has to|have to)\s+(.+)/i,
+            /(?:feature|functionality|capability):\s*(.+)/i,
+            /(?:it should|it must|it needs to)\s+(.+)/i,
+            /(?:users? (?:can|should|will|must))\s+(.+)/i,
+            /(?:the system (?:should|must|will))\s+(.+)/i,
+            /(?:support(?:s|ing)?)\s+(.+)/i,
+            /(?:provide(?:s)?|enable(?:s)?|allow(?:s)?)\s+(.+)/i,
         ];
         for (const sentence of sentences) {
             for (const pattern of requirementPatterns) {
@@ -168,10 +244,14 @@ export class ConversationSummarizer extends BasePattern {
     }
     extractGoals(prompt) {
         const goals = [];
+        // Expanded goal patterns
         const goalPatterns = [
-            /(?:goal is to|aim to|objective is to)\s+(.+)/gi,
-            /(?:trying to|looking to|hoping to)\s+(.+)/gi,
-            /(?:so that|in order to)\s+(.+)/gi,
+            /(?:goal is to|aim(?:ing)? to|objective is to)\s+(.+)/gi,
+            /(?:trying to|looking to|hoping to|want(?:ing)? to)\s+(.+)/gi,
+            /(?:so that|in order to|to achieve)\s+(.+)/gi,
+            /(?:the purpose is|main purpose|key purpose)\s+(.+)/gi,
+            /(?:ultimately|end goal|final goal|main goal)\s+(.+)/gi,
+            /(?:we're building this to|this will help)\s+(.+)/gi,
         ];
         for (const pattern of goalPatterns) {
             const matches = prompt.matchAll(pattern);

package/dist/core/intelligence/patterns/dependency-identifier.d.ts

@@ -1,18 +1,20 @@
-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 PRD Pattern: DependencyIdentifier
+ * v4.5 Pattern: Dependency Identifier
  *
  * Identifies technical and external dependencies in PRD content.
  * Helps surface hidden requirements and blockers.
  */
 export declare class DependencyIdentifier extends BasePattern {
-    id: string;
-    name: string;
-    description: string;
-    applicableIntents: PromptIntent[];
-    mode: OptimizationMode | 'both';
-    priority: number;
+    readonly id = "dependency-identifier";
+    readonly name = "Dependency Identifier";
+    readonly description = "Identifies technical and external dependencies";
+    readonly applicableIntents: PromptIntent[];
+    readonly mode: PatternMode;
+    readonly priority: PatternPriority;
+    readonly phases: PatternPhase[];
+    static readonly configSchema: PatternConfigSchema;
     apply(prompt: string, _context: PatternContext): PatternResult;
     private hasDependencySection;
     private identifyDependencies;

package/dist/core/intelligence/patterns/dependency-identifier.js

@@ -1,17 +1,34 @@
-import { BasePattern } from './base-pattern.js';
+import { BasePattern, } from './base-pattern.js';
 /**
- * v4.3.2 PRD Pattern: DependencyIdentifier
+ * v4.5 Pattern: Dependency Identifier
  *
  * Identifies technical and external dependencies in PRD content.
  * Helps surface hidden requirements and blockers.
  */
 export class DependencyIdentifier extends BasePattern {
+    // -------------------------------------------------------------------------
+    // Pattern Metadata (v4.5 unified types)
+    // -------------------------------------------------------------------------
     id = 'dependency-identifier';
-    name = 'DependencyIdentifier';
+    name = 'Dependency Identifier';
     description = 'Identifies technical and external dependencies';
     applicableIntents = ['prd-generation', 'planning', 'migration'];
     mode = 'deep';
-    priority = 5;
+    priority = 5; // MEDIUM-LOW - supplementary
+    phases = ['question-validation', 'output-generation'];
+    // -------------------------------------------------------------------------
+    // Configuration Schema (v4.5)
+    // -------------------------------------------------------------------------
+    static configSchema = {
+        categorizeDependencies: {
+            type: 'boolean',
+            default: true,
+            description: 'Separate technical from external dependencies',
+        },
+    };
+    // -------------------------------------------------------------------------
+    // Pattern Application
+    // -------------------------------------------------------------------------
     apply(prompt, _context) {
         // Check if dependencies are already documented
         if (this.hasDependencySection(prompt)) {

package/dist/core/intelligence/patterns/domain-context-enricher.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';
 /**
- * DomainContextEnricher Pattern (v4.1)
+ * v4.5 Pattern: Domain Context Enricher
  *
  * Adds domain-specific context and best practices based on detected
  * technical domain. Helps agents apply domain expertise.
  */
 export declare class DomainContextEnricher extends BasePattern {
-    id: string;
-    name: string;
-    description: string;
-    applicableIntents: PromptIntent[];
-    mode: 'fast' | 'deep' | 'both';
-    priority: number;
+    readonly id = "domain-context-enricher";
+    readonly name = "Domain Context Enricher";
+    readonly description = "Adds domain-specific best practices and context";
+    readonly applicableIntents: PromptIntent[];
+    readonly mode: PatternMode;
+    readonly priority: PatternPriority;
+    readonly phases: PatternPhase[];
+    static readonly configSchema: PatternConfigSchema;
     private domainPatterns;
     apply(prompt: string, _context: PatternContext): PatternResult;
 }

package/dist/core/intelligence/patterns/domain-context-enricher.js

@@ -1,11 +1,14 @@
-import { BasePattern } from './base-pattern.js';
+import { BasePattern, } from './base-pattern.js';
 /**
- * DomainContextEnricher Pattern (v4.1)
+ * v4.5 Pattern: Domain Context Enricher
  *
  * Adds domain-specific context and best practices based on detected
  * technical domain. Helps agents apply domain expertise.
  */
 export class DomainContextEnricher extends BasePattern {
+    // -------------------------------------------------------------------------
+    // Pattern Metadata (v4.5 unified types)
+    // -------------------------------------------------------------------------
     id = 'domain-context-enricher';
     name = 'Domain Context Enricher';
     description = 'Adds domain-specific best practices and context';
@@ -19,7 +22,28 @@ export class DomainContextEnricher extends BasePattern {
         'migration',
     ];
     mode = 'both';
-    priority = 5; // Medium priority
+    priority = 5; // MEDIUM-LOW - supplementary
+    phases = ['all'];
+    // -------------------------------------------------------------------------
+    // Configuration Schema (v4.5)
+    // -------------------------------------------------------------------------
+    static configSchema = {
+        maxDomains: {
+            type: 'number',
+            default: 2,
+            description: 'Maximum number of domains to detect',
+            validation: { min: 1, max: 4 },
+        },
+        practicesPerDomain: {
+            type: 'number',
+            default: 3,
+            description: 'Number of best practices per domain',
+            validation: { min: 1, max: 6 },
+        },
+    };
+    // -------------------------------------------------------------------------
+    // Pattern Data
+    // -------------------------------------------------------------------------
     // Domain detection patterns
     domainPatterns = {
         authentication: {

package/dist/core/intelligence/patterns/edge-case-identifier.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: Edge Case Identifier
+ * v4.5 Pattern: Edge Case Identifier
  *
  * Identifies potential edge cases by domain/intent to ensure
  * comprehensive requirement coverage.
  */
 export declare class EdgeCaseIdentifier extends BasePattern {
-    id: string;
-    name: string;
-    description: string;
-    applicableIntents: PromptIntent[];
-    mode: "deep";
-    priority: number;
+    readonly id = "edge-case-identifier";
+    readonly name = "Edge Case Identifier";
+    readonly description = "Identify potential edge cases and failure modes by domain";
+    readonly applicableIntents: PromptIntent[];
+    readonly mode: PatternMode;
+    readonly priority: PatternPriority;
+    readonly phases: PatternPhase[];
+    static readonly configSchema: PatternConfigSchema;
     apply(prompt: string, context: PatternContext): PatternResult;
     private identifyEdgeCases;
     private getGeneralEdgeCases;

package/dist/core/intelligence/patterns/edge-case-identifier.js

@@ -1,11 +1,14 @@
-import { BasePattern } from './base-pattern.js';
+import { BasePattern, } from './base-pattern.js';
 /**
- * v4.0 Deep Mode Pattern: Edge Case Identifier
+ * v4.5 Pattern: Edge Case Identifier
  *
  * Identifies potential edge cases by domain/intent to ensure
  * comprehensive requirement coverage.
  */
 export class EdgeCaseIdentifier extends BasePattern {
+    // -------------------------------------------------------------------------
+    // Pattern Metadata (v4.5 unified types)
+    // -------------------------------------------------------------------------
     id = 'edge-case-identifier';
     name = 'Edge Case Identifier';
     description = 'Identify potential edge cases and failure modes by domain';
@@ -17,7 +20,22 @@ export class EdgeCaseIdentifier extends BasePattern {
         'security-review',
     ];
     mode = 'deep';
-    priority = 4;
+    priority = 4; // LOW - polish phase
+    phases = ['all'];
+    // -------------------------------------------------------------------------
+    // Configuration Schema (v4.5)
+    // -------------------------------------------------------------------------
+    static configSchema = {
+        maxEdgeCases: {
+            type: 'number',
+            default: 8,
+            description: 'Maximum number of edge cases to identify',
+            validation: { min: 1, max: 15 },
+        },
+    };
+    // -------------------------------------------------------------------------
+    // Pattern Application
+    // -------------------------------------------------------------------------
     apply(prompt, context) {
         const edgeCases = this.identifyEdgeCases(prompt, context.intent.primaryIntent);
         if (edgeCases.length === 0) {

package/dist/core/intelligence/patterns/error-tolerance-enhancer.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';
 /**
- * ErrorToleranceEnhancer Pattern (v4.1)
+ * v4.5 Pattern: Error Tolerance Enhancer
  *
  * Adds error handling requirements and considerations to prompts.
  * Ensures implementations are robust and handle failure gracefully.
  */
 export declare class ErrorToleranceEnhancer extends BasePattern {
-    id: string;
-    name: string;
-    description: string;
-    applicableIntents: PromptIntent[];
-    mode: 'fast' | 'deep' | 'both';
-    priority: number;
+    readonly id = "error-tolerance-enhancer";
+    readonly name = "Error Tolerance Enhancer";
+    readonly description = "Adds error handling requirements and failure mode considerations";
+    readonly applicableIntents: PromptIntent[];
+    readonly mode: PatternMode;
+    readonly priority: PatternPriority;
+    readonly phases: PatternPhase[];
+    static readonly configSchema: PatternConfigSchema;
     private errorIndicators;
     private errorScenarios;
     apply(prompt: string, _context: PatternContext): PatternResult;

package/dist/core/intelligence/patterns/error-tolerance-enhancer.js

@@ -1,11 +1,14 @@
-import { BasePattern } from './base-pattern.js';
+import { BasePattern, } from './base-pattern.js';
 /**
- * ErrorToleranceEnhancer Pattern (v4.1)
+ * v4.5 Pattern: Error Tolerance Enhancer
  *
  * Adds error handling requirements and considerations to prompts.
  * Ensures implementations are robust and handle failure gracefully.
  */
 export class ErrorToleranceEnhancer extends BasePattern {
+    // -------------------------------------------------------------------------
+    // Pattern Metadata (v4.5 unified types)
+    // -------------------------------------------------------------------------
     id = 'error-tolerance-enhancer';
     name = 'Error Tolerance Enhancer';
     description = 'Adds error handling requirements and failure mode considerations';
@@ -16,8 +19,23 @@ export class ErrorToleranceEnhancer extends BasePattern {
         'migration',
         'testing',
     ];
-    mode = 'deep'; // Only in deep mode for comprehensive analysis
-    priority = 5; // Medium priority
+    mode = 'deep';
+    priority = 5; // MEDIUM-LOW - supplementary
+    phases = ['all'];
+    // -------------------------------------------------------------------------
+    // Configuration Schema (v4.5)
+    // -------------------------------------------------------------------------
+    static configSchema = {
+        maxErrorScenarios: {
+            type: 'number',
+            default: 6,
+            description: 'Maximum number of error scenarios to surface',
+            validation: { min: 1, max: 10 },
+        },
+    };
+    // -------------------------------------------------------------------------
+    // Pattern Data
+    // -------------------------------------------------------------------------
     // Indicators that error handling is already addressed
     errorIndicators = [
         'error handling',

package/dist/core/intelligence/patterns/implicit-requirement-extractor.d.ts

@@ -1,20 +1,24 @@
-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: ImplicitRequirementExtractor
+ * v4.5 Pattern: Implicit Requirement Extractor
  *
  * Surfaces requirements mentioned indirectly in conversations.
  * Identifies hidden assumptions and unstated needs.
+ * Enhanced with more detection patterns and categorization.
  */
 export declare class ImplicitRequirementExtractor extends BasePattern {
-    id: string;
-    name: string;
-    description: string;
-    applicableIntents: PromptIntent[];
-    mode: OptimizationMode | 'both';
-    priority: number;
+    readonly id = "implicit-requirement-extractor";
+    readonly name = "Implicit Requirement Extractor";
+    readonly description = "Surfaces requirements mentioned indirectly";
+    readonly applicableIntents: PromptIntent[];
+    readonly mode: PatternMode;
+    readonly priority: PatternPriority;
+    readonly phases: PatternPhase[];
+    static readonly configSchema: PatternConfigSchema;
+    private readonly implicitPatterns;
     apply(prompt: string, _context: PatternContext): PatternResult;
     private extractImplicitRequirements;
-    private addImplicitRequirements;
+    private addImplicitRequirementsSection;
 }
 //# sourceMappingURL=implicit-requirement-extractor.d.ts.map