clavix 4.3.1 → 4.3.2

package/dist/core/intelligence/patterns/user-persona-enricher.js

@@ -0,0 +1,124 @@
+import { BasePattern } from './base-pattern.js';
+/**
+ * v4.3.2 PRD Pattern: UserPersonaEnricher
+ *
+ * Adds missing user context and personas to PRD content.
+ * Ensures the "who" is clearly defined alongside the "what".
+ */
+export class UserPersonaEnricher extends BasePattern {
+    id = 'user-persona-enricher';
+    name = 'UserPersonaEnricher';
+    description = 'Adds missing user context and personas';
+    applicableIntents = ['prd-generation', 'planning'];
+    mode = 'deep';
+    priority = 6;
+    apply(prompt, _context) {
+        // Check if user/persona context already exists
+        if (this.hasUserContext(prompt)) {
+            return {
+                enhancedPrompt: prompt,
+                improvement: {
+                    dimension: 'completeness',
+                    description: 'User context already present',
+                    impact: 'low',
+                },
+                applied: false,
+            };
+        }
+        // Check if this is PRD-like content that needs users
+        if (!this.needsUserContext(prompt)) {
+            return {
+                enhancedPrompt: prompt,
+                improvement: {
+                    dimension: 'completeness',
+                    description: 'Content does not require user persona',
+                    impact: 'low',
+                },
+                applied: false,
+            };
+        }
+        // Add user persona section
+        const enhanced = this.addUserPersona(prompt);
+        return {
+            enhancedPrompt: enhanced,
+            improvement: {
+                dimension: 'completeness',
+                description: 'Added user persona context (who will use this)',
+                impact: 'medium',
+            },
+            applied: true,
+        };
+    }
+    hasUserContext(prompt) {
+        const userKeywords = [
+            'user persona',
+            'target user',
+            'end user',
+            'user profile',
+            'audience',
+            'stakeholder',
+            'as a user',
+            'users can',
+            'users will',
+            'for users',
+            'customer',
+            'developer',
+            'admin',
+            'target audience',
+        ];
+        return this.hasSection(prompt, userKeywords);
+    }
+    needsUserContext(prompt) {
+        // PRD-like content that talks about features but not users
+        const featureKeywords = [
+            'feature',
+            'build',
+            'create',
+            'implement',
+            'functionality',
+            'should',
+            'must',
+            'requirement',
+        ];
+        return this.hasSection(prompt, featureKeywords);
+    }
+    addUserPersona(prompt) {
+        // Detect the likely user type from content
+        const userType = this.inferUserType(prompt);
+        const personaSection = `\n\n### Target Users\n` +
+            `**Primary User:** ${userType}\n` +
+            `- Goals: [What they want to achieve]\n` +
+            `- Pain Points: [Current frustrations]\n` +
+            `- Context: [When and how they'll use this]`;
+        return prompt + personaSection;
+    }
+    inferUserType(prompt) {
+        const lowerPrompt = prompt.toLowerCase();
+        // Try to infer user type from content
+        if (lowerPrompt.includes('api') ||
+            lowerPrompt.includes('sdk') ||
+            lowerPrompt.includes('library')) {
+            return 'Developers integrating with the system';
+        }
+        if (lowerPrompt.includes('admin') ||
+            lowerPrompt.includes('manage') ||
+            lowerPrompt.includes('dashboard')) {
+            return 'Administrators managing the system';
+        }
+        if (lowerPrompt.includes('e-commerce') ||
+            lowerPrompt.includes('shop') ||
+            lowerPrompt.includes('buy')) {
+            return 'Customers making purchases';
+        }
+        if (lowerPrompt.includes('content') ||
+            lowerPrompt.includes('blog') ||
+            lowerPrompt.includes('cms')) {
+            return 'Content creators and editors';
+        }
+        if (lowerPrompt.includes('mobile') || lowerPrompt.includes('app')) {
+            return 'Mobile app users';
+        }
+        return '[Define primary user type]';
+    }
+}
+//# sourceMappingURL=user-persona-enricher.js.map

