clavix 4.11.2 → 5.0.0

package/dist/core/intelligence/patterns/scope-definer.js

@@ -1,236 +0,0 @@
-import { BasePattern, } from './base-pattern.js';
-/**
- * v4.5 Pattern: Scope Definer
- *
- * Adds explicit scope boundaries to prevent scope creep
- * and clarify what is/isn't included.
- */
-export class ScopeDefiner extends BasePattern {
-    // -------------------------------------------------------------------------
-    // Pattern Metadata (v4.5 unified types)
-    // -------------------------------------------------------------------------
-    id = 'scope-definer';
-    name = 'Scope Definer';
-    description = 'Add explicit scope boundaries to prevent scope creep';
-    applicableIntents = [
-        'code-generation',
-        'planning',
-        'prd-generation',
-        'migration',
-        'documentation',
-    ];
-    scope = 'comprehensive';
-    priority = 5; // MEDIUM-LOW - supplementary
-    phases = ['all'];
-    // -------------------------------------------------------------------------
-    // Configuration Schema (v4.5)
-    // -------------------------------------------------------------------------
-    static configSchema = {
-        maxInScopeItems: {
-            type: 'number',
-            default: 5,
-            description: 'Maximum number of in-scope items to list',
-            validation: { min: 1, max: 10 },
-        },
-        maxOutOfScopeItems: {
-            type: 'number',
-            default: 5,
-            description: 'Maximum number of out-of-scope items to list',
-            validation: { min: 1, max: 10 },
-        },
-    };
-    // -------------------------------------------------------------------------
-    // Pattern Application
-    // -------------------------------------------------------------------------
-    apply(prompt, context) {
-        // Check if prompt already has scope definition
-        if (this.hasExistingScope(prompt)) {
-            return {
-                enhancedPrompt: prompt,
-                improvement: {
-                    dimension: 'completeness',
-                    description: 'Scope already defined',
-                    impact: 'low',
-                },
-                applied: false,
-            };
-        }
-        const scope = this.defineScope(prompt, context.intent.primaryIntent);
-        const scopeSection = this.formatScopeSection(scope);
-        const enhancedPrompt = `${prompt}\n\n${scopeSection}`;
-        return {
-            enhancedPrompt,
-            improvement: {
-                dimension: 'completeness',
-                description: 'Added explicit scope boundaries',
-                impact: 'medium',
-            },
-            applied: true,
-        };
-    }
-    hasExistingScope(prompt) {
-        const scopeIndicators = [
-            'out of scope',
-            'not included',
-            'scope:',
-            'in scope',
-            'excluded',
-            'will not',
-            "won't include",
-            'not part of',
-        ];
-        const lowerPrompt = prompt.toLowerCase();
-        return scopeIndicators.some((indicator) => lowerPrompt.includes(indicator));
-    }
-    defineScope(prompt, intent) {
-        const lowerPrompt = prompt.toLowerCase();
-        // Extract what's explicitly requested
-        const inScope = this.extractInScope(lowerPrompt, intent);
-        // Identify common out-of-scope items based on context
-        const outOfScope = this.identifyOutOfScope(lowerPrompt, intent);
-        // Identify boundaries
-        const boundaries = this.identifyBoundaries(lowerPrompt, intent);
-        return { inScope, outOfScope, boundaries };
-    }
-    extractInScope(prompt, intent) {
-        const inScope = [];
-        // Look for explicit requirements
-        const requirementPatterns = [
-            /(?:need|want|require|should have|must have)\s+(.+?)(?:\.|,|$)/gi,
-            /(?:create|build|implement|add)\s+(?:a\s+)?(.+?)(?:\.|,|$)/gi,
-        ];
-        requirementPatterns.forEach((pattern) => {
-            let match;
-            while ((match = pattern.exec(prompt)) !== null) {
-                const requirement = match[1].trim();
-                if (requirement.length > 3 && requirement.length < 100) {
-                    inScope.push(requirement);
-                }
-            }
-        });
-        // Intent-specific in-scope items
-        switch (intent) {
-            case 'code-generation':
-                if (this.hasSection(prompt, ['component', 'ui'])) {
-                    inScope.push('Component implementation with specified functionality');
-                }
-                if (this.hasSection(prompt, ['api', 'endpoint'])) {
-                    inScope.push('API endpoint implementation');
-                }
-                break;
-            case 'planning':
-                inScope.push('High-level architecture design');
-                inScope.push('Task breakdown and sequencing');
-                break;
-            case 'migration':
-                inScope.push('Data migration from source to target');
-                inScope.push('Functionality preservation');
-                break;
-        }
-        return [...new Set(inScope)].slice(0, 5);
-    }
-    identifyOutOfScope(prompt, intent) {
-        const outOfScope = [];
-        // Common out-of-scope items by intent
-        switch (intent) {
-            case 'code-generation':
-                outOfScope.push('Deployment and CI/CD configuration');
-                outOfScope.push('Production infrastructure setup');
-                if (!this.hasSection(prompt, ['test'])) {
-                    outOfScope.push('Comprehensive test suite (basic tests only)');
-                }
-                if (!this.hasSection(prompt, ['doc', 'readme'])) {
-                    outOfScope.push('Extensive documentation');
-                }
-                break;
-            case 'planning':
-                outOfScope.push('Actual implementation code');
-                outOfScope.push('Detailed technical specifications');
-                outOfScope.push('Resource allocation and team assignments');
-                break;
-            case 'migration':
-                outOfScope.push('New feature development');
-                outOfScope.push('Performance optimization beyond parity');
-                outOfScope.push('Refactoring unrelated code');
-                break;
-            case 'documentation':
-                outOfScope.push('Code implementation changes');
-                outOfScope.push('Architectural modifications');
-                break;
-            case 'prd-generation':
-                outOfScope.push('Technical implementation details');
-                outOfScope.push('Code or pseudocode');
-                outOfScope.push('Database schema design');
-                break;
-        }
-        // Domain-specific exclusions
-        if (this.hasSection(prompt, ['frontend', 'ui', 'component'])) {
-            if (!this.hasSection(prompt, ['backend', 'api', 'server'])) {
-                outOfScope.push('Backend/API implementation');
-            }
-        }
-        if (this.hasSection(prompt, ['backend', 'api', 'server'])) {
-            if (!this.hasSection(prompt, ['frontend', 'ui'])) {
-                outOfScope.push('Frontend/UI implementation');
-            }
-        }
-        return [...new Set(outOfScope)].slice(0, 5);
-    }
-    identifyBoundaries(prompt, intent) {
-        const boundaries = [];
-        // Technical boundaries
-        if (this.hasSection(prompt, ['component', 'module', 'service'])) {
-            boundaries.push('Limited to specified component/module boundaries');
-        }
-        // Integration boundaries
-        if (this.hasSection(prompt, ['integration', 'third-party', 'external'])) {
-            boundaries.push('External integrations assumed to be available and configured');
-        }
-        // Data boundaries
-        if (this.hasSection(prompt, ['database', 'data', 'storage'])) {
-            boundaries.push('Database schema assumed to exist or specified separately');
-        }
-        // Auth boundaries
-        if (this.hasSection(prompt, ['auth', 'user', 'login'])) {
-            boundaries.push('Authentication system assumed to be in place');
-        }
-        // Intent-specific boundaries
-        switch (intent) {
-            case 'code-generation':
-                boundaries.push('Following existing project conventions and patterns');
-                break;
-            case 'migration':
-                boundaries.push('Maintaining backward compatibility where specified');
-                break;
-            case 'testing':
-                boundaries.push('Testing within unit/integration test scope');
-                break;
-        }
-        return [...new Set(boundaries)].slice(0, 4);
-    }
-    formatScopeSection(scope) {
-        const lines = ['### Scope Definition', ''];
-        if (scope.inScope.length > 0) {
-            lines.push('**In Scope:**');
-            scope.inScope.forEach((item) => {
-                lines.push(`✓ ${item}`);
-            });
-            lines.push('');
-        }
-        if (scope.outOfScope.length > 0) {
-            lines.push('**Out of Scope:**');
-            scope.outOfScope.forEach((item) => {
-                lines.push(`✗ ${item}`);
-            });
-            lines.push('');
-        }
-        if (scope.boundaries.length > 0) {
-            lines.push('**Boundaries & Assumptions:**');
-            scope.boundaries.forEach((item) => {
-                lines.push(`• ${item}`);
-            });
-        }
-        return lines.join('\n');
-    }
-}
-//# sourceMappingURL=scope-definer.js.map

