clavix 4.2.0 → 4.3.2

package/dist/core/conversation-quality-tracker.js

@@ -0,0 +1,195 @@
+/**
+ * v4.3.2: Conversation Quality Tracker
+ *
+ * Implements the "Supportive Companion" UX pattern for conversational mode.
+ * Silently tracks quality, provides positive reinforcement, and gentle guidance.
+ */
+/**
+ * ConversationQualityTracker - "Supportive Companion" UX
+ *
+ * Design principles:
+ * - Silent tracking during normal flow
+ * - Celebrate progress, don't criticize gaps
+ * - Gentle nudge only for critical issues (max 1 per session)
+ * - Always reassure that Clavix will help
+ */
+export class ConversationQualityTracker {
+    topics = new Map();
+    messageCount = 0;
+    hasNudged = false;
+    lastCheckpointAt = 0;
+    // Topic detection keywords
+    TOPIC_KEYWORDS = {
+        features: ['feature', 'functionality', 'should', 'must', 'need', 'want', 'capability'],
+        'tech stack': [
+            'react',
+            'node',
+            'typescript',
+            'python',
+            'database',
+            'api',
+            'backend',
+            'frontend',
+        ],
+        constraints: [
+            'constraint',
+            'limitation',
+            'budget',
+            'timeline',
+            'deadline',
+            'must not',
+            'cannot',
+        ],
+        users: ['user', 'customer', 'audience', 'persona', 'who will'],
+        goals: ['goal', 'objective', 'purpose', 'why', 'problem', 'solve'],
+        scope: ['scope', 'out of scope', 'not include', 'exclude', 'later', 'mvp'],
+        success: ['success', 'metric', 'kpi', 'measure', 'criteria'],
+        design: ['design', 'ui', 'ux', 'layout', 'interface', 'look'],
+    };
+    // Critical gaps that warrant a nudge (only if quality < 40%)
+    CRITICAL_TOPICS = ['features', 'goals'];
+    /**
+     * Track a new message (silent analysis)
+     */
+    trackMessage(content) {
+        this.messageCount++;
+        this.analyzeTopics(content);
+    }
+    /**
+     * Get positive checkpoint message (call after ~5 messages or on "status")
+     * Returns null if not time for a checkpoint
+     */
+    getPositiveCheckpoint() {
+        // Only show checkpoint every 5 messages
+        if (this.messageCount < 5 || this.messageCount - this.lastCheckpointAt < 5) {
+            return null;
+        }
+        this.lastCheckpointAt = this.messageCount;
+        const coveredTopics = this.getCoveredTopics();
+        if (coveredTopics.length === 0) {
+            return null;
+        }
+        // Format covered topics nicely
+        const topicList = coveredTopics.slice(0, 3).join(', ');
+        return `📝 Shaping up nicely! Covered: ${topicList}. Continue or /summarize anytime.`;
+    }
+    /**
+     * Check if a gentle nudge is needed (max 1 per session, only for critical gaps)
+     */
+    shouldNudge() {
+        // Only nudge once per session
+        if (this.hasNudged) {
+            return { shouldNudge: false };
+        }
+        // Only nudge after a few messages
+        if (this.messageCount < 3) {
+            return { shouldNudge: false };
+        }
+        // Only nudge if quality is low
+        const quality = this.calculateQuality();
+        if (quality.overallCompleteness >= 40) {
+            return { shouldNudge: false };
+        }
+        // Find critical gap
+        const criticalGap = this.findCriticalGap();
+        if (!criticalGap) {
+            return { shouldNudge: false };
+        }
+        // Mark that we've nudged
+        this.hasNudged = true;
+        return {
+            shouldNudge: true,
+            gap: criticalGap,
+            message: `💡 One thought: a note about ${criticalGap} would help. No worries—Clavix will fill gaps when you summarize.`,
+        };
+    }
+    /**
+     * Get reassuring end-of-session message
+     */
+    getEndMessage() {
+        const coveredTopics = this.getCoveredTopics();
+        if (coveredTopics.length === 0) {
+            return '✨ Session recorded! Clavix Intelligence will help structure your requirements.';
+        }
+        if (coveredTopics.length >= 3) {
+            return '✨ Great session! You covered several key areas. Clavix Intelligence will enhance your summary.';
+        }
+        return '✨ Great session! Clavix Intelligence will enhance your summary with any missing pieces.';
+    }
+    /**
+     * Get current quality metrics (for internal use)
+     */
+    calculateQuality() {
+        const topics = Array.from(this.topics.values());
+        // Calculate completeness based on covered topics
+        const totalPossibleTopics = Object.keys(this.TOPIC_KEYWORDS).length;
+        const coveredCount = topics.filter((t) => t.confidence >= 30).length;
+        const overallCompleteness = Math.min(100, Math.round((coveredCount / totalPossibleTopics) * 100));
+        // Estimate ambiguity (higher if fewer topics covered with low confidence)
+        const avgConfidence = topics.length > 0 ? topics.reduce((sum, t) => sum + t.confidence, 0) / topics.length : 0;
+        const ambiguityLevel = Math.max(0, 100 - avgConfidence);
+        return {
+            topics,
+            overallCompleteness,
+            ambiguityLevel,
+            messageCount: this.messageCount,
+        };
+    }
+    /**
+     * Get list of covered topics (user-friendly names)
+     */
+    getCoveredTopics() {
+        return Array.from(this.topics.values())
+            .filter((t) => t.confidence >= 30)
+            .sort((a, b) => b.confidence - a.confidence)
+            .map((t) => t.name);
+    }
+    /**
+     * Find a critical gap to nudge about
+     */
+    findCriticalGap() {
+        for (const topic of this.CRITICAL_TOPICS) {
+            const tracked = this.topics.get(topic);
+            if (!tracked || tracked.confidence < 20) {
+                return topic;
+            }
+        }
+        return null;
+    }
+    /**
+     * Analyze message content for topic coverage
+     */
+    analyzeTopics(content) {
+        const lowerContent = content.toLowerCase();
+        for (const [topic, keywords] of Object.entries(this.TOPIC_KEYWORDS)) {
+            const matchedKeywords = keywords.filter((kw) => lowerContent.includes(kw));
+            if (matchedKeywords.length > 0) {
+                const existing = this.topics.get(topic);
+                const confidence = Math.min(100, matchedKeywords.length * 25 + (existing?.confidence || 0));
+                this.topics.set(topic, {
+                    name: topic,
+                    confidence,
+                    firstMentioned: existing?.firstMentioned || this.messageCount,
+                });
+            }
+        }
+    }
+    /**
+     * Reset tracker for new session
+     */
+    reset() {
+        this.topics.clear();
+        this.messageCount = 0;
+        this.hasNudged = false;
+        this.lastCheckpointAt = 0;
+    }
+    /**
+     * Get summary for debugging/logging
+     */
+    getSummary() {
+        const quality = this.calculateQuality();
+        const topics = this.getCoveredTopics();
+        return `Messages: ${this.messageCount}, Topics: [${topics.join(', ')}], Completeness: ${quality.overallCompleteness}%`;
+    }
+}
+//# sourceMappingURL=conversation-quality-tracker.js.map

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

