clavix 4.3.1 → 4.4.0

package/dist/core/intelligence/patterns/implicit-requirement-extractor.js

@@ -0,0 +1,236 @@
+import { BasePattern } from './base-pattern.js';
+/**
+ * v4.4 Conversational Pattern: ImplicitRequirementExtractor
+ *
+ * Surfaces requirements mentioned indirectly in conversations.
+ * Identifies hidden assumptions and unstated needs.
+ * Enhanced with more detection patterns and categorization.
+ */
+export class ImplicitRequirementExtractor extends BasePattern {
+    id = 'implicit-requirement-extractor';
+    name = 'ImplicitRequirementExtractor';
+    description = 'Surfaces requirements mentioned indirectly';
+    applicableIntents = ['summarization', 'planning', 'prd-generation'];
+    mode = 'deep';
+    priority = 7;
+    // Categories for implicit requirements
+    implicitPatterns = [
+        // Infrastructure requirements
+        {
+            check: (p) => p.includes('mobile'),
+            requirement: 'Mobile-responsive design required',
+            category: 'infrastructure',
+        },
+        {
+            check: (p) => p.includes('real-time') || p.includes('realtime'),
+            requirement: 'Real-time updates infrastructure needed',
+            category: 'infrastructure',
+        },
+        {
+            check: (p) => p.includes('scale') || p.includes('thousands') || p.includes('millions'),
+            requirement: 'Scalability architecture required',
+            category: 'infrastructure',
+        },
+        {
+            check: (p) => p.includes('offline') || p.includes('without internet'),
+            requirement: 'Offline-capable architecture needed',
+            category: 'infrastructure',
+        },
+        {
+            check: (p) => p.includes('multi-tenant') || p.includes('multiple organizations'),
+            requirement: 'Multi-tenancy support required',
+            category: 'infrastructure',
+        },
+        // Security requirements
+        {
+            check: (p) => p.includes('secure') || p.includes('security'),
+            requirement: 'Security audit and compliance requirements',
+            category: 'security',
+        },
+        {
+            check: (p) => p.includes('gdpr') || p.includes('privacy') || p.includes('compliant'),
+            requirement: 'Data privacy and compliance infrastructure',
+            category: 'security',
+        },
+        {
+            check: (p) => p.includes('encrypt') || p.includes('sensitive'),
+            requirement: 'Data encryption requirements',
+            category: 'security',
+        },
+        // Performance requirements
+        {
+            check: (p) => p.includes('fast') || p.includes('quick'),
+            requirement: 'Performance optimization requirements',
+            category: 'performance',
+        },
+        {
+            check: (p) => p.includes('responsive') || p.includes('instant'),
+            requirement: 'Low-latency response requirements',
+            category: 'performance',
+        },
+        // UX requirements
+        {
+            check: (p) => p.includes('easy') || p.includes('simple') || p.includes('intuitive'),
+            requirement: 'User experience priority (simplicity mentioned)',
+            category: 'ux',
+        },
+        {
+            check: (p) => p.includes('accessible') || p.includes('a11y'),
+            requirement: 'Accessibility (WCAG) compliance required',
+            category: 'ux',
+        },
+        // Integration requirements
+        {
+            check: (p) => p.includes('notify') ||
+                p.includes('alert') ||
+                p.includes('email') ||
+                p.includes('notification'),
+            requirement: 'Notification system infrastructure',
+            category: 'integration',
+        },
+        {
+            check: (p) => p.includes('search') || p.includes('find'),
+            requirement: 'Search functionality and indexing',
+            category: 'integration',
+        },
+        {
+            check: (p) => p.includes('report') || p.includes('analytics') || p.includes('dashboard'),
+            requirement: 'Analytics and reporting infrastructure',
+            category: 'integration',
+        },
+        {
+            check: (p) => p.includes('integrate') || p.includes('connect') || p.includes('sync'),
+            requirement: 'Integration APIs and webhooks',
+            category: 'integration',
+        },
+        {
+            check: (p) => p.includes('import') || p.includes('export') || p.includes('csv'),
+            requirement: 'Data import/export functionality',
+            category: 'integration',
+        },
+    ];
+    apply(prompt, _context) {
+        // Extract implicit requirements
+        const implicitReqs = this.extractImplicitRequirements(prompt);
+        // If no implicit requirements found, skip
+        if (implicitReqs.length === 0) {
+            return {
+                enhancedPrompt: prompt,
+                improvement: {
+                    dimension: 'completeness',
+                    description: 'No implicit requirements detected',
+                    impact: 'low',
+                },
+                applied: false,
+            };
+        }
+        // Add implicit requirements section
+        const enhanced = this.addImplicitRequirementsSection(prompt, implicitReqs);
+        return {
+            enhancedPrompt: enhanced,
+            improvement: {
+                dimension: 'completeness',
+                description: `Surfaced ${implicitReqs.length} implicit requirements`,
+                impact: 'medium',
+            },
+            applied: true,
+        };
+    }
+    extractImplicitRequirements(prompt) {
+        const implicitReqs = [];
+        const lowerPrompt = prompt.toLowerCase();
+        // Pattern 1: "like X" implies feature parity
+        const likePatterns = prompt.matchAll(/(?:like|similar to|same as)\s+([A-Za-z0-9\s]+)/gi);
+        for (const match of likePatterns) {
+            if (match[1]) {
+                implicitReqs.push({
+                    requirement: `Feature parity with "${match[1].trim()}" (implied)`,
+                    category: 'feature',
+                });
+            }
+        }
+        // Use pattern-based detection
+        for (const pattern of this.implicitPatterns) {
+            if (pattern.check(lowerPrompt)) {
+                implicitReqs.push({
+                    requirement: pattern.requirement,
+                    category: pattern.category,
+                });
+            }
+        }
+        // Pattern: User mentions imply auth/permissions
+        if ((lowerPrompt.includes('user') || lowerPrompt.includes('admin')) &&
+            !lowerPrompt.includes('authentication')) {
+            implicitReqs.push({
+                requirement: 'User authentication system (implied by user roles)',
+                category: 'security',
+            });
+        }
+        // Pattern: Data mentions imply storage
+        if ((lowerPrompt.includes('save') ||
+            lowerPrompt.includes('store') ||
+            lowerPrompt.includes('data')) &&
+            !lowerPrompt.includes('database')) {
+            implicitReqs.push({
+                requirement: 'Data persistence/storage (implied by data operations)',
+                category: 'infrastructure',
+            });
+        }
+        // Pattern: "Always" or "never" implies validation rules
+        const alwaysNeverPatterns = prompt.matchAll(/(?:always|never|must always|must never)\s+([^.!?]+)/gi);
+        for (const match of alwaysNeverPatterns) {
+            if (match[1]) {
+                implicitReqs.push({
+                    requirement: `Business rule: "${match[1].trim()}" (implied constraint)`,
+                    category: 'business',
+                });
+            }
+        }
+        // Deduplicate by requirement text
+        const seen = new Set();
+        return implicitReqs
+            .filter((r) => {
+            if (seen.has(r.requirement))
+                return false;
+            seen.add(r.requirement);
+            return true;
+        })
+            .slice(0, 10); // Increased to 10
+    }
+    addImplicitRequirementsSection(prompt, implicitReqs) {
+        let section = '\n\n### Implicit Requirements (Inferred)\n';
+        section += '*The following requirements are implied by the discussion:*\n\n';
+        // Group by category for better organization
+        const byCategory = new Map();
+        for (const req of implicitReqs) {
+            const existing = byCategory.get(req.category) || [];
+            existing.push(req.requirement);
+            byCategory.set(req.category, existing);
+        }
+        // Format with category headers if multiple categories
+        if (byCategory.size > 2) {
+            const categoryLabels = {
+                infrastructure: '🏗️ Infrastructure',
+                security: '🔒 Security',
+                performance: '⚡ Performance',
+                ux: '✨ User Experience',
+                integration: '🔗 Integration',
+                feature: '📋 Feature',
+                business: '📊 Business Rules',
+            };
+            for (const [category, reqs] of byCategory) {
+                section += `**${categoryLabels[category] || category}:**\n`;
+                section += reqs.map((r) => `- ${r}`).join('\n');
+                section += '\n\n';
+            }
+        }
+        else {
+            // Simple list for fewer categories
+            section += implicitReqs.map((r) => `- ${r.requirement}`).join('\n');
+            section += '\n\n';
+        }
+        section += '> **Note:** Please verify these inferred requirements are accurate.';
+        return prompt + section;
+    }
+}
+//# sourceMappingURL=implicit-requirement-extractor.js.map

