clavix 4.12.0 → 5.0.0

package/dist/core/intelligence/patterns/prd-structure-enforcer.js

@@ -1,183 +0,0 @@
-import { BasePattern, } from './base-pattern.js';
-/**
- * v4.5 Pattern: PRD Structure Enforcer
- *
- * Ensures PRD prompts include all necessary sections
- * for comprehensive product requirement documentation.
- */
-export class PRDStructureEnforcer extends BasePattern {
-    // -------------------------------------------------------------------------
-    // Pattern Metadata (v4.5 unified types)
-    // -------------------------------------------------------------------------
-    id = 'prd-structure-enforcer';
-    name = 'PRD Structure Enforcer';
-    description = 'Ensure PRD prompts include all necessary sections';
-    applicableIntents = ['prd-generation'];
-    scope = 'comprehensive';
-    priority = 9; // VERY HIGH - structural integrity
-    phases = ['question-validation', 'output-generation'];
-    // -------------------------------------------------------------------------
-    // Configuration Schema (v4.5)
-    // -------------------------------------------------------------------------
-    static configSchema = {
-        showCompletenessScore: {
-            type: 'boolean',
-            default: true,
-            description: 'Show PRD completeness percentage',
-        },
-        includeBestPractices: {
-            type: 'boolean',
-            default: true,
-            description: 'Include PRD best practices reminder',
-        },
-    };
-    // -------------------------------------------------------------------------
-    // Pattern Data
-    // -------------------------------------------------------------------------
-    // Required PRD sections with their purposes
-    PRD_SECTIONS = [
-        {
-            id: 'problem',
-            name: 'Problem Statement',
-            keywords: ['problem', 'issue', 'pain point', 'challenge', 'need'],
-            prompt: 'What problem does this solve? What pain points are being addressed?',
-        },
-        {
-            id: 'users',
-            name: 'Target Users',
-            keywords: ['user', 'audience', 'persona', 'customer', 'stakeholder', 'who'],
-            prompt: 'Who are the target users? What are their characteristics and needs?',
-        },
-        {
-            id: 'goals',
-            name: 'Goals & Success Metrics',
-            keywords: ['goal', 'objective', 'success', 'metric', 'kpi', 'measure', 'outcome'],
-            prompt: 'What are the measurable goals? How will success be measured?',
-        },
-        {
-            id: 'requirements',
-            name: 'Functional Requirements',
-            keywords: ['feature', 'requirement', 'must', 'should', 'functionality', 'capability'],
-            prompt: 'What specific functionality is required? List the features.',
-        },
-        {
-            id: 'scope',
-            name: 'Scope & Boundaries',
-            keywords: ['scope', 'boundary', 'included', 'excluded', 'out of scope', 'limitation'],
-            prompt: 'What is in scope and out of scope? What are the boundaries?',
-        },
-        {
-            id: 'constraints',
-            name: 'Constraints & Dependencies',
-            keywords: ['constraint', 'dependency', 'limitation', 'assumption', 'prerequisite'],
-            prompt: 'What technical or business constraints exist? What dependencies are there?',
-        },
-        {
-            id: 'timeline',
-            name: 'Timeline & Milestones',
-            keywords: ['timeline', 'deadline', 'milestone', 'phase', 'sprint', 'release'],
-            prompt: 'What is the timeline? What are key milestones?',
-        },
-        {
-            id: 'risks',
-            name: 'Risks & Mitigations',
-            keywords: ['risk', 'mitigation', 'concern', 'blocker', 'issue'],
-            prompt: 'What are potential risks? How will they be mitigated?',
-        },
-    ];
-    apply(prompt, _context) {
-        const analysis = this.analyzePRDCompleteness(prompt);
-        if (analysis.missingSections.length === 0) {
-            return {
-                enhancedPrompt: prompt,
-                improvement: {
-                    dimension: 'completeness',
-                    description: 'PRD prompt already includes key sections',
-                    impact: 'low',
-                },
-                applied: false,
-            };
-        }
-        // Generate enhancement section
-        const enhancementSection = this.formatEnhancementSection(analysis);
-        const enhancedPrompt = `${prompt}\n\n${enhancementSection}`;
-        return {
-            enhancedPrompt,
-            improvement: {
-                dimension: 'completeness',
-                description: `Added ${analysis.missingSections.length} PRD sections for consideration`,
-                impact: 'high',
-            },
-            applied: true,
-        };
-    }
-    analyzePRDCompleteness(prompt) {
-        const lowerPrompt = prompt.toLowerCase();
-        const presentSections = [];
-        const missingSections = [];
-        const weakSections = [];
-        for (const section of this.PRD_SECTIONS) {
-            const matchedKeywords = section.keywords.filter((kw) => lowerPrompt.includes(kw.toLowerCase()));
-            if (matchedKeywords.length >= 2) {
-                // Section is well-covered
-                presentSections.push(section);
-            }
-            else if (matchedKeywords.length === 1) {
-                // Section is mentioned but weak
-                weakSections.push(section);
-            }
-            else {
-                // Section is missing
-                missingSections.push(section);
-            }
-        }
-        // Calculate completeness score
-        const totalSections = this.PRD_SECTIONS.length;
-        const coveredCount = presentSections.length + weakSections.length * 0.5;
-        const completenessScore = Math.round((coveredCount / totalSections) * 100);
-        return {
-            presentSections,
-            missingSections,
-            weakSections,
-            completenessScore,
-        };
-    }
-    formatEnhancementSection(analysis) {
-        const lines = [
-            '### PRD Completeness Check',
-            '',
-            `**Current coverage:** ${analysis.completenessScore}%`,
-            '',
-        ];
-        // Critical missing sections
-        if (analysis.missingSections.length > 0) {
-            lines.push('**Missing sections to consider:**');
-            lines.push('');
-            analysis.missingSections.forEach((section) => {
-                lines.push(`#### ${section.name}`);
-                lines.push(`_${section.prompt}_`);
-                lines.push('');
-            });
-        }
-        // Weak sections that need elaboration
-        if (analysis.weakSections.length > 0) {
-            lines.push('**Sections that could be expanded:**');
-            lines.push('');
-            analysis.weakSections.forEach((section) => {
-                lines.push(`- **${section.name}**: ${section.prompt}`);
-            });
-            lines.push('');
-        }
-        // Add PRD best practices reminder
-        lines.push('---');
-        lines.push('');
-        lines.push('**PRD Best Practices:**');
-        lines.push('- Be specific about user personas and their needs');
-        lines.push('- Include measurable success criteria');
-        lines.push('- Clearly define what is NOT in scope');
-        lines.push('- Prioritize requirements (must-have vs nice-to-have)');
-        lines.push('- Consider edge cases and error scenarios');
-        return lines.join('\n');
-    }
-}
-//# sourceMappingURL=prd-structure-enforcer.js.map

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