package/dist/core/intelligence/quality-assessor.js

@@ -11,6 +11,8 @@ export class QualityAssessor {
         'security-review': ['scope', 'threat-model', 'compliance-requirements', 'known-issues'],
         learning: ['current-knowledge', 'learning-goal', 'preferred-depth', 'context'],
         'prd-generation': ['product-vision', 'user-personas', 'features', 'success-metrics'],
+        // v4.3.2: Conversational mode intent
+        summarization: ['conversation-context', 'key-requirements', 'constraints', 'success-criteria'],
     };
     /**
      * Assess quality of a prompt (backward compatibility wrapper)

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

@@ -1,7 +1,9 @@
-export type PromptIntent = 'code-generation' | 'planning' | 'refinement' | 'debugging' | 'documentation' | 'prd-generation' | 'testing' | 'migration' | 'security-review' | 'learning';
+export type PromptIntent = 'code-generation' | 'planning' | 'refinement' | 'debugging' | 'documentation' | 'prd-generation' | 'testing' | 'migration' | 'security-review' | 'learning' | 'summarization';
 export type QualityDimension = 'clarity' | 'efficiency' | 'structure' | 'completeness' | 'actionability' | 'specificity';
 export type ImpactLevel = 'low' | 'medium' | 'high';
-export type OptimizationMode = 'fast' | 'deep';
+export type OptimizationMode = 'fast' | 'deep' | 'prd' | 'conversational';
+export type OptimizationPhase = 'question-validation' | 'output-generation' | 'conversation-tracking' | 'summarization';
+export type DocumentType = 'full-prd' | 'quick-prd' | 'mini-prd' | 'prompt';
 export interface IntentAnalysis {
     primaryIntent: PromptIntent;
     confidence: number;
@@ -55,6 +57,9 @@ export interface PatternContext {
     intent: IntentAnalysis;
     mode: OptimizationMode;
     originalPrompt: string;
+    phase?: OptimizationPhase;
+    documentType?: DocumentType;
+    questionId?: string;
 }
 export interface PatternResult {
     enhancedPrompt: string;

package/dist/core/intelligence/universal-optimizer.d.ts

@@ -1,7 +1,16 @@
 import { IntentDetector } from './intent-detector.js';
 import { PatternLibrary } from './pattern-library.js';
 import { QualityAssessor } from './quality-assessor.js';
-import { OptimizationResult, OptimizationMode, EscalationAnalysis } from './types.js';
+import { OptimizationResult, OptimizationMode, OptimizationPhase, DocumentType, EscalationAnalysis } from './types.js';
+/**
+ * v4.3.2: Extended context options for PRD and Conversational modes
+ */
+export interface OptimizationContextOverride {
+    phase?: OptimizationPhase;
+    documentType?: DocumentType;
+    questionId?: string;
+    intent?: string;
+}
 export declare class UniversalOptimizer {
     private intentDetector;
     private patternLibrary;
@@ -9,8 +18,24 @@ export declare class UniversalOptimizer {
     constructor(intentDetector?: IntentDetector, patternLibrary?: PatternLibrary, qualityAssessor?: QualityAssessor);
     /**
      * Optimize a prompt using Clavix Intelligence
+     * @param prompt The prompt to optimize
+     * @param mode The optimization mode
+     * @param contextOverride Optional context override for PRD/Conversational modes
+     */
+    optimize(prompt: string, mode: OptimizationMode, contextOverride?: OptimizationContextOverride): Promise<OptimizationResult>;
+    /**
+     * v4.3.2: Validate a PRD answer and provide friendly suggestions
+     * Uses adaptive threshold (< 50% quality triggers suggestions)
+     */
+    validatePRDAnswer(answer: string, questionId: string): Promise<{
+        needsClarification: boolean;
+        suggestion?: string;
+        quality: number;
+    }>;
+    /**
+     * v4.3.2: Generate a friendly, non-intrusive suggestion for low-quality answers
      */
-    optimize(prompt: string, mode: OptimizationMode): Promise<OptimizationResult>;
+    private generateFriendlySuggestion;
     /**
      * Determine if deep mode should be recommended (for fast mode results)
      * @deprecated Use analyzeEscalation() for more detailed analysis

package/dist/core/intelligence/universal-optimizer.js

@@ -12,13 +12,24 @@ export class UniversalOptimizer {
     }
     /**
      * Optimize a prompt using Clavix Intelligence
+     * @param prompt The prompt to optimize
+     * @param mode The optimization mode
+     * @param contextOverride Optional context override for PRD/Conversational modes
      */
-    async optimize(prompt, mode) {
+    async optimize(prompt, mode, contextOverride) {
         const startTime = Date.now();
-        // Step 1: Detect intent
-        const intent = this.intentDetector.analyze(prompt);
-        // Step 2: Select applicable patterns
-        const patterns = this.patternLibrary.selectPatterns(intent, mode);
+        // Step 1: Detect intent (or use override)
+        let intent = this.intentDetector.analyze(prompt);
+        if (contextOverride?.intent) {
+            intent = {
+                ...intent,
+                primaryIntent: contextOverride.intent,
+            };
+        }
+        // Step 2: Select applicable patterns using mode-aware selection
+        const patterns = mode === 'prd' || mode === 'conversational'
+            ? this.patternLibrary.selectPatternsForMode(mode, intent, contextOverride?.phase)
+            : this.patternLibrary.selectPatterns(intent, mode);
         // Step 3: Apply patterns sequentially
         let enhanced = prompt;
         const improvements = [];
@@ -27,6 +38,10 @@ export class UniversalOptimizer {
             intent,
             mode,
             originalPrompt: prompt,
+            // v4.3.2: Extended context
+            phase: contextOverride?.phase,
+            documentType: contextOverride?.documentType,
+            questionId: contextOverride?.questionId,
         };
         for (const pattern of patterns) {
             try {
@@ -61,6 +76,51 @@ export class UniversalOptimizer {
             processingTimeMs,
         };
     }
+    /**
+     * v4.3.2: Validate a PRD answer and provide friendly suggestions
+     * Uses adaptive threshold (< 50% quality triggers suggestions)
+     */
+    async validatePRDAnswer(answer, questionId) {
+        const result = await this.optimize(answer, 'prd', {
+            phase: 'question-validation',
+            questionId,
+            intent: 'prd-generation',
+        });
+        // Adaptive threshold: only suggest improvements for very vague answers
+        if (result.quality.overall < 50) {
+            return {
+                needsClarification: true,
+                suggestion: this.generateFriendlySuggestion(result, questionId),
+                quality: result.quality.overall,
+            };
+        }
+        return {
+            needsClarification: false,
+            quality: result.quality.overall,
+        };
+    }
+    /**
+     * v4.3.2: Generate a friendly, non-intrusive suggestion for low-quality answers
+     */
+    generateFriendlySuggestion(result, questionId) {
+        const suggestions = {
+            q1: ["the problem you're solving", 'why this matters', 'who benefits'],
+            q2: ['specific features', 'user actions', 'key functionality'],
+            q3: ['technologies', 'frameworks', 'constraints'],
+            q4: ["what's explicitly out of scope", 'features to avoid', 'limitations'],
+            q5: ['additional context', 'constraints', 'timeline considerations'],
+        };
+        const questionSuggestions = suggestions[questionId] || suggestions.q5;
+        // Pick the most relevant suggestion based on what's missing
+        let detail = questionSuggestions[0];
+        if (result.quality.completeness < 40) {
+            detail = questionSuggestions[Math.min(1, questionSuggestions.length - 1)];
+        }
+        if (result.quality.specificity < 40) {
+            detail = questionSuggestions[Math.min(2, questionSuggestions.length - 1)];
+        }
+        return `adding ${detail} would help`;
+    }
     /**
      * Determine if deep mode should be recommended (for fast mode results)
      * @deprecated Use analyzeEscalation() for more detailed analysis

package/dist/templates/slash-commands/_canonical/deep.md

@@ -93,6 +93,7 @@ Deep mode provides **Clavix Intelligence™** with comprehensive analysis that g
    - **migration**: Version upgrades, porting code between frameworks
    - **security-review**: Security audits, vulnerability checks
    - **learning**: Conceptual understanding, tutorials, explanations
+   - **summarization**: Extracting requirements from conversations
 
 3. **Strategic Scope Detection** (before detailed analysis):
 

package/dist/templates/slash-commands/_canonical/fast.md

@@ -91,6 +91,7 @@ Clavix provides **Clavix Intelligence™** that automatically detects intent and
    - **migration**: Version upgrades, porting code between frameworks
    - **security-review**: Security audits, vulnerability checks
    - **learning**: Conceptual understanding, tutorials, explanations
+   - **summarization**: Extracting requirements from conversations
 
 3. **Quality Assessment** - Evaluate across 6 dimensions:
 

package/dist/templates/slash-commands/_components/sections/pattern-visibility.md

@@ -75,6 +75,21 @@ Patterns: 7 applied (deep mode)
 | SuccessCriteriaEnforcer | 6 | Adds measurable success criteria |
 | DomainContextEnricher | 5 | Adds domain-specific best practices |
 
+**v4.3.2 PRD Mode Patterns (deep mode):**
+| Pattern | Priority | What It Does |
+|---------|----------|--------------|
+| RequirementPrioritizer | 7 | Separates must-have from nice-to-have requirements |
+| UserPersonaEnricher | 6 | Adds missing user context and personas |
+| SuccessMetricsEnforcer | 7 | Ensures measurable success criteria exist |
+| DependencyIdentifier | 5 | Identifies technical and external dependencies |
+
+**v4.3.2 Conversational Mode Patterns (deep mode):**
+| Pattern | Priority | What It Does |
+|---------|----------|--------------|
+| ConversationSummarizer | 8 | Extracts structured requirements from messages |
+| TopicCoherenceAnalyzer | 6 | Detects topic shifts and multi-topic conversations |
+| ImplicitRequirementExtractor | 7 | Surfaces requirements mentioned indirectly |
+
 ### Pattern Selection Logic
 
 Patterns are selected based on:
@@ -109,11 +124,20 @@ Deep mode only:
   AlternativePhrasingGenerator, EdgeCaseIdentifier, ValidationChecklistCreator,
   AssumptionExplicitizer, ScopeDefiner, PRDStructureEnforcer,
   ErrorToleranceEnhancer, PrerequisiteIdentifier
+
+v4.3.2 PRD mode (deep):
+  RequirementPrioritizer, UserPersonaEnricher, SuccessMetricsEnforcer,
+  DependencyIdentifier
+
+v4.3.2 Conversational mode (deep):
+  ConversationSummarizer, TopicCoherenceAnalyzer, ImplicitRequirementExtractor
 ```
 
 ### Pattern Count by Mode
 
 | Mode | Patterns Available | Typical Applied |
 |------|-------------------|-----------------|
-| Fast | 14 core patterns | 4-7 patterns |
-| Deep | 20 total patterns | 8-14 patterns |
+| Fast | 21 core patterns | 4-7 patterns |
+| Deep | 27 total patterns | 8-14 patterns |
+| PRD | 15 patterns | 10-15 patterns |
+| Conversational | 11 patterns | 6-11 patterns |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clavix",
-  "version": "4.3.1",
+  "version": "4.3.2",
   "description": "Clavix Intelligence™ for AI coding. Automatically optimizes prompts with intent detection, quality assessment, and adaptive patterns—no framework to learn. Works with Claude Code, Cursor, Windsurf, and 19+ other AI coding tools.",
   "type": "module",
   "main": "dist/index.js",
@@ -54,7 +54,7 @@
     "requirements"
   ],
   "author": "ClavixDev",
-  "license": "MIT",
+  "license": "Apache-2.0",
   "bugs": {
     "url": "https://github.com/ClavixDev/Clavix/issues"
   },