package/dist/core/intelligence/patterns/step-decomposer.d.ts

@@ -1,31 +0,0 @@
-import { BasePattern, PatternScope, PatternPriority, PatternPhase, PatternConfigSchema } from './base-pattern.js';
-import { PromptIntent, PatternContext, PatternResult } from '../types.js';
-/**
- * v4.5 Pattern: Step-by-Step Decomposer
- *
- * Breaks complex prompts into clear sequential steps.
- * Applicable in both fast and deep modes.
- */
-export declare class StepDecomposer extends BasePattern {
-    readonly id = "step-decomposer";
-    readonly name = "Step-by-Step Decomposer";
-    readonly description = "Break complex prompts into clear sequential steps";
-    readonly applicableIntents: PromptIntent[];
-    readonly scope: PatternScope;
-    readonly priority: PatternPriority;
-    readonly phases: PatternPhase[];
-    static readonly configSchema: PatternConfigSchema;
-    apply(prompt: string, context: PatternContext): PatternResult;
-    private needsDecomposition;
-    private hasSteps;
-    private decompose;
-    private decomposeCodeGeneration;
-    private decomposePlanning;
-    private decomposeMigration;
-    private decomposeTesting;
-    private decomposeDebugging;
-    private decomposeDocumentation;
-    private decomposeGeneric;
-    private formatStepsSection;
-}
-//# sourceMappingURL=step-decomposer.d.ts.map

