clavix 4.11.2 → 5.0.0

package/dist/core/intelligence/patterns/structure-organizer.js

@@ -1,218 +0,0 @@
-import { BasePattern, } from './base-pattern.js';
-/**
- * v4.5 Pattern: Structure Organizer
- *
- * Reorders information logically following the flow:
- * Objective → Requirements → Technical Constraints → Expected Output → Success Criteria
- */
-export class StructureOrganizer extends BasePattern {
-    // -------------------------------------------------------------------------
-    // Pattern Metadata (v4.5 unified types)
-    // -------------------------------------------------------------------------
-    id = 'structure-organizer';
-    name = 'Structure Organizer';
-    description = 'Reorders information into logical sections';
-    applicableIntents = [
-        'code-generation',
-        'planning',
-        'refinement',
-        'debugging',
-        'documentation',
-    ];
-    scope = 'both';
-    priority = 8; // HIGH - core enhancement
-    phases = ['all'];
-    // -------------------------------------------------------------------------
-    // Configuration Schema (v4.5)
-    // -------------------------------------------------------------------------
-    static configSchema = {
-        addHeadersIfMissing: {
-            type: 'boolean',
-            default: true,
-            description: 'Add markdown headers if not present',
-        },
-        reorderSections: {
-            type: 'boolean',
-            default: true,
-            description: 'Reorder sections to follow logical flow',
-        },
-    };
-    // -------------------------------------------------------------------------
-    // Pattern Application
-    // -------------------------------------------------------------------------
-    apply(prompt, _context) {
-        // Detect existing sections
-        const sections = this.detectSections(prompt);
-        // If already well-structured, minimal changes
-        if (sections.length === 0 || this.isWellOrdered(sections)) {
-            const enhanced = this.addSectionHeaders(prompt);
-            return {
-                enhancedPrompt: enhanced,
-                improvement: {
-                    dimension: 'structure',
-                    description: 'Added section headers for clarity',
-                    impact: 'low',
-                },
-                applied: enhanced !== prompt,
-            };
-        }
-        // Extract content by type
-        const objective = this.extractObjective(prompt);
-        const requirements = this.extractRequirements(prompt);
-        const technical = this.extractTechnical(prompt);
-        const expectedOutput = this.extractExpectedOutput(prompt);
-        const successCriteria = this.extractSuccessCriteria(prompt);
-        const constraints = this.extractConstraints(prompt);
-        const other = this.extractOther(prompt, [
-            objective,
-            requirements,
-            technical,
-            expectedOutput,
-            successCriteria,
-            constraints,
-        ]);
-        // Build structured output
-        let structured = '';
-        let sectionsCount = 0;
-        if (objective) {
-            structured += '## Objective\n\n' + objective + '\n\n';
-            sectionsCount++;
-        }
-        if (requirements) {
-            structured += '## Requirements\n\n' + requirements + '\n\n';
-            sectionsCount++;
-        }
-        if (technical) {
-            structured += '## Technical Constraints\n\n' + technical + '\n\n';
-            sectionsCount++;
-        }
-        if (constraints) {
-            structured += '## Constraints\n\n' + constraints + '\n\n';
-            sectionsCount++;
-        }
-        if (expectedOutput) {
-            structured += '## Expected Output\n\n' + expectedOutput + '\n\n';
-            sectionsCount++;
-        }
-        if (successCriteria) {
-            structured += '## Success Criteria\n\n' + successCriteria + '\n\n';
-            sectionsCount++;
-        }
-        if (other) {
-            structured += other + '\n';
-        }
-        const enhanced = structured.trim();
-        return {
-            enhancedPrompt: enhanced,
-            improvement: {
-                dimension: 'structure',
-                description: `Reorganized content into ${sectionsCount} logical sections`,
-                impact: sectionsCount >= 4 ? 'high' : sectionsCount >= 2 ? 'medium' : 'low',
-            },
-            applied: true,
-        };
-    }
-    detectSections(prompt) {
-        const sectionMarkers = [
-            /^#+\s+.+$/gm, // Markdown headers
-            /^[A-Z][^.!?]+:$/gm, // "Objective:", "Requirements:"
-            /^\d+\.\s+[A-Z]/gm, // Numbered lists
-            /^[-*]\s+/gm, // Bullet points
-        ];
-        const sections = [];
-        for (const marker of sectionMarkers) {
-            const matches = prompt.match(marker);
-            if (matches) {
-                sections.push(...matches);
-            }
-        }
-        return sections;
-    }
-    isWellOrdered(sections) {
-        const idealOrder = ['objective', 'requirement', 'technical', 'constraint', 'output', 'success'];
-        let lastIndex = -1;
-        for (const section of sections) {
-            const sectionLower = section.toLowerCase();
-            const currentIndex = idealOrder.findIndex((keyword) => sectionLower.includes(keyword));
-            if (currentIndex !== -1) {
-                if (currentIndex < lastIndex) {
-                    return false; // Out of order
-                }
-                lastIndex = currentIndex;
-            }
-        }
-        return true;
-    }
-    isDisorganized(prompt) {
-        // Check for requirements before objective
-        const objectiveIndex = prompt.toLowerCase().indexOf('objective');
-        const requirementIndex = prompt.toLowerCase().indexOf('requirement');
-        if (objectiveIndex > 0 && requirementIndex > 0 && requirementIndex < objectiveIndex) {
-            return true;
-        }
-        // Check for output before requirements
-        const outputIndex = prompt.toLowerCase().indexOf('output');
-        if (outputIndex > 0 && requirementIndex > 0 && outputIndex < requirementIndex) {
-            return true;
-        }
-        return false;
-    }
-    extractObjective(prompt) {
-        const patterns = [
-            /(?:objective|goal|purpose|need to|want to)[:]\s*(.+?)(?:\n\n|$)/is,
-            /^(.{20,100}?)(?:\n|$)/i, // First sentence if no explicit objective
-        ];
-        for (const pattern of patterns) {
-            const match = prompt.match(pattern);
-            if (match) {
-                return match[1].trim();
-            }
-        }
-        return '';
-    }
-    extractRequirements(prompt) {
-        const pattern = /(?:requirements?|must have|need|should)[:]\s*(.+?)(?:\n\n|##|$)/is;
-        const match = prompt.match(pattern);
-        return match ? match[1].trim() : '';
-    }
-    extractTechnical(prompt) {
-        const pattern = /(?:technical|tech stack|technology|using|built? with)[:]\s*(.+?)(?:\n\n|##|$)/is;
-        const match = prompt.match(pattern);
-        return match ? match[1].trim() : '';
-    }
-    extractExpectedOutput(prompt) {
-        const pattern = /(?:expected output|output|result|deliverable)[:]\s*(.+?)(?:\n\n|##|$)/is;
-        const match = prompt.match(pattern);
-        return match ? match[1].trim() : '';
-    }
-    extractSuccessCriteria(prompt) {
-        const pattern = /(?:success criteria|success|criteria|measure)[:]\s*(.+?)(?:\n\n|##|$)/is;
-        const match = prompt.match(pattern);
-        return match ? match[1].trim() : '';
-    }
-    extractConstraints(prompt) {
-        const pattern = /(?:constraints?|limitations?|must not|cannot)[:]\s*(.+?)(?:\n\n|##|$)/is;
-        const match = prompt.match(pattern);
-        return match ? match[1].trim() : '';
-    }
-    extractOther(prompt, extracted) {
-        let remaining = prompt;
-        for (const section of extracted) {
-            if (section) {
-                remaining = remaining.replace(section, '');
-            }
-        }
-        remaining = remaining.replace(/#{1,6}\s*.+\n/g, ''); // Remove headers
-        remaining = remaining.replace(/\n{3,}/g, '\n\n'); // Normalize newlines
-        return remaining.trim();
-    }
-    addSectionHeaders(prompt) {
-        // If prompt already has headers, return as-is
-        if (prompt.match(/^#+\s+/m)) {
-            return prompt;
-        }
-        // Add a simple objective header
-        return '## Objective\n\n' + prompt;
-    }
-}
-//# sourceMappingURL=structure-organizer.js.map

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

@@ -1,22 +0,0 @@
-import { BasePattern, PatternScope, PatternPriority, PatternPhase, PatternConfigSchema } from './base-pattern.js';
-import { PatternContext, PatternResult, PromptIntent } from '../types.js';
-/**
- * v4.5 Pattern: Success Criteria Enforcer
- *
- * Ensures prompts include measurable success criteria. Agents need to know
- * when they've successfully completed a task - this pattern adds that clarity.
- */
-export declare class SuccessCriteriaEnforcer extends BasePattern {
-    readonly id = "success-criteria-enforcer";
-    readonly name = "Success Criteria Enforcer";
-    readonly description = "Adds measurable success criteria for task completion validation";
-    readonly applicableIntents: PromptIntent[];
-    readonly scope: PatternScope;
-    readonly priority: PatternPriority;
-    readonly phases: PatternPhase[];
-    static readonly configSchema: PatternConfigSchema;
-    private successIndicators;
-    private intentCriteria;
-    apply(prompt: string, context: PatternContext): PatternResult;
-}
-//# sourceMappingURL=success-criteria-enforcer.d.ts.map

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

@@ -1,165 +0,0 @@
-import { BasePattern, } from './base-pattern.js';
-/**
- * v4.5 Pattern: Success Criteria Enforcer
- *
- * Ensures prompts include measurable success criteria. Agents need to know
- * when they've successfully completed a task - this pattern adds that clarity.
- */
-export class SuccessCriteriaEnforcer extends BasePattern {
-    // -------------------------------------------------------------------------
-    // Pattern Metadata (v4.5 unified types)
-    // -------------------------------------------------------------------------
-    id = 'success-criteria-enforcer';
-    name = 'Success Criteria Enforcer';
-    description = 'Adds measurable success criteria for task completion validation';
-    applicableIntents = [
-        'code-generation',
-        'planning',
-        'refinement',
-        'debugging',
-        'testing',
-        'migration',
-        'prd-generation',
-    ];
-    scope = 'both';
-    priority = 7; // MEDIUM-HIGH - important enrichment
-    phases = ['all'];
-    // -------------------------------------------------------------------------
-    // Configuration Schema (v4.5)
-    // -------------------------------------------------------------------------
-    static configSchema = {
-        showCheckboxes: {
-            type: 'boolean',
-            default: true,
-            description: 'Show criteria as checkboxes for progress tracking',
-        },
-    };
-    // -------------------------------------------------------------------------
-    // Pattern Data
-    // -------------------------------------------------------------------------
-    // Indicators that success criteria already exist
-    successIndicators = [
-        'success criteria',
-        'acceptance criteria',
-        'done when',
-        'complete when',
-        'must pass',
-        'should pass',
-        'test coverage',
-        'meets requirements',
-        'criteria:',
-        'requirements:',
-        'must have',
-        'must include',
-        'validation:',
-        'verify that',
-        'ensure that',
-        'should be able to',
-    ];
-    // Intent-specific success criteria templates
-    intentCriteria = {
-        'code-generation': [
-            'Code compiles/transpiles without errors',
-            'All tests pass (if tests are written)',
-            'Follows project coding standards',
-            'No TypeScript/linting errors',
-            'Functionality matches requirements',
-            'Edge cases are handled',
-        ],
-        planning: [
-            'All requirements are addressed',
-            'Tasks are atomic and actionable',
-            'Dependencies are identified',
-            'Timeline/phases are realistic',
-            'Risks are documented',
-        ],
-        refinement: [
-            'Improved metrics (specify: performance, readability, etc.)',
-            'No regression in functionality',
-            'Tests still pass',
-            'Code review approved',
-        ],
-        debugging: [
-            'Bug is reproducible and root cause identified',
-            'Fix addresses root cause, not symptom',
-            'No new bugs introduced',
-            'Regression test added',
-        ],
-        testing: [
-            'Test coverage meets threshold (e.g., >80%)',
-            'All critical paths tested',
-            'Edge cases covered',
-            'Tests are deterministic (no flaky tests)',
-            'Test execution time is reasonable',
-        ],
-        migration: [
-            'All features work as before',
-            'No data loss',
-            'Performance is not degraded',
-            'Rollback plan exists',
-            'Documentation is updated',
-        ],
-        'prd-generation': [
-            'All sections are complete',
-            'Requirements are unambiguous',
-            'Technical constraints are specified',
-            'Success metrics are measurable',
-            'Scope is clearly defined',
-        ],
-        documentation: [
-            'All public APIs are documented',
-            'Examples are provided',
-            'Instructions are testable',
-            'No broken links',
-        ],
-        'security-review': [
-            'All OWASP Top 10 checked',
-            'Vulnerabilities are prioritized',
-            'Remediation steps are provided',
-            'No false positives',
-        ],
-        learning: [
-            'Concept is explained clearly',
-            'Examples demonstrate the concept',
-            'Reader can apply knowledge',
-        ],
-    };
-    apply(prompt, context) {
-        const lowerPrompt = prompt.toLowerCase();
-        // Check if success criteria already exist
-        const hasCriteria = this.successIndicators.some((indicator) => lowerPrompt.includes(indicator.toLowerCase()));
-        if (hasCriteria) {
-            return {
-                enhancedPrompt: prompt,
-                improvement: {
-                    dimension: 'completeness',
-                    description: 'Success criteria already specified',
-                    impact: 'low',
-                },
-                applied: false,
-            };
-        }
-        // Get intent-specific criteria
-        const intent = context.intent.primaryIntent;
-        const criteria = this.intentCriteria[intent] || this.intentCriteria['code-generation'];
-        // Build success criteria section
-        const criteriaSection = `
-
-## Success Criteria
-
-This task is complete when:
-${criteria.map((c) => `- [ ] ${c}`).join('\n')}
-
-**Tip**: Check off criteria as you complete them to track progress.`;
-        return {
-            enhancedPrompt: prompt + criteriaSection,
-            improvement: {
-                dimension: 'completeness',
-                description: `Added ${criteria.length} measurable success criteria for ${intent}`,
-                impact: 'medium',
-            },
-            applied: true,
-        };
-    }
-}
-//# sourceMappingURL=success-criteria-enforcer.js.map

package/dist/core/intelligence/patterns/success-metrics-enforcer.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: Success Metrics Enforcer
- *
- * Ensures measurable success criteria exist in PRD content.
- * Adds KPIs and metrics when missing.
- */
-export declare class SuccessMetricsEnforcer extends BasePattern {
-    readonly id = "success-metrics-enforcer";
-    readonly name = "Success Metrics Enforcer";
-    readonly description = "Ensures measurable success criteria exist";
-    readonly applicableIntents: PromptIntent[];
-    readonly scope: PatternScope;
-    readonly priority: PatternPriority;
-    readonly phases: PatternPhase[];
-    static readonly configSchema: PatternConfigSchema;
-    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

@@ -1,165 +0,0 @@
-import { BasePattern, } from './base-pattern.js';
-/**
- * v4.5 Pattern: Success Metrics Enforcer
- *
- * Ensures measurable success criteria exist in PRD content.
- * Adds KPIs and metrics when missing.
- */
-export class SuccessMetricsEnforcer extends BasePattern {
-    // -------------------------------------------------------------------------
-    // Pattern Metadata (v4.5 unified types)
-    // -------------------------------------------------------------------------
-    id = 'success-metrics-enforcer';
-    name = 'Success Metrics Enforcer';
-    description = 'Ensures measurable success criteria exist';
-    applicableIntents = ['prd-generation', 'planning'];
-    scope = 'comprehensive';
-    priority = 7; // MEDIUM-HIGH - important enrichment
-    phases = ['question-validation', 'output-generation'];
-    // -------------------------------------------------------------------------
-    // Configuration Schema (v4.5)
-    // -------------------------------------------------------------------------
-    static configSchema = {
-        maxKPIs: {
-            type: 'number',
-            default: 4,
-            description: 'Maximum number of KPIs to suggest',
-            validation: { min: 1, max: 8 },
-        },
-        includeMeasurementGuidance: {
-            type: 'boolean',
-            default: true,
-            description: 'Include guidance on how to measure success',
-        },
-    };
-    // -------------------------------------------------------------------------
-    // Pattern Application
-    // -------------------------------------------------------------------------
-    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/technical-context-enricher.d.ts

@@ -1,25 +0,0 @@
-import { BasePattern, PatternScope, PatternPriority, PatternPhase, PatternConfigSchema, PatternDependency } from './base-pattern.js';
-import { PatternContext, PatternResult, PromptIntent } from '../types.js';
-/**
- * v4.5 Pattern: Technical Context Enricher
- *
- * Adds missing technical context (language, framework, versions).
- * Detects technologies and suggests version specifications.
- */
-export declare class TechnicalContextEnricher extends BasePattern {
-    readonly id = "technical-context-enricher";
-    readonly name = "Technical Context Enricher";
-    readonly description = "Adds missing technical context (language, framework, versions)";
-    readonly applicableIntents: PromptIntent[];
-    readonly scope: PatternScope;
-    readonly priority: PatternPriority;
-    readonly phases: PatternPhase[];
-    readonly dependencies: PatternDependency;
-    static readonly configSchema: PatternConfigSchema;
-    apply(prompt: string, context: PatternContext): PatternResult;
-    private hasTechnicalContext;
-    private detectLanguage;
-    private detectFramework;
-    private hasVersionInfo;
-}
-//# sourceMappingURL=technical-context-enricher.d.ts.map