clavix 4.2.0 → 4.3.2

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

@@ -0,0 +1,149 @@
+import { BasePattern } from './base-pattern.js';
+/**
+ * v4.3.2 PRD Pattern: DependencyIdentifier
+ *
+ * Identifies technical and external dependencies in PRD content.
+ * Helps surface hidden requirements and blockers.
+ */
+export class DependencyIdentifier extends BasePattern {
+    id = 'dependency-identifier';
+    name = 'DependencyIdentifier';
+    description = 'Identifies technical and external dependencies';
+    applicableIntents = ['prd-generation', 'planning', 'migration'];
+    mode = 'deep';
+    priority = 5;
+    apply(prompt, _context) {
+        // Check if dependencies are already documented
+        if (this.hasDependencySection(prompt)) {
+            return {
+                enhancedPrompt: prompt,
+                improvement: {
+                    dimension: 'completeness',
+                    description: 'Dependencies already documented',
+                    impact: 'low',
+                },
+                applied: false,
+            };
+        }
+        // Check if this content has identifiable dependencies
+        const dependencies = this.identifyDependencies(prompt);
+        if (dependencies.length === 0) {
+            return {
+                enhancedPrompt: prompt,
+                improvement: {
+                    dimension: 'completeness',
+                    description: 'No clear dependencies identified',
+                    impact: 'low',
+                },
+                applied: false,
+            };
+        }
+        // Add dependency section
+        const enhanced = this.addDependencySection(prompt, dependencies);
+        return {
+            enhancedPrompt: enhanced,
+            improvement: {
+                dimension: 'completeness',
+                description: `Identified ${dependencies.length} dependencies (technical/external)`,
+                impact: 'medium',
+            },
+            applied: true,
+        };
+    }
+    hasDependencySection(prompt) {
+        const dependencyKeywords = [
+            'dependencies',
+            'depends on',
+            'prerequisite',
+            'requires',
+            'blocked by',
+            'blocker',
+            'external service',
+            'third-party',
+            'integration with',
+        ];
+        return this.hasSection(prompt, dependencyKeywords);
+    }
+    identifyDependencies(prompt) {
+        const dependencies = [];
+        const lowerPrompt = prompt.toLowerCase();
+        // Technical dependencies
+        if (lowerPrompt.includes('api')) {
+            dependencies.push('API availability and documentation');
+        }
+        if (lowerPrompt.includes('database') || lowerPrompt.includes('db')) {
+            dependencies.push('Database schema and migrations');
+        }
+        if (lowerPrompt.includes('authentication') || lowerPrompt.includes('auth')) {
+            dependencies.push('Authentication system integration');
+        }
+        if (lowerPrompt.includes('payment') ||
+            lowerPrompt.includes('stripe') ||
+            lowerPrompt.includes('billing')) {
+            dependencies.push('Payment provider integration');
+        }
+        if (lowerPrompt.includes('email') || lowerPrompt.includes('notification')) {
+            dependencies.push('Email/notification service');
+        }
+        if (lowerPrompt.includes('storage') ||
+            lowerPrompt.includes('s3') ||
+            lowerPrompt.includes('file')) {
+            dependencies.push('File storage service');
+        }
+        if (lowerPrompt.includes('search') || lowerPrompt.includes('elasticsearch')) {
+            dependencies.push('Search infrastructure');
+        }
+        if (lowerPrompt.includes('analytics') || lowerPrompt.includes('tracking')) {
+            dependencies.push('Analytics platform');
+        }
+        if (lowerPrompt.includes('ci/cd') || lowerPrompt.includes('deploy')) {
+            dependencies.push('CI/CD pipeline');
+        }
+        if (lowerPrompt.includes('cache') || lowerPrompt.includes('redis')) {
+            dependencies.push('Caching infrastructure');
+        }
+        // External dependencies
+        if (lowerPrompt.includes('third-party') || lowerPrompt.includes('external')) {
+            dependencies.push('Third-party service availability');
+        }
+        if (lowerPrompt.includes('team') || lowerPrompt.includes('collaboration')) {
+            dependencies.push('Cross-team coordination');
+        }
+        if (lowerPrompt.includes('approval') || lowerPrompt.includes('sign-off')) {
+            dependencies.push('Stakeholder approvals');
+        }
+        if (lowerPrompt.includes('legal') || lowerPrompt.includes('compliance')) {
+            dependencies.push('Legal/compliance review');
+        }
+        if (lowerPrompt.includes('design') ||
+            lowerPrompt.includes('ui') ||
+            lowerPrompt.includes('ux')) {
+            dependencies.push('Design specifications');
+        }
+        return dependencies;
+    }
+    addDependencySection(prompt, dependencies) {
+        // Categorize dependencies
+        const technical = dependencies.filter((d) => d.includes('API') ||
+            d.includes('Database') ||
+            d.includes('Authentication') ||
+            d.includes('service') ||
+            d.includes('infrastructure') ||
+            d.includes('pipeline'));
+        const external = dependencies.filter((d) => !technical.includes(d));
+        let section = '\n\n### Dependencies\n';
+        if (technical.length > 0) {
+            section += '**Technical Dependencies:**\n';
+            section += technical.map((d) => `- ${d}`).join('\n');
+            section += '\n\n';
+        }
+        if (external.length > 0) {
+            section += '**External Dependencies:**\n';
+            section += external.map((d) => `- ${d}`).join('\n');
+            section += '\n';
+        }
+        section += '\n**Dependency Status:** [Track status of each dependency]';
+        return prompt + section;
+    }
+}
+//# sourceMappingURL=dependency-identifier.js.map

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

@@ -0,0 +1,20 @@
+import { BasePattern } from './base-pattern.js';
+import { PromptIntent, OptimizationMode, PatternContext, PatternResult } from '../types.js';
+/**
+ * v4.3.2 Conversational Pattern: ImplicitRequirementExtractor
+ *
+ * Surfaces requirements mentioned indirectly in conversations.
+ * Identifies hidden assumptions and unstated needs.
+ */
+export declare class ImplicitRequirementExtractor extends BasePattern {
+    id: string;
+    name: string;
+    description: string;
+    applicableIntents: PromptIntent[];
+    mode: OptimizationMode | 'both';
+    priority: number;
+    apply(prompt: string, _context: PatternContext): PatternResult;
+    private extractImplicitRequirements;
+    private addImplicitRequirements;
+}
+//# sourceMappingURL=implicit-requirement-extractor.d.ts.map

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