package/dist/core/intelligence/patterns/step-decomposer.js

@@ -1,242 +0,0 @@
-import { BasePattern, } from './base-pattern.js';
-/**
- * v4.5 Pattern: Step-by-Step Decomposer
- *
- * Breaks complex prompts into clear sequential steps.
- * Applicable in both fast and deep modes.
- */
-export class StepDecomposer extends BasePattern {
-    // -------------------------------------------------------------------------
-    // Pattern Metadata (v4.5 unified types)
-    // -------------------------------------------------------------------------
-    id = 'step-decomposer';
-    name = 'Step-by-Step Decomposer';
-    description = 'Break complex prompts into clear sequential steps';
-    applicableIntents = [
-        'code-generation',
-        'planning',
-        'migration',
-        'testing',
-        'debugging',
-        'documentation',
-    ];
-    scope = 'both';
-    priority = 5; // MEDIUM-LOW - supplementary
-    phases = ['all'];
-    // -------------------------------------------------------------------------
-    // Configuration Schema (v4.5)
-    // -------------------------------------------------------------------------
-    static configSchema = {
-        minWordsForDecomposition: {
-            type: 'number',
-            default: 100,
-            description: 'Minimum word count before decomposition is applied',
-            validation: { min: 50, max: 500 },
-        },
-    };
-    // -------------------------------------------------------------------------
-    // Pattern Application
-    // -------------------------------------------------------------------------
-    apply(prompt, context) {
-        // Check if prompt is complex enough to benefit from decomposition
-        if (!this.needsDecomposition(prompt)) {
-            return {
-                enhancedPrompt: prompt,
-                improvement: {
-                    dimension: 'structure',
-                    description: 'Prompt is simple enough, no decomposition needed',
-                    impact: 'low',
-                },
-                applied: false,
-            };
-        }
-        // Check if already has steps
-        if (this.hasSteps(prompt)) {
-            return {
-                enhancedPrompt: prompt,
-                improvement: {
-                    dimension: 'structure',
-                    description: 'Prompt already has step structure',
-                    impact: 'low',
-                },
-                applied: false,
-            };
-        }
-        const steps = this.decompose(prompt, context.intent.primaryIntent);
-        if (steps.length < 2) {
-            return {
-                enhancedPrompt: prompt,
-                improvement: {
-                    dimension: 'structure',
-                    description: 'Could not identify multiple steps',
-                    impact: 'low',
-                },
-                applied: false,
-            };
-        }
-        const stepsSection = this.formatStepsSection(steps);
-        const enhancedPrompt = `${prompt}\n\n${stepsSection}`;
-        return {
-            enhancedPrompt,
-            improvement: {
-                dimension: 'structure',
-                description: `Decomposed into ${steps.length} sequential steps`,
-                impact: 'high',
-            },
-            applied: true,
-        };
-    }
-    needsDecomposition(prompt) {
-        // Complex if:
-        // - Contains multiple actions (and, then, also, after)
-        // - Has multiple requirements listed
-        // - Is longer than 100 words
-        const wordCount = this.countWords(prompt);
-        const hasMultipleActions = /\b(and|then|also|after|next|finally|additionally)\b/gi.test(prompt);
-        const hasMultipleRequirements = (prompt.match(/[-•*]\s+/g) || []).length >= 2;
-        return wordCount > 100 || hasMultipleActions || hasMultipleRequirements;
-    }
-    hasSteps(prompt) {
-        // Check for existing step indicators
-        const stepPatterns = [
-            /step\s*[1-9]/i,
-            /^\s*[1-9]\.\s+/m,
-            /first[\s,].*second[\s,]/i,
-            /phase\s*[1-9]/i,
-        ];
-        return stepPatterns.some((pattern) => pattern.test(prompt));
-    }
-    decompose(prompt, intent) {
-        const steps = [];
-        const lowerPrompt = prompt.toLowerCase();
-        // Intent-specific decomposition
-        switch (intent) {
-            case 'code-generation':
-                steps.push(...this.decomposeCodeGeneration(lowerPrompt));
-                break;
-            case 'planning':
-                steps.push(...this.decomposePlanning(lowerPrompt));
-                break;
-            case 'migration':
-                steps.push(...this.decomposeMigration(lowerPrompt));
-                break;
-            case 'testing':
-                steps.push(...this.decomposeTesting(lowerPrompt));
-                break;
-            case 'debugging':
-                steps.push(...this.decomposeDebugging(lowerPrompt));
-                break;
-            case 'documentation':
-                steps.push(...this.decomposeDocumentation(lowerPrompt));
-                break;
-            default:
-                steps.push(...this.decomposeGeneric(lowerPrompt));
-        }
-        return steps;
-    }
-    decomposeCodeGeneration(prompt) {
-        const steps = [];
-        // Standard code generation workflow
-        if (this.hasSection(prompt, ['component', 'ui', 'interface'])) {
-            steps.push({ description: 'Define component interface and props' });
-            steps.push({ description: 'Implement core component logic' });
-            steps.push({ description: 'Add styling and responsive design' });
-            steps.push({ description: 'Add error handling and edge cases' });
-            steps.push({ description: 'Write unit tests' });
-        }
-        else if (this.hasSection(prompt, ['api', 'endpoint', 'route'])) {
-            steps.push({ description: 'Define API contract (request/response)' });
-            steps.push({ description: 'Implement endpoint handler' });
-            steps.push({ description: 'Add input validation' });
-            steps.push({ description: 'Implement error handling' });
-            steps.push({ description: 'Add authentication/authorization if needed' });
-            steps.push({ description: 'Write tests' });
-        }
-        else if (this.hasSection(prompt, ['function', 'utility', 'helper'])) {
-            steps.push({ description: 'Define function signature and types' });
-            steps.push({ description: 'Implement core logic' });
-            steps.push({ description: 'Handle edge cases' });
-            steps.push({ description: 'Add documentation' });
-            steps.push({ description: 'Write tests' });
-        }
-        else {
-            steps.push({ description: 'Understand requirements and define interface' });
-            steps.push({ description: 'Implement core functionality' });
-            steps.push({ description: 'Add error handling' });
-            steps.push({ description: 'Test and validate' });
-        }
-        return steps;
-    }
-    decomposePlanning(_prompt) {
-        return [
-            { description: 'Clarify goals and success criteria' },
-            { description: 'Identify key components and dependencies' },
-            { description: 'Define architecture and data flow' },
-            { description: 'Break down into implementable tasks' },
-            { description: 'Identify risks and mitigation strategies' },
-            { description: 'Create timeline and milestones' },
-        ];
-    }
-    decomposeMigration(_prompt) {
-        return [
-            { description: 'Assess current state and document existing behavior' },
-            { description: 'Define target state and requirements' },
-            { description: 'Create migration plan with rollback strategy' },
-            { description: 'Set up parallel environment for testing' },
-            { description: 'Migrate data in stages' },
-            { description: 'Validate functionality and performance' },
-            { description: 'Switch traffic and monitor' },
-            { description: 'Decommission old system after stabilization' },
-        ];
-    }
-    decomposeTesting(_prompt) {
-        return [
-            { description: 'Identify test cases from requirements' },
-            { description: 'Set up test environment and fixtures' },
-            { description: 'Write happy path tests' },
-            { description: 'Write edge case tests' },
-            { description: 'Write error scenario tests' },
-            { description: 'Verify coverage meets requirements' },
-            { description: 'Review and refactor tests for maintainability' },
-        ];
-    }
-    decomposeDebugging(_prompt) {
-        return [
-            { description: 'Reproduce the bug consistently' },
-            { description: 'Gather error logs and stack traces' },
-            { description: 'Isolate the problem area' },
-            { description: 'Form hypothesis about root cause' },
-            { description: 'Test hypothesis with targeted changes' },
-            { description: 'Implement fix' },
-            { description: 'Verify fix resolves issue without regression' },
-            { description: 'Add test to prevent recurrence' },
-        ];
-    }
-    decomposeDocumentation(_prompt) {
-        return [
-            { description: 'Identify target audience and their needs' },
-            { description: 'Outline document structure' },
-            { description: 'Write introduction and overview' },
-            { description: 'Document main content with examples' },
-            { description: 'Add troubleshooting/FAQ section' },
-            { description: 'Review for accuracy and clarity' },
-        ];
-    }
-    decomposeGeneric(_prompt) {
-        return [
-            { description: 'Understand and clarify requirements' },
-            { description: 'Plan approach and identify dependencies' },
-            { description: 'Execute main task' },
-            { description: 'Validate results' },
-            { description: 'Document and finalize' },
-        ];
-    }
-    formatStepsSection(steps) {
-        const lines = ['### Implementation Steps', ''];
-        steps.forEach((step, index) => {
-            lines.push(`${index + 1}. ${step.description}`);
-        });
-        return lines.join('\n');
-    }
-}
-//# sourceMappingURL=step-decomposer.js.map