@@ -306,6 +306,8 @@ export class IntentDetector {
             migration: this.calculateIntentScore(lowerPrompt, words, 'migration'),
             'security-review': this.calculateIntentScore(lowerPrompt, words, 'security-review'),
             learning: this.calculateIntentScore(lowerPrompt, words, 'learning'),
+            // v4.3.2: Conversational mode intent
+            summarization: 0, // Summarization is explicit command, not inferred
         };
         // Apply intent priority rules
         const primaryIntent = this.selectPrimaryIntent(scores, lowerPrompt);
@@ -685,6 +687,7 @@ export class IntentDetector {
             migration: this.calculateIntentScore(lowerPrompt, words, 'migration'),
             'security-review': this.calculateIntentScore(lowerPrompt, words, 'security-review'),
             learning: this.calculateIntentScore(lowerPrompt, words, 'learning'),
+            summarization: 0, // v4.3.2: Explicit command
         };
         // Get secondary intents (top 2-3 after primary, with score > 10)
         const secondaryIntents = this.getSecondaryIntents(scores, basicAnalysis.primaryIntent);

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

@@ -1,5 +1,5 @@
 import { BasePattern } from './patterns/base-pattern.js';
-import { IntentAnalysis, OptimizationMode } from './types.js';
+import { IntentAnalysis, OptimizationMode, OptimizationPhase } from './types.js';
 export declare class PatternLibrary {
     private patterns;
     constructor();
@@ -28,6 +28,23 @@ export declare class PatternLibrary {
      * Select applicable patterns for the given context
      */
     selectPatterns(intent: IntentAnalysis, mode: OptimizationMode): BasePattern[];
+    /**
+     * v4.3.2: 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
+     */
+    private mapToBaseMode;
+    /**
+     * Check if pattern is applicable for PRD phase
+     */
+    private isPatternApplicableForPRDPhase;
+    /**
+     * Check if pattern is applicable for conversational phase
+     */
+    private isPatternApplicableForConversationalPhase;
     /**
      * Get all registered patterns
      */

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

@@ -21,6 +21,15 @@ import { SuccessCriteriaEnforcer } from './patterns/success-criteria-enforcer.js
 import { ErrorToleranceEnhancer } from './patterns/error-tolerance-enhancer.js';
 import { PrerequisiteIdentifier } from './patterns/prerequisite-identifier.js';
 import { DomainContextEnricher } from './patterns/domain-context-enricher.js';
+// v4.3.2 PRD patterns
+import { RequirementPrioritizer } from './patterns/requirement-prioritizer.js';
+import { UserPersonaEnricher } from './patterns/user-persona-enricher.js';
+import { SuccessMetricsEnforcer } from './patterns/success-metrics-enforcer.js';
+import { DependencyIdentifier } from './patterns/dependency-identifier.js';
+// v4.3.2 Conversational patterns
+import { ConversationSummarizer } from './patterns/conversation-summarizer.js';
+import { TopicCoherenceAnalyzer } from './patterns/topic-coherence-analyzer.js';
+import { ImplicitRequirementExtractor } from './patterns/implicit-requirement-extractor.js';
 export class PatternLibrary {
     patterns = new Map();
     constructor() {
@@ -51,6 +60,15 @@ export class PatternLibrary {
         this.register(new ErrorToleranceEnhancer()); // P5 - Add error handling (deep only)
         this.register(new PrerequisiteIdentifier()); // P6 - Identify prerequisites (deep only)
         this.register(new DomainContextEnricher()); // P5 - Add domain best practices (both modes)
+        // v4.3.2 PRD patterns
+        this.register(new RequirementPrioritizer()); // P7 - Separate must-have from nice-to-have
+        this.register(new UserPersonaEnricher()); // P6 - Add user context and personas
+        this.register(new SuccessMetricsEnforcer()); // P7 - Ensure measurable success criteria
+        this.register(new DependencyIdentifier()); // P5 - Identify technical/external dependencies
+        // v4.3.2 Conversational patterns
+        this.register(new ConversationSummarizer()); // P8 - Extract structured requirements
+        this.register(new TopicCoherenceAnalyzer()); // P6 - Detect topic shifts
+        this.register(new ImplicitRequirementExtractor()); // P7 - Surface implicit requirements
     }
     /**
      * Register a new pattern
@@ -102,6 +120,119 @@ export class PatternLibrary {
         // Sort by priority (highest first)
         return applicablePatterns.sort((a, b) => b.priority - a.priority);
     }
+    /**
+     * v4.3.2: Select patterns for specific mode with phase-awareness
+     * Maps PRD and conversational modes to appropriate base modes and patterns
+     */
+    selectPatternsForMode(mode, intent, phase) {
+        // Map PRD/conversational modes to base modes for pattern selection
+        const baseMode = this.mapToBaseMode(mode, phase);
+        const applicablePatterns = [];
+        for (const pattern of this.patterns.values()) {
+            // Check mode compatibility (use mapped base mode)
+            if (pattern.mode !== 'both' && pattern.mode !== baseMode) {
+                continue;
+            }
+            // Check intent compatibility
+            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;
+                }
+            }
+            applicablePatterns.push(pattern);
+        }
+        // Sort by priority (highest first)
+        return applicablePatterns.sort((a, b) => b.priority - a.priority);
+    }
+    /**
+     * Map extended modes to base modes for pattern compatibility
+     */
+    mapToBaseMode(mode, phase) {
+        switch (mode) {
+            case 'prd':
+                // PRD uses deep mode for output generation, fast for validation
+                return phase === 'question-validation' ? 'fast' : 'deep';
+            case 'conversational':
+                // Conversational uses fast mode for tracking, deep for summarization
+                return phase === 'summarization' ? 'deep' : 'fast';
+            case 'fast':
+            case 'deep':
+            default:
+                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/conversation-summarizer.d.ts

@@ -0,0 +1,25 @@
+import { BasePattern } from './base-pattern.js';
+import { PromptIntent, OptimizationMode, PatternContext, PatternResult } from '../types.js';
+/**
+ * v4.3.2 Conversational Pattern: ConversationSummarizer
+ *
+ * Extracts structured requirements from conversational messages.
+ * Organizes free-form discussion into actionable requirements.
+ */
+export declare class ConversationSummarizer extends BasePattern {
+    id: string;
+    name: string;
+    description: string;
+    applicableIntents: PromptIntent[];
+    mode: OptimizationMode | 'both';
+    priority: number;
+    apply(prompt: string, _context: PatternContext): PatternResult;
+    private isAlreadyStructured;
+    private isConversationalContent;
+    private extractAndStructure;
+    private extractRequirements;
+    private extractConstraints;
+    private extractGoals;
+    private cleanRequirement;
+}
+//# sourceMappingURL=conversation-summarizer.d.ts.map

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

@@ -0,0 +1,197 @@
+import { BasePattern } from './base-pattern.js';
+/**
+ * v4.3.2 Conversational Pattern: ConversationSummarizer
+ *
+ * Extracts structured requirements from conversational messages.
+ * Organizes free-form discussion into actionable requirements.
+ */
+export class ConversationSummarizer extends BasePattern {
+    id = 'conversation-summarizer';
+    name = 'ConversationSummarizer';
+    description = 'Extracts structured requirements from messages';
+    applicableIntents = ['summarization', 'planning', 'prd-generation'];
+    mode = 'deep';
+    priority = 8;
+    apply(prompt, _context) {
+        // Check if content is already well-structured
+        if (this.isAlreadyStructured(prompt)) {
+            return {
+                enhancedPrompt: prompt,
+                improvement: {
+                    dimension: 'structure',
+                    description: 'Content already well-structured',
+                    impact: 'low',
+                },
+                applied: false,
+            };
+        }
+        // Check if this looks like conversational content
+        if (!this.isConversationalContent(prompt)) {
+            return {
+                enhancedPrompt: prompt,
+                improvement: {
+                    dimension: 'structure',
+                    description: 'Not conversational content',
+                    impact: 'low',
+                },
+                applied: false,
+            };
+        }
+        // Extract and structure requirements
+        const enhanced = this.extractAndStructure(prompt);
+        return {
+            enhancedPrompt: enhanced,
+            improvement: {
+                dimension: 'structure',
+                description: 'Extracted structured requirements from conversation',
+                impact: 'high',
+            },
+            applied: true,
+        };
+    }
+    isAlreadyStructured(prompt) {
+        // Check for markdown structure
+        const structureIndicators = [
+            '##',
+            '###',
+            '**Requirements:**',
+            '**Features:**',
+            '- [ ]',
+            '1.',
+            '2.',
+            '3.',
+        ];
+        const matches = structureIndicators.filter((indicator) => prompt.includes(indicator));
+        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));
+        // Also check for lack of structure (sentences without bullet points)
+        const sentences = this.extractSentences(prompt);
+        const hasBulletPoints = prompt.includes('- ') || prompt.includes('* ');
+        return matches.length >= 2 || (sentences.length > 3 && !hasBulletPoints);
+    }
+    extractAndStructure(prompt) {
+        const requirements = this.extractRequirements(prompt);
+        const constraints = this.extractConstraints(prompt);
+        const goals = this.extractGoals(prompt);
+        let structured = '### Extracted Requirements\n\n';
+        if (goals.length > 0) {
+            structured += '**Goals:**\n';
+            structured += goals.map((g) => `- ${g}`).join('\n');
+            structured += '\n\n';
+        }
+        if (requirements.length > 0) {
+            structured += '**Requirements:**\n';
+            structured += requirements.map((r) => `- ${r}`).join('\n');
+            structured += '\n\n';
+        }
+        if (constraints.length > 0) {
+            structured += '**Constraints:**\n';
+            structured += constraints.map((c) => `- ${c}`).join('\n');
+            structured += '\n\n';
+        }
+        structured += '---\n\n**Original Context:**\n' + prompt;
+        return structured;
+    }
+    extractRequirements(prompt) {
+        const requirements = [];
+        const sentences = this.extractSentences(prompt);
+        const requirementPatterns = [
+            /(?:need|want|should|must|require)\s+(?:to\s+)?(.+)/i,
+            /(?:should be able to|needs to)\s+(.+)/i,
+            /(?:feature|functionality):\s*(.+)/i,
+        ];
+        for (const sentence of sentences) {
+            for (const pattern of requirementPatterns) {
+                const match = sentence.match(pattern);
+                if (match && match[1]) {
+                    const req = this.cleanRequirement(match[1]);
+                    if (req && !requirements.includes(req)) {
+                        requirements.push(req);
+                    }
+                }
+            }
+        }
+        return requirements.slice(0, 10); // Max 10 requirements
+    }
+    extractConstraints(prompt) {
+        const constraints = [];
+        const lowerPrompt = prompt.toLowerCase();
+        const constraintPatterns = [
+            /(?:can't|cannot|shouldn't|must not)\s+(.+)/gi,
+            /(?:limited to|restricted to|only)\s+(.+)/gi,
+            /(?:within|budget|deadline|timeline):\s*(.+)/gi,
+            /(?:no more than|at most|maximum)\s+(.+)/gi,
+        ];
+        for (const pattern of constraintPatterns) {
+            const matches = prompt.matchAll(pattern);
+            for (const match of matches) {
+                if (match[1]) {
+                    const constraint = this.cleanRequirement(match[1]);
+                    if (constraint && !constraints.includes(constraint)) {
+                        constraints.push(constraint);
+                    }
+                }
+            }
+        }
+        // Common constraint keywords
+        if (lowerPrompt.includes('performance')) {
+            constraints.push('Performance requirements to be defined');
+        }
+        if (lowerPrompt.includes('security')) {
+            constraints.push('Security requirements to be defined');
+        }
+        if (lowerPrompt.includes('mobile') && lowerPrompt.includes('desktop')) {
+            constraints.push('Must work on both mobile and desktop');
+        }
+        return constraints.slice(0, 5); // Max 5 constraints
+    }
+    extractGoals(prompt) {
+        const goals = [];
+        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,
+        ];
+        for (const pattern of goalPatterns) {
+            const matches = prompt.matchAll(pattern);
+            for (const match of matches) {
+                if (match[1]) {
+                    const goal = this.cleanRequirement(match[1]);
+                    if (goal && !goals.includes(goal)) {
+                        goals.push(goal);
+                    }
+                }
+            }
+        }
+        return goals.slice(0, 3); // Max 3 goals
+    }
+    cleanRequirement(text) {
+        return text
+            .trim()
+            .replace(/[.!?,;:]+$/, '')
+            .replace(/\s+/g, ' ')
+            .substring(0, 200);
+    }
+}
+//# sourceMappingURL=conversation-summarizer.js.map

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

@@ -0,0 +1,21 @@
+import { BasePattern } from './base-pattern.js';
+import { PromptIntent, OptimizationMode, PatternContext, PatternResult } from '../types.js';
+/**
+ * v4.3.2 PRD Pattern: DependencyIdentifier
+ *
+ * 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;
+    apply(prompt: string, _context: PatternContext): PatternResult;
+    private hasDependencySection;
+    private identifyDependencies;
+    private addDependencySection;
+}
+//# sourceMappingURL=dependency-identifier.d.ts.map