clavix 4.3.1 → 4.3.2

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

@@ -0,0 +1,129 @@
+import { BasePattern } from './base-pattern.js';
+/**
+ * v4.3.2 Conversational Pattern: ImplicitRequirementExtractor
+ *
+ * Surfaces requirements mentioned indirectly in conversations.
+ * Identifies hidden assumptions and unstated needs.
+ */
+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;
+    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.addImplicitRequirements(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(`Feature parity with "${match[1].trim()}" (implied)`);
+            }
+        }
+        // Pattern 2: Technical mentions imply requirements
+        if (lowerPrompt.includes('mobile')) {
+            implicitReqs.push('Mobile-responsive design required');
+        }
+        if (lowerPrompt.includes('real-time') || lowerPrompt.includes('realtime')) {
+            implicitReqs.push('Real-time updates infrastructure needed');
+        }
+        if (lowerPrompt.includes('scale') ||
+            lowerPrompt.includes('thousands') ||
+            lowerPrompt.includes('millions')) {
+            implicitReqs.push('Scalability architecture required');
+        }
+        if (lowerPrompt.includes('secure') || lowerPrompt.includes('security')) {
+            implicitReqs.push('Security audit and compliance requirements');
+        }
+        if (lowerPrompt.includes('fast') || lowerPrompt.includes('quick')) {
+            implicitReqs.push('Performance optimization requirements');
+        }
+        // Pattern 3: User mentions imply auth/permissions
+        if ((lowerPrompt.includes('user') || lowerPrompt.includes('admin')) &&
+            !lowerPrompt.includes('authentication')) {
+            implicitReqs.push('User authentication system (implied by user roles)');
+        }
+        // Pattern 4: Data mentions imply storage
+        if ((lowerPrompt.includes('save') ||
+            lowerPrompt.includes('store') ||
+            lowerPrompt.includes('data')) &&
+            !lowerPrompt.includes('database')) {
+            implicitReqs.push('Data persistence/storage (implied by data operations)');
+        }
+        // Pattern 5: "Easy" or "simple" implies UX focus
+        if (lowerPrompt.includes('easy') ||
+            lowerPrompt.includes('simple') ||
+            lowerPrompt.includes('intuitive')) {
+            implicitReqs.push('User experience priority (simplicity mentioned)');
+        }
+        // Pattern 6: Notifications/alerts imply communication system
+        if (lowerPrompt.includes('notify') ||
+            lowerPrompt.includes('alert') ||
+            lowerPrompt.includes('email') ||
+            lowerPrompt.includes('notification')) {
+            implicitReqs.push('Notification system infrastructure');
+        }
+        // Pattern 7: Search implies search infrastructure
+        if (lowerPrompt.includes('search') || lowerPrompt.includes('find')) {
+            implicitReqs.push('Search functionality and indexing');
+        }
+        // Pattern 8: Reports/analytics implies data aggregation
+        if (lowerPrompt.includes('report') ||
+            lowerPrompt.includes('analytics') ||
+            lowerPrompt.includes('dashboard')) {
+            implicitReqs.push('Analytics and reporting infrastructure');
+        }
+        // Pattern 9: Integration mentions
+        if (lowerPrompt.includes('integrate') ||
+            lowerPrompt.includes('connect') ||
+            lowerPrompt.includes('sync')) {
+            implicitReqs.push('Integration APIs and webhooks');
+        }
+        // Pattern 10: "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(`Business rule: "${match[1].trim()}" (implied constraint)`);
+            }
+        }
+        // Deduplicate
+        return [...new Set(implicitReqs)].slice(0, 8);
+    }
+    addImplicitRequirements(prompt, implicitReqs) {
+        let section = '\n\n### Implicit Requirements (Inferred)\n';
+        section += '*The following requirements are implied by the discussion:*\n\n';
+        section += implicitReqs.map((r) => `- ${r}`).join('\n');
+        section += '\n\n> **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,22 @@
+import { BasePattern } from './base-pattern.js';
+import { PromptIntent, OptimizationMode, PatternContext, PatternResult } from '../types.js';
+/**
+ * v4.3.2 Conversational Pattern: TopicCoherenceAnalyzer
+ *
+ * Detects topic shifts and multi-topic conversations.
+ * Helps organize scattered discussions into coherent themes.
+ */
+export declare class TopicCoherenceAnalyzer extends BasePattern {
+    id: string;
+    name: string;
+    description: string;
+    applicableIntents: PromptIntent[];
+    mode: OptimizationMode | 'both';
+    priority: number;
+    apply(prompt: string, _context: PatternContext): PatternResult;
+    private detectTopics;
+    private hasTopicOrganization;
+    private organizeByTopic;
+    private extractTopicContent;
+}
+//# sourceMappingURL=topic-coherence-analyzer.d.ts.map

package/dist/core/intelligence/patterns/topic-coherence-analyzer.js

@@ -0,0 +1,140 @@
+import { BasePattern } from './base-pattern.js';
+/**
+ * v4.3.2 Conversational Pattern: TopicCoherenceAnalyzer
+ *
+ * Detects topic shifts and multi-topic conversations.
+ * Helps organize scattered discussions into coherent themes.
+ */
+export class TopicCoherenceAnalyzer extends BasePattern {
+    id = 'topic-coherence-analyzer';
+    name = 'TopicCoherenceAnalyzer';
+    description = 'Detects topic shifts and multi-topic conversations';
+    applicableIntents = ['summarization', 'planning'];
+    mode = 'deep';
+    priority = 6;
+    apply(prompt, _context) {
+        // Detect topics in the content
+        const topics = this.detectTopics(prompt);
+        // If single topic or already organized, skip
+        if (topics.length <= 1) {
+            return {
+                enhancedPrompt: prompt,
+                improvement: {
+                    dimension: 'structure',
+                    description: 'Single coherent topic detected',
+                    impact: 'low',
+                },
+                applied: false,
+            };
+        }
+        // Check if already has topic organization
+        if (this.hasTopicOrganization(prompt)) {
+            return {
+                enhancedPrompt: prompt,
+                improvement: {
+                    dimension: 'structure',
+                    description: 'Topics already organized',
+                    impact: 'low',
+                },
+                applied: false,
+            };
+        }
+        // Add topic organization
+        const enhanced = this.organizeByTopic(prompt, topics);
+        return {
+            enhancedPrompt: enhanced,
+            improvement: {
+                dimension: 'structure',
+                description: `Organized ${topics.length} distinct topics for clarity`,
+                impact: 'medium',
+            },
+            applied: true,
+        };
+    }
+    detectTopics(prompt) {
+        const topics = [];
+        const lowerPrompt = prompt.toLowerCase();
+        // Topic detection patterns
+        const topicIndicators = {
+            'User Interface': ['ui', 'interface', 'design', 'layout', 'button', 'form', 'page', 'screen'],
+            'Backend/API': ['api', 'backend', 'server', 'endpoint', 'route', 'controller'],
+            Database: ['database', 'db', 'schema', 'table', 'query', 'migration'],
+            Authentication: ['auth', 'login', 'password', 'session', 'token', 'permission'],
+            Performance: ['performance', 'speed', 'cache', 'optimize', 'latency'],
+            Testing: ['test', 'spec', 'coverage', 'qa', 'validation'],
+            Deployment: ['deploy', 'ci/cd', 'pipeline', 'release', 'environment'],
+            'User Experience': ['ux', 'usability', 'accessibility', 'user flow', 'journey'],
+            'Business Logic': ['business', 'workflow', 'process', 'rule', 'logic'],
+            Integration: ['integration', 'third-party', 'external', 'webhook', 'sync'],
+        };
+        for (const [topic, keywords] of Object.entries(topicIndicators)) {
+            const hasKeyword = keywords.some((kw) => lowerPrompt.includes(kw));
+            if (hasKeyword) {
+                topics.push(topic);
+            }
+        }
+        return topics;
+    }
+    hasTopicOrganization(prompt) {
+        // Check for existing topic headers
+        const topicHeaders = /##\s*(user interface|backend|database|auth|performance|testing|deploy)/i;
+        return topicHeaders.test(prompt);
+    }
+    organizeByTopic(prompt, topics) {
+        // Add topic summary at the beginning
+        let organized = '### Topics Covered\n';
+        organized += 'This conversation touches on multiple areas:\n';
+        organized += topics.map((t, i) => `${i + 1}. **${t}**`).join('\n');
+        organized += '\n\n---\n\n';
+        // Extract content relevant to each topic
+        organized += '### Discussion by Topic\n\n';
+        for (const topic of topics) {
+            const relevantContent = this.extractTopicContent(prompt, topic);
+            if (relevantContent) {
+                organized += `#### ${topic}\n`;
+                organized += relevantContent + '\n\n';
+            }
+        }
+        organized += '---\n\n**Full Context:**\n' + prompt;
+        return organized;
+    }
+    extractTopicContent(prompt, topic) {
+        // Simple extraction based on topic keywords
+        const topicKeywords = {
+            'User Interface': [
+                'ui',
+                'interface',
+                'design',
+                'layout',
+                'button',
+                'form',
+                'page',
+                'screen',
+                'component',
+            ],
+            'Backend/API': ['api', 'backend', 'server', 'endpoint', 'route', 'controller', 'service'],
+            Database: ['database', 'db', 'schema', 'table', 'query', 'migration', 'model'],
+            Authentication: ['auth', 'login', 'password', 'session', 'token', 'permission', 'user'],
+            Performance: ['performance', 'speed', 'cache', 'optimize', 'latency', 'fast', 'slow'],
+            Testing: ['test', 'spec', 'coverage', 'qa', 'validation', 'verify'],
+            Deployment: ['deploy', 'ci/cd', 'pipeline', 'release', 'environment', 'production'],
+            'User Experience': ['ux', 'usability', 'accessibility', 'user flow', 'journey', 'experience'],
+            'Business Logic': ['business', 'workflow', 'process', 'rule', 'logic', 'requirement'],
+            Integration: ['integration', 'third-party', 'external', 'webhook', 'sync', 'connect'],
+        };
+        const keywords = topicKeywords[topic] || [];
+        const sentences = this.extractSentences(prompt);
+        const relevantSentences = sentences.filter((sentence) => {
+            const lower = sentence.toLowerCase();
+            return keywords.some((kw) => lower.includes(kw));
+        });
+        if (relevantSentences.length === 0) {
+            return `- Discussion related to ${topic}`;
+        }
+        return relevantSentences
+            .slice(0, 3)
+            .map((s) => `- ${s.trim()}`)
+            .join('\n');
+    }
+}
+//# sourceMappingURL=topic-coherence-analyzer.js.map

package/dist/core/intelligence/patterns/user-persona-enricher.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: UserPersonaEnricher
+ *
+ * Adds missing user context and personas to PRD content.
+ * Ensures the "who" is clearly defined alongside the "what".
+ */
+export declare class UserPersonaEnricher extends BasePattern {
+    id: string;
+    name: string;
+    description: string;
+    applicableIntents: PromptIntent[];
+    mode: OptimizationMode | 'both';
+    priority: number;
+    apply(prompt: string, _context: PatternContext): PatternResult;
+    private hasUserContext;
+    private needsUserContext;
+    private addUserPersona;
+    private inferUserType;
+}
+//# sourceMappingURL=user-persona-enricher.d.ts.map