package/dist/core/intelligence/patterns/requirement-prioritizer.d.ts

@@ -0,0 +1,22 @@
+import { BasePattern } from './base-pattern.js';
+import { PromptIntent, OptimizationMode, PatternContext, PatternResult } from '../types.js';
+/**
+ * v4.3.2 PRD Pattern: RequirementPrioritizer
+ *
+ * Separates must-have from nice-to-have requirements in PRD content.
+ * Helps clarify priorities and MVP scope.
+ */
+export declare class RequirementPrioritizer extends BasePattern {
+    id: string;
+    name: string;
+    description: string;
+    applicableIntents: PromptIntent[];
+    mode: OptimizationMode | 'both';
+    priority: number;
+    apply(prompt: string, _context: PatternContext): PatternResult;
+    private hasFeatureContent;
+    private hasPrioritization;
+    private addPrioritization;
+    private extractFeatureSection;
+}
+//# sourceMappingURL=requirement-prioritizer.d.ts.map

package/dist/core/intelligence/patterns/requirement-prioritizer.js

@@ -0,0 +1,117 @@
+import { BasePattern } from './base-pattern.js';
+/**
+ * v4.3.2 PRD Pattern: RequirementPrioritizer
+ *
+ * Separates must-have from nice-to-have requirements in PRD content.
+ * Helps clarify priorities and MVP scope.
+ */
+export class RequirementPrioritizer extends BasePattern {
+    id = 'requirement-prioritizer';
+    name = 'RequirementPrioritizer';
+    description = 'Separates must-have from nice-to-have requirements';
+    applicableIntents = ['prd-generation', 'planning'];
+    mode = 'deep';
+    priority = 7;
+    apply(prompt, _context) {
+        // Only apply to PRD-related content with features
+        if (!this.hasFeatureContent(prompt)) {
+            return {
+                enhancedPrompt: prompt,
+                improvement: {
+                    dimension: 'structure',
+                    description: 'No feature content to prioritize',
+                    impact: 'low',
+                },
+                applied: false,
+            };
+        }
+        // Check if prioritization already exists
+        if (this.hasPrioritization(prompt)) {
+            return {
+                enhancedPrompt: prompt,
+                improvement: {
+                    dimension: 'structure',
+                    description: 'Requirements already prioritized',
+                    impact: 'low',
+                },
+                applied: false,
+            };
+        }
+        // Add prioritization framework
+        const enhanced = this.addPrioritization(prompt);
+        return {
+            enhancedPrompt: enhanced,
+            improvement: {
+                dimension: 'structure',
+                description: 'Added requirement prioritization (must-have vs nice-to-have)',
+                impact: 'high',
+            },
+            applied: true,
+        };
+    }
+    hasFeatureContent(prompt) {
+        const featureKeywords = [
+            'feature',
+            'requirement',
+            'functionality',
+            'capability',
+            'should',
+            'must',
+            'need',
+            'want',
+            'implement',
+        ];
+        return this.hasSection(prompt, featureKeywords);
+    }
+    hasPrioritization(prompt) {
+        const priorityKeywords = [
+            'must-have',
+            'must have',
+            'nice-to-have',
+            'nice to have',
+            'p0',
+            'p1',
+            'p2',
+            'priority:',
+            'mvp',
+            'phase 1',
+            'phase 2',
+            'critical',
+            'optional',
+        ];
+        return this.hasSection(prompt, priorityKeywords);
+    }
+    addPrioritization(prompt) {
+        // Look for feature sections and add prioritization guidance
+        const featureSection = this.extractFeatureSection(prompt);
+        if (!featureSection) {
+            // No clear feature section, add prioritization note
+            return (prompt +
+                '\n\n### Requirement Priorities\n' +
+                '**Must-Have (MVP):**\n- [Core features required for launch]\n\n' +
+                '**Nice-to-Have (Post-MVP):**\n- [Features to add after initial release]');
+        }
+        // Features exist but aren't prioritized - add framework
+        const priorityNote = '\n\n> **Priority Framework:** Consider categorizing features as:\n' +
+            '> - **Must-Have (P0):** Required for MVP, blocking issues\n' +
+            '> - **Should-Have (P1):** Important but not blocking\n' +
+            '> - **Nice-to-Have (P2):** Enhancements for future iterations';
+        return prompt + priorityNote;
+    }
+    extractFeatureSection(prompt) {
+        // Try to find feature-related sections
+        const featurePatterns = [
+            /features?:?\s*\n([\s\S]*?)(?=\n##|\n\*\*[A-Z]|$)/i,
+            /requirements?:?\s*\n([\s\S]*?)(?=\n##|\n\*\*[A-Z]|$)/i,
+            /what we(?:'re| are) building:?\s*\n([\s\S]*?)(?=\n##|\n\*\*[A-Z]|$)/i,
+        ];
+        for (const pattern of featurePatterns) {
+            const match = prompt.match(pattern);
+            if (match) {
+                return match[1];
+            }
+        }
+        return null;
+    }
+}
+//# sourceMappingURL=requirement-prioritizer.js.map

package/dist/core/intelligence/patterns/success-metrics-enforcer.d.ts

@@ -0,0 +1,22 @@
+import { BasePattern } from './base-pattern.js';
+import { PromptIntent, OptimizationMode, PatternContext, PatternResult } from '../types.js';
+/**
+ * v4.3.2 PRD Pattern: SuccessMetricsEnforcer
+ *
+ * Ensures measurable success criteria exist in PRD content.
+ * Adds KPIs and metrics when missing.
+ */
+export declare class SuccessMetricsEnforcer extends BasePattern {
+    id: string;
+    name: string;
+    description: string;
+    applicableIntents: PromptIntent[];
+    mode: OptimizationMode | 'both';
+    priority: number;
+    apply(prompt: string, _context: PatternContext): PatternResult;
+    private hasSuccessMetrics;
+    private needsMetrics;
+    private addSuccessMetrics;
+    private inferRelevantMetrics;
+}
+//# sourceMappingURL=success-metrics-enforcer.d.ts.map

package/dist/core/intelligence/patterns/success-metrics-enforcer.js

@@ -0,0 +1,142 @@
+import { BasePattern } from './base-pattern.js';
+/**
+ * v4.3.2 PRD Pattern: SuccessMetricsEnforcer
+ *
+ * Ensures measurable success criteria exist in PRD content.
+ * Adds KPIs and metrics when missing.
+ */
+export class SuccessMetricsEnforcer extends BasePattern {
+    id = 'success-metrics-enforcer';
+    name = 'SuccessMetricsEnforcer';
+    description = 'Ensures measurable success criteria exist';
+    applicableIntents = ['prd-generation', 'planning'];
+    mode = 'deep';
+    priority = 7;
+    apply(prompt, _context) {
+        // Check if success metrics already exist
+        if (this.hasSuccessMetrics(prompt)) {
+            return {
+                enhancedPrompt: prompt,
+                improvement: {
+                    dimension: 'completeness',
+                    description: 'Success metrics already present',
+                    impact: 'low',
+                },
+                applied: false,
+            };
+        }
+        // Check if this is content that needs metrics
+        if (!this.needsMetrics(prompt)) {
+            return {
+                enhancedPrompt: prompt,
+                improvement: {
+                    dimension: 'completeness',
+                    description: 'Content does not require success metrics',
+                    impact: 'low',
+                },
+                applied: false,
+            };
+        }
+        // Add success metrics section
+        const enhanced = this.addSuccessMetrics(prompt);
+        return {
+            enhancedPrompt: enhanced,
+            improvement: {
+                dimension: 'completeness',
+                description: 'Added measurable success criteria and KPIs',
+                impact: 'high',
+            },
+            applied: true,
+        };
+    }
+    hasSuccessMetrics(prompt) {
+        const metricsKeywords = [
+            'success metric',
+            'success criteria',
+            'kpi',
+            'measure success',
+            'acceptance criteria',
+            '% increase',
+            '% decrease',
+            'conversion rate',
+            'completion rate',
+            'response time',
+            'latency',
+            'uptime',
+            'sla',
+            'benchmark',
+        ];
+        return this.hasSection(prompt, metricsKeywords);
+    }
+    needsMetrics(prompt) {
+        // PRD-like content that describes features
+        const prdKeywords = [
+            'feature',
+            'build',
+            'implement',
+            'goal',
+            'objective',
+            'product',
+            'launch',
+            'release',
+        ];
+        return this.hasSection(prompt, prdKeywords);
+    }
+    addSuccessMetrics(prompt) {
+        // Detect the type of project to suggest relevant metrics
+        const metrics = this.inferRelevantMetrics(prompt);
+        const metricsSection = `\n\n### Success Metrics\n` +
+            `**Primary KPIs:**\n` +
+            metrics.map((m) => `- ${m}`).join('\n') +
+            `\n\n**Measurement Approach:**\n` +
+            `- Baseline: [Current state before implementation]\n` +
+            `- Target: [Specific, measurable goals]\n` +
+            `- Timeline: [When to measure success]`;
+        return prompt + metricsSection;
+    }
+    inferRelevantMetrics(prompt) {
+        const lowerPrompt = prompt.toLowerCase();
+        const metrics = [];
+        // Performance-related
+        if (lowerPrompt.includes('performance') ||
+            lowerPrompt.includes('fast') ||
+            lowerPrompt.includes('speed')) {
+            metrics.push('Response time < [X]ms (p95)');
+            metrics.push('Page load time improvement by [X]%');
+        }
+        // User engagement
+        if (lowerPrompt.includes('user') ||
+            lowerPrompt.includes('engagement') ||
+            lowerPrompt.includes('retention')) {
+            metrics.push('User engagement increase by [X]%');
+            metrics.push('Task completion rate > [X]%');
+        }
+        // Conversion/business
+        if (lowerPrompt.includes('conversion') ||
+            lowerPrompt.includes('sales') ||
+            lowerPrompt.includes('revenue')) {
+            metrics.push('Conversion rate improvement by [X]%');
+            metrics.push('Revenue impact of $[X]');
+        }
+        // Technical quality
+        if (lowerPrompt.includes('quality') ||
+            lowerPrompt.includes('bug') ||
+            lowerPrompt.includes('error')) {
+            metrics.push('Error rate < [X]%');
+            metrics.push('Test coverage > [X]%');
+        }
+        // API/integration
+        if (lowerPrompt.includes('api') || lowerPrompt.includes('integration')) {
+            metrics.push('API availability > [X]%');
+            metrics.push('Integration success rate > [X]%');
+        }
+        // Default metrics if none matched
+        if (metrics.length === 0) {
+            metrics.push('[Define primary success metric]');
+            metrics.push('[Define secondary success metric]');
+            metrics.push('[Define timeline for measurement]');
+        }
+        return metrics.slice(0, 4); // Max 4 metrics
+    }
+}
+//# sourceMappingURL=success-metrics-enforcer.js.map

package/dist/core/intelligence/patterns/topic-coherence-analyzer.d.ts

@@ -0,0 +1,24 @@
+import { BasePattern } from './base-pattern.js';
+import { PromptIntent, OptimizationMode, PatternContext, PatternResult } from '../types.js';
+/**
+ * v4.4 Conversational Pattern: TopicCoherenceAnalyzer
+ *
+ * Detects topic shifts and multi-topic conversations.
+ * Helps organize scattered discussions into coherent themes.
+ * Enhanced with expanded topic dictionary and better detection.
+ */
+export declare class TopicCoherenceAnalyzer extends BasePattern {
+    id: string;
+    name: string;
+    description: string;
+    applicableIntents: PromptIntent[];
+    mode: OptimizationMode | 'both';
+    priority: number;
+    private readonly topicIndicators;
+    apply(prompt: string, _context: PatternContext): PatternResult;
+    private detectTopics;
+    private hasTopicOrganization;
+    private organizeByTopic;
+    private extractTopicContent;
+}
+//# sourceMappingURL=topic-coherence-analyzer.d.ts.map