@@ -1,23 +0,0 @@
-import { BasePattern, PatternScope, PatternPriority, PatternPhase, PatternConfigSchema } from './base-pattern.js';
-import { PatternContext, PatternResult, PromptIntent } from '../types.js';
-/**
- * v4.5 Pattern: Prerequisite Identifier
- *
- * Identifies and explicitly states prerequisites and dependencies
- * that must be in place before the task can be executed.
- */
-export declare class PrerequisiteIdentifier extends BasePattern {
-    readonly id = "prerequisite-identifier";
-    readonly name = "Prerequisite Identifier";
-    readonly description = "Identifies and documents prerequisites and dependencies for task execution";
-    readonly applicableIntents: PromptIntent[];
-    readonly scope: PatternScope;
-    readonly priority: PatternPriority;
-    readonly phases: PatternPhase[];
-    static readonly configSchema: PatternConfigSchema;
-    private prerequisiteIndicators;
-    private techPrerequisites;
-    private intentPrerequisites;
-    apply(prompt: string, context: PatternContext): PatternResult;
-}
-//# sourceMappingURL=prerequisite-identifier.d.ts.map

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

@@ -1,221 +0,0 @@
-import { BasePattern, } from './base-pattern.js';
-/**
- * v4.5 Pattern: Prerequisite Identifier
- *
- * Identifies and explicitly states prerequisites and dependencies
- * that must be in place before the task can be executed.
- */
-export class PrerequisiteIdentifier extends BasePattern {
-    // -------------------------------------------------------------------------
-    // Pattern Metadata (v4.5 unified types)
-    // -------------------------------------------------------------------------
-    id = 'prerequisite-identifier';
-    name = 'Prerequisite Identifier';
-    description = 'Identifies and documents prerequisites and dependencies for task execution';
-    applicableIntents = [
-        'code-generation',
-        'planning',
-        'migration',
-        'testing',
-        'debugging',
-    ];
-    scope = 'comprehensive';
-    priority = 6; // MEDIUM - standard enhancement
-    phases = ['all'];
-    // -------------------------------------------------------------------------
-    // Configuration Schema (v4.5)
-    // -------------------------------------------------------------------------
-    static configSchema = {
-        maxPrerequisites: {
-            type: 'number',
-            default: 8,
-            description: 'Maximum number of prerequisites to list',
-            validation: { min: 1, max: 15 },
-        },
-        maxTechnologies: {
-            type: 'number',
-            default: 3,
-            description: 'Maximum number of technologies to detect',
-            validation: { min: 1, max: 5 },
-        },
-    };
-    // -------------------------------------------------------------------------
-    // Pattern Data
-    // -------------------------------------------------------------------------
-    // Keywords that suggest prerequisites are already addressed
-    prerequisiteIndicators = [
-        'prerequisite',
-        'requirements:',
-        'depends on',
-        'dependency',
-        'requires',
-        'before starting',
-        'first ensure',
-        'make sure',
-        'assuming',
-        'given that',
-        'setup:',
-        'installation:',
-        'configuration:',
-    ];
-    // Technology-specific prerequisites
-    techPrerequisites = {
-        react: [
-            'Node.js >= 16.x installed',
-            'npm or yarn package manager',
-            'React project initialized (create-react-app, Vite, or Next.js)',
-            'TypeScript configured (if using TS)',
-        ],
-        node: [
-            'Node.js >= 16.x installed',
-            'npm/yarn/pnpm package manager',
-            'package.json initialized',
-        ],
-        typescript: [
-            'TypeScript installed',
-            'tsconfig.json configured',
-            'Build tooling setup (tsc, esbuild, swc)',
-        ],
-        database: [
-            'Database server running',
-            'Database connection credentials',
-            'Database client/ORM installed',
-            'Schema/migrations up to date',
-        ],
-        api: [
-            'API endpoint accessible',
-            'Authentication tokens/keys available',
-            'API documentation available',
-            'Rate limits understood',
-        ],
-        testing: [
-            'Test framework installed (Jest, Vitest, etc.)',
-            'Test configuration files present',
-            'Test database/mocks available',
-        ],
-        docker: [
-            'Docker installed and running',
-            'Docker Compose (if using)',
-            'Container registry access (if pulling images)',
-        ],
-        aws: [
-            'AWS CLI installed and configured',
-            'IAM credentials with appropriate permissions',
-            'AWS SDK installed',
-        ],
-        git: [
-            'Git installed',
-            'Repository cloned',
-            'Correct branch checked out',
-            'No uncommitted changes (or staged appropriately)',
-        ],
-    };
-    // Intent-specific prerequisites
-    intentPrerequisites = {
-        'code-generation': [
-            'Development environment set up',
-            'Required dependencies installed',
-            'Coding standards/style guide available',
-        ],
-        migration: [
-            'Backup of existing data/code',
-            'Migration plan documented',
-            'Rollback strategy defined',
-            'Downtime window scheduled (if applicable)',
-        ],
-        testing: [
-            'Code to be tested is implemented',
-            'Test data/fixtures available',
-            'CI/CD pipeline configured (for automated tests)',
-        ],
-        debugging: [
-            'Bug is reproducible',
-            'Relevant logs available',
-            'Debug tools configured',
-            'Access to failing environment',
-        ],
-        planning: [
-            'Requirements documented',
-            'Stakeholder input collected',
-            'Timeline/constraints known',
-        ],
-    };
-    apply(prompt, context) {
-        const lowerPrompt = prompt.toLowerCase();
-        // Check if prerequisites are already addressed
-        const hasPrerequisites = this.prerequisiteIndicators.some((indicator) => lowerPrompt.includes(indicator.toLowerCase()));
-        if (hasPrerequisites) {
-            return {
-                enhancedPrompt: prompt,
-                improvement: {
-                    dimension: 'completeness',
-                    description: 'Prerequisites already specified',
-                    impact: 'low',
-                },
-                applied: false,
-            };
-        }
-        // Detect technologies mentioned
-        const detectedTech = [];
-        const techKeywords = {
-            react: /\b(react|jsx|tsx|component|hook|useState|useEffect)\b/i,
-            node: /\b(node|express|koa|fastify|npm|yarn|pnpm)\b/i,
-            typescript: /\b(typescript|ts|tsx|type|interface)\b/i,
-            database: /\b(database|db|sql|postgres|mysql|mongo|redis|prisma|sequelize)\b/i,
-            api: /\b(api|rest|graphql|endpoint|fetch|axios|http)\b/i,
-            testing: /\b(test|jest|vitest|mocha|cypress|playwright)\b/i,
-            docker: /\b(docker|container|kubernetes|k8s|compose)\b/i,
-            aws: /\b(aws|s3|lambda|ec2|dynamodb|cloudformation)\b/i,
-            git: /\b(git|commit|branch|merge|pull request|pr)\b/i,
-        };
-        for (const [tech, regex] of Object.entries(techKeywords)) {
-            if (regex.test(prompt)) {
-                detectedTech.push(tech);
-            }
-        }
-        // Collect prerequisites
-        const prerequisites = [];
-        // Add intent-specific prerequisites
-        const intent = context.intent.primaryIntent;
-        const intentPrereqs = this.intentPrerequisites[intent] || [];
-        prerequisites.push(...intentPrereqs);
-        // Add tech-specific prerequisites
-        for (const tech of detectedTech.slice(0, 3)) {
-            // Limit to 3 technologies
-            const techPrereqs = this.techPrerequisites[tech] || [];
-            prerequisites.push(...techPrereqs.slice(0, 2)); // 2 per technology
-        }
-        // Deduplicate and limit
-        const uniquePrereqs = [...new Set(prerequisites)].slice(0, 8);
-        if (uniquePrereqs.length === 0) {
-            return {
-                enhancedPrompt: prompt,
-                improvement: {
-                    dimension: 'completeness',
-                    description: 'No specific prerequisites detected',
-                    impact: 'low',
-                },
-                applied: false,
-            };
-        }
-        // Build prerequisites section
-        const prereqSection = `
-
-## Prerequisites
-
-Before starting this task, ensure:
-${uniquePrereqs.map((p) => `- [ ] ${p}`).join('\n')}
-
-**Note**: Check prerequisites to avoid blockers during implementation.`;
-        return {
-            enhancedPrompt: prompt + prereqSection,
-            improvement: {
-                dimension: 'completeness',
-                description: `Added ${uniquePrereqs.length} prerequisites for ${detectedTech.join(', ') || intent}`,
-                impact: 'medium',
-            },
-            applied: true,
-        };
-    }
-}
-//# sourceMappingURL=prerequisite-identifier.js.map

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

@@ -1,24 +0,0 @@
-import { BasePattern, PatternScope, PatternPriority, PatternPhase, PatternConfigSchema } from './base-pattern.js';
-import { PromptIntent, PatternContext, PatternResult } from '../types.js';
-/**
- * v4.5 Pattern: Requirement Prioritizer
- *
- * Separates must-have from nice-to-have requirements in PRD content.
- * Helps clarify priorities and MVP scope.
- */
-export declare class RequirementPrioritizer extends BasePattern {
-    readonly id = "requirement-prioritizer";
-    readonly name = "Requirement Prioritizer";
-    readonly description = "Separates must-have from nice-to-have requirements";
-    readonly applicableIntents: PromptIntent[];
-    readonly scope: PatternScope;
-    readonly priority: PatternPriority;
-    readonly phases: PatternPhase[];
-    static readonly configSchema: PatternConfigSchema;
-    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

@@ -1,134 +0,0 @@
-import { BasePattern, } from './base-pattern.js';
-/**
- * v4.5 Pattern: Requirement Prioritizer
- *
- * Separates must-have from nice-to-have requirements in PRD content.
- * Helps clarify priorities and MVP scope.
- */
-export class RequirementPrioritizer extends BasePattern {
-    // -------------------------------------------------------------------------
-    // Pattern Metadata (v4.5 unified types)
-    // -------------------------------------------------------------------------
-    id = 'requirement-prioritizer';
-    name = 'Requirement Prioritizer';
-    description = 'Separates must-have from nice-to-have requirements';
-    applicableIntents = ['prd-generation', 'planning'];
-    scope = 'comprehensive';
-    priority = 7; // MEDIUM-HIGH - important enrichment
-    phases = ['question-validation', 'output-generation'];
-    // -------------------------------------------------------------------------
-    // Configuration Schema (v4.5)
-    // -------------------------------------------------------------------------
-    static configSchema = {
-        usePriorityLabels: {
-            type: 'boolean',
-            default: true,
-            description: 'Use P0/P1/P2 priority labels',
-        },
-    };
-    // -------------------------------------------------------------------------
-    // Pattern Application
-    // -------------------------------------------------------------------------
-    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/scope-definer.d.ts

@@ -1,26 +0,0 @@
-import { BasePattern, PatternScope, PatternPriority, PatternPhase, PatternConfigSchema } from './base-pattern.js';
-import { PromptIntent, PatternContext, PatternResult } from '../types.js';
-/**
- * v4.5 Pattern: Scope Definer
- *
- * Adds explicit scope boundaries to prevent scope creep
- * and clarify what is/isn't included.
- */
-export declare class ScopeDefiner extends BasePattern {
-    readonly id = "scope-definer";
-    readonly name = "Scope Definer";
-    readonly description = "Add explicit scope boundaries to prevent scope creep";
-    readonly applicableIntents: PromptIntent[];
-    readonly scope: PatternScope;
-    readonly priority: PatternPriority;
-    readonly phases: PatternPhase[];
-    static readonly configSchema: PatternConfigSchema;
-    apply(prompt: string, context: PatternContext): PatternResult;
-    private hasExistingScope;
-    private defineScope;
-    private extractInScope;
-    private identifyOutOfScope;
-    private identifyBoundaries;
-    private formatScopeSection;
-}
-//# sourceMappingURL=scope-definer.d.ts.map