package/dist/core/intelligence/patterns/structure-organizer.d.ts

@@ -1,31 +0,0 @@
-import { BasePattern, PatternScope, PatternPriority, PatternPhase, PatternConfigSchema } from './base-pattern.js';
-import { PatternContext, PatternResult, PromptIntent } from '../types.js';
-/**
- * v4.5 Pattern: Structure Organizer
- *
- * Reorders information logically following the flow:
- * Objective → Requirements → Technical Constraints → Expected Output → Success Criteria
- */
-export declare class StructureOrganizer extends BasePattern {
-    readonly id = "structure-organizer";
-    readonly name = "Structure Organizer";
-    readonly description = "Reorders information into logical sections";
-    readonly applicableIntents: PromptIntent[];
-    readonly scope: PatternScope;
-    readonly priority: PatternPriority;
-    readonly phases: PatternPhase[];
-    static readonly configSchema: PatternConfigSchema;
-    apply(prompt: string, _context: PatternContext): PatternResult;
-    private detectSections;
-    private isWellOrdered;
-    private isDisorganized;
-    private extractObjective;
-    private extractRequirements;
-    private extractTechnical;
-    private extractExpectedOutput;
-    private extractSuccessCriteria;
-    private extractConstraints;
-    private extractOther;
-    private addSectionHeaders;
-}
-//# sourceMappingURL=structure-organizer.d.ts.map