clavix 4.12.0 → 5.0.0

package/dist/core/intelligence/patterns/alternative-phrasing-generator.js

@@ -1,239 +0,0 @@
-import { BasePattern, } from './base-pattern.js';
-/**
- * v4.5 Pattern: Alternative Phrasing Generator
- *
- * Generates 2-3 alternative prompt structures to give users options
- * for different approaches to the same request.
- */
-export class AlternativePhrasingGenerator extends BasePattern {
-    // -------------------------------------------------------------------------
-    // Pattern Metadata (v4.5 unified types)
-    // -------------------------------------------------------------------------
-    id = 'alternative-phrasing-generator';
-    name = 'Alternative Phrasing Generator';
-    description = 'Generate alternative prompt structures for different approaches';
-    applicableIntents = [
-        'code-generation',
-        'planning',
-        'debugging',
-        'testing',
-        'migration',
-        'security-review',
-        'documentation',
-    ];
-    scope = 'comprehensive';
-    priority = 3; // VERY LOW - final touches
-    phases = ['all'];
-    // -------------------------------------------------------------------------
-    // Configuration Schema (v4.5)
-    // -------------------------------------------------------------------------
-    static configSchema = {
-        maxAlternatives: {
-            type: 'number',
-            default: 3,
-            description: 'Maximum number of alternative approaches to generate',
-            validation: { min: 1, max: 5 },
-        },
-    };
-    // -------------------------------------------------------------------------
-    // Pattern Application
-    // -------------------------------------------------------------------------
-    apply(prompt, context) {
-        const alternatives = this.generateAlternatives(prompt, context.intent.primaryIntent);
-        if (alternatives.length === 0) {
-            return {
-                enhancedPrompt: prompt,
-                improvement: {
-                    dimension: 'structure',
-                    description: 'No alternative phrasings needed',
-                    impact: 'low',
-                },
-                applied: false,
-            };
-        }
-        // Append alternatives section to the prompt
-        const alternativesSection = this.formatAlternativesSection(alternatives);
-        const enhancedPrompt = `${prompt}\n\n${alternativesSection}`;
-        return {
-            enhancedPrompt,
-            improvement: {
-                dimension: 'structure',
-                description: `Generated ${alternatives.length} alternative approaches`,
-                impact: 'medium',
-            },
-            applied: true,
-        };
-    }
-    generateAlternatives(prompt, intent) {
-        const alternatives = [];
-        // Intent-specific alternative generation
-        switch (intent) {
-            case 'code-generation':
-                alternatives.push(...this.generateCodeAlternatives(prompt));
-                break;
-            case 'planning':
-                alternatives.push(...this.generatePlanningAlternatives(prompt));
-                break;
-            case 'debugging':
-                alternatives.push(...this.generateDebuggingAlternatives(prompt));
-                break;
-            case 'testing':
-                alternatives.push(...this.generateTestingAlternatives(prompt));
-                break;
-            case 'migration':
-                alternatives.push(...this.generateMigrationAlternatives(prompt));
-                break;
-            case 'security-review':
-                alternatives.push(...this.generateSecurityAlternatives(prompt));
-                break;
-            case 'documentation':
-                alternatives.push(...this.generateDocumentationAlternatives(prompt));
-                break;
-        }
-        return alternatives.slice(0, 3); // Max 3 alternatives
-    }
-    generateCodeAlternatives(_prompt) {
-        return [
-            {
-                title: 'Functional Decomposition',
-                description: 'Break down into discrete functions with clear interfaces',
-                bestFor: 'Step-by-step implementation, clarity on sequence',
-            },
-            {
-                title: 'Test-Driven Approach',
-                description: 'Define expected behavior through tests first',
-                bestFor: 'When requirements are clear and testable',
-            },
-            {
-                title: 'Example-Driven',
-                description: 'Provide concrete input/output examples',
-                bestFor: 'When you have reference implementations',
-            },
-        ];
-    }
-    generatePlanningAlternatives(_prompt) {
-        return [
-            {
-                title: 'Top-Down Design',
-                description: 'Start with high-level architecture, then decompose',
-                bestFor: 'Complex systems with clear boundaries',
-            },
-            {
-                title: 'User Story Mapping',
-                description: 'Organize around user journeys and value delivery',
-                bestFor: 'User-facing features and workflows',
-            },
-            {
-                title: 'Domain-Driven Approach',
-                description: 'Model based on business domain concepts',
-                bestFor: 'Business logic-heavy applications',
-            },
-        ];
-    }
-    generateDebuggingAlternatives(_prompt) {
-        return [
-            {
-                title: 'Binary Search',
-                description: 'Isolate the problem by eliminating half the code at a time',
-                bestFor: 'When the bug location is unknown',
-            },
-            {
-                title: 'Trace Analysis',
-                description: 'Follow data flow through the system step by step',
-                bestFor: 'Data transformation or state issues',
-            },
-            {
-                title: 'Hypothesis Testing',
-                description: 'Form specific hypotheses and test each one',
-                bestFor: 'Complex, intermittent, or hard-to-reproduce bugs',
-            },
-        ];
-    }
-    generateTestingAlternatives(_prompt) {
-        return [
-            {
-                title: 'Behavior-Driven',
-                description: 'Write tests as specifications of expected behavior',
-                bestFor: 'Feature validation and acceptance testing',
-            },
-            {
-                title: 'Property-Based',
-                description: 'Define properties that should hold for any input',
-                bestFor: 'Edge cases and data validation',
-            },
-            {
-                title: 'Snapshot Testing',
-                description: 'Capture and compare output snapshots',
-                bestFor: 'UI components and serializable outputs',
-            },
-        ];
-    }
-    generateMigrationAlternatives(_prompt) {
-        return [
-            {
-                title: 'Big Bang Migration',
-                description: 'Complete migration in one release',
-                bestFor: 'Small systems or when downtime is acceptable',
-            },
-            {
-                title: 'Strangler Fig Pattern',
-                description: 'Gradually replace old system piece by piece',
-                bestFor: 'Large systems requiring zero downtime',
-            },
-            {
-                title: 'Parallel Running',
-                description: 'Run both systems simultaneously and compare',
-                bestFor: 'Critical systems requiring validation',
-            },
-        ];
-    }
-    generateSecurityAlternatives(_prompt) {
-        return [
-            {
-                title: 'Threat Modeling',
-                description: 'Identify attack surfaces and threat actors first',
-                bestFor: 'Comprehensive security assessment',
-            },
-            {
-                title: 'OWASP Checklist',
-                description: 'Systematic check against common vulnerabilities',
-                bestFor: 'Web application security review',
-            },
-            {
-                title: 'Attack Simulation',
-                description: 'Think like an attacker, test exploitability',
-                bestFor: 'Penetration testing mindset',
-            },
-        ];
-    }
-    generateDocumentationAlternatives(_prompt) {
-        return [
-            {
-                title: 'Tutorial Style',
-                description: 'Step-by-step guide with examples',
-                bestFor: 'Onboarding and learning',
-            },
-            {
-                title: 'Reference Format',
-                description: 'Comprehensive API/function reference',
-                bestFor: 'Quick lookup and experienced users',
-            },
-            {
-                title: 'Conceptual Overview',
-                description: 'Explain the "why" and mental models',
-                bestFor: 'Understanding architecture and design decisions',
-            },
-        ];
-    }
-    formatAlternativesSection(alternatives) {
-        const lines = ['### Alternative Approaches', ''];
-        alternatives.forEach((alt, index) => {
-            lines.push(`**${index + 1}. ${alt.title}**`);
-            lines.push(`   ${alt.description}`);
-            lines.push(`   → Best for: ${alt.bestFor}`);
-            lines.push('');
-        });
-        return lines.join('\n');
-    }
-}
-//# sourceMappingURL=alternative-phrasing-generator.js.map

package/dist/core/intelligence/patterns/ambiguity-detector.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: Ambiguity Detector
- *
- * Identifies and clarifies ambiguous terms, vague references, and unclear
- * specifications in prompts. Helps agents understand exactly what's needed.
- */
-export declare class AmbiguityDetector extends BasePattern {
-    readonly id = "ambiguity-detector";
-    readonly name = "Ambiguity Detector";
-    readonly description = "Identifies and clarifies ambiguous terms and vague references";
-    readonly applicableIntents: PromptIntent[];
-    readonly scope: PatternScope;
-    readonly priority: PatternPriority;
-    readonly phases: PatternPhase[];
-    static readonly configSchema: PatternConfigSchema;
-    private ambiguousTerms;
-    private vaguePatterns;
-    apply(prompt: string, _context: PatternContext): PatternResult;
-}
-//# sourceMappingURL=ambiguity-detector.d.ts.map

package/dist/core/intelligence/patterns/ambiguity-detector.js

@@ -1,196 +0,0 @@
-import { BasePattern, } from './base-pattern.js';
-/**
- * v4.5 Pattern: Ambiguity Detector
- *
- * Identifies and clarifies ambiguous terms, vague references, and unclear
- * specifications in prompts. Helps agents understand exactly what's needed.
- */
-export class AmbiguityDetector extends BasePattern {
-    // -------------------------------------------------------------------------
-    // Pattern Metadata (v4.5 unified types)
-    // -------------------------------------------------------------------------
-    id = 'ambiguity-detector';
-    name = 'Ambiguity Detector';
-    description = 'Identifies and clarifies ambiguous terms and vague references';
-    applicableIntents = [
-        'code-generation',
-        'planning',
-        'refinement',
-        'debugging',
-        'documentation',
-        'prd-generation',
-        'testing',
-        'migration',
-    ];
-    scope = 'both';
-    priority = 9; // VERY HIGH - structural integrity
-    phases = ['all'];
-    // -------------------------------------------------------------------------
-    // Configuration Schema (v4.5)
-    // -------------------------------------------------------------------------
-    static configSchema = {
-        checkVaguePatterns: {
-            type: 'boolean',
-            default: true,
-            description: 'Check for vague phrases like "should work", "properly", etc.',
-        },
-        checkUndefinedPronouns: {
-            type: 'boolean',
-            default: true,
-            description: 'Check for unclear pronoun references',
-        },
-        maxClarifications: {
-            type: 'number',
-            default: 10,
-            description: 'Maximum number of clarifications to add',
-            validation: { min: 1, max: 20 },
-        },
-    };
-    // -------------------------------------------------------------------------
-    // Pattern Data
-    // -------------------------------------------------------------------------
-    // Common ambiguous terms that need clarification
-    ambiguousTerms = {
-        // Generic terms needing specificity
-        app: ['web app', 'mobile app', 'desktop app', 'CLI tool'],
-        system: ['backend system', 'frontend system', 'full-stack system', 'microservice'],
-        feature: ['user-facing feature', 'backend feature', 'API endpoint', 'UI component'],
-        component: ['React component', 'Vue component', 'service component', 'module'],
-        service: ['REST API', 'GraphQL API', 'background worker', 'microservice'],
-        database: ['PostgreSQL', 'MongoDB', 'MySQL', 'SQLite', 'Redis'],
-        authentication: ['OAuth', 'JWT', 'session-based', 'API keys', 'social login'],
-        cache: ['in-memory cache', 'Redis cache', 'CDN cache', 'browser cache'],
-        storage: ['local storage', 'cloud storage', 'file system', 'object storage'],
-        user: ['end user', 'admin user', 'API consumer', 'authenticated user'],
-        // Action verbs needing clarification
-        create: ['generate', 'implement', 'design', 'scaffold'],
-        update: ['modify', 'patch', 'replace', 'extend'],
-        fix: ['debug', 'patch', 'refactor', 'rewrite'],
-        improve: ['optimize', 'refactor', 'enhance', 'extend'],
-        handle: ['process', 'validate', 'transform', 'route'],
-        // Scope terms
-        some: ['specific subset', 'all matching', 'first N', 'random sample'],
-        many: ['more than 10', 'more than 100', 'more than 1000', 'unlimited'],
-        few: ['2-3', '5-10', 'less than 10'],
-        large: ['>1MB', '>100MB', '>1GB', 'unbounded'],
-        small: ['<1KB', '<100KB', '<1MB'],
-        fast: ['<100ms', '<1s', '<5s', 'real-time'],
-        slow: ['>1s', '>5s', '>30s'],
-        // Quality terms
-        good: ['>80% coverage', '>90% accuracy', 'production-ready', 'MVP-quality'],
-        better: ['improved by X%', 'faster than current', 'more readable'],
-        best: ['optimal', 'industry standard', 'team consensus'],
-        simple: ['single function', 'minimal dependencies', 'no external calls'],
-        complex: ['multi-step', 'with dependencies', 'requiring state'],
-    };
-    // Vague phrases that need clarification
-    vaguePatterns = [
-        {
-            pattern: /\bshould work\b/gi,
-            suggestion: 'Define specific success criteria and test cases',
-        },
-        {
-            pattern: /\bproperly\b/gi,
-            suggestion: 'Specify exact behavior or standards to follow',
-        },
-        {
-            pattern: /\bcorrectly\b/gi,
-            suggestion: 'Define what "correct" means with specific criteria',
-        },
-        {
-            pattern: /\bappropriate(ly)?\b/gi,
-            suggestion: 'Specify the exact behavior or standards expected',
-        },
-        {
-            pattern: /\bas needed\b/gi,
-            suggestion: 'Define when and what is needed specifically',
-        },
-        {
-            pattern: /\bif necessary\b/gi,
-            suggestion: 'Define the conditions that trigger this action',
-        },
-        {
-            pattern: /\betc\.?\b/gi,
-            suggestion: 'List all items explicitly or define a complete category',
-        },
-        {
-            pattern: /\band so on\b/gi,
-            suggestion: 'Enumerate all items or define the pattern explicitly',
-        },
-        {
-            pattern: /\bwhatever\b/gi,
-            suggestion: 'Specify the exact options or constraints',
-        },
-        {
-            pattern: /\bsomething like\b/gi,
-            suggestion: 'Provide the exact specification or reference',
-        },
-        {
-            pattern: /\bmaybe\b/gi,
-            suggestion: 'Decide if this is a requirement or not',
-        },
-        {
-            pattern: /\bprobably\b/gi,
-            suggestion: 'Confirm if this is a requirement or not',
-        },
-    ];
-    apply(prompt, _context) {
-        let enhanced = prompt;
-        const ambiguitiesFound = [];
-        const clarifications = [];
-        // Check for ambiguous terms
-        for (const [term, options] of Object.entries(this.ambiguousTerms)) {
-            const regex = new RegExp(`\\b${term}\\b`, 'gi');
-            if (regex.test(prompt)) {
-                // Check if the term is already qualified
-                const qualifiedPattern = new RegExp(`\\b(${options.join('|')})\\s+${term}\\b|\\b${term}\\s+(${options.join('|')})\\b`, 'gi');
-                if (!qualifiedPattern.test(prompt)) {
-                    ambiguitiesFound.push(`"${term}" is ambiguous`);
-                    clarifications.push(`[CLARIFY: "${term}" - specify: ${options.slice(0, 3).join(', ')}?]`);
-                }
-            }
-        }
-        // Check for vague phrases
-        for (const { pattern, suggestion } of this.vaguePatterns) {
-            if (pattern.test(prompt)) {
-                ambiguitiesFound.push(`Found vague phrase matching: ${pattern.source}`);
-                clarifications.push(`[CLARIFY: ${suggestion}]`);
-            }
-        }
-        // Check for undefined pronouns
-        const pronounPatterns = [
-            { pattern: /\bit\b(?!eration|em|erable)/gi, issue: '"it" - unclear reference' },
-            { pattern: /\bthis\b(?!\s+\w+)/gi, issue: '"this" - unclear reference' },
-            { pattern: /\bthat\b(?!\s+\w+)/gi, issue: '"that" - unclear reference' },
-            { pattern: /\bthey\b/gi, issue: '"they" - unclear reference' },
-            { pattern: /\bthose\b(?!\s+\w+)/gi, issue: '"those" - unclear reference' },
-        ];
-        for (const { pattern, issue } of pronounPatterns) {
-            const matches = prompt.match(pattern);
-            if (matches && matches.length > 0) {
-                // Only flag if it appears at the start of a sentence or after punctuation
-                const contextPattern = new RegExp(`[.!?]\\s*${pattern.source}|^${pattern.source}`, 'gi');
-                if (contextPattern.test(prompt)) {
-                    ambiguitiesFound.push(issue);
-                }
-            }
-        }
-        // If ambiguities found, append clarification section
-        if (clarifications.length > 0) {
-            enhanced = prompt + '\n\n## Clarifications Needed\n' + clarifications.join('\n');
-        }
-        const applied = ambiguitiesFound.length > 0;
-        return {
-            enhancedPrompt: enhanced,
-            improvement: {
-                dimension: 'clarity',
-                description: applied
-                    ? `Identified ${ambiguitiesFound.length} ambiguous terms/phrases requiring clarification`
-                    : 'No significant ambiguities detected',
-                impact: ambiguitiesFound.length > 3 ? 'high' : ambiguitiesFound.length > 1 ? 'medium' : 'low',
-            },
-            applied,
-        };
-    }
-}
-//# sourceMappingURL=ambiguity-detector.js.map

package/dist/core/intelligence/patterns/assumption-explicitizer.d.ts

@@ -1,30 +0,0 @@
-import { BasePattern, PatternScope, PatternPriority, PatternPhase, PatternConfigSchema } from './base-pattern.js';
-import { PromptIntent, PatternContext, PatternResult } from '../types.js';
-/**
- * v4.5 Pattern: Assumption Explicitizer
- *
- * Makes implicit assumptions explicit to prevent misunderstandings
- * and ensure comprehensive requirement coverage.
- */
-export declare class AssumptionExplicitizer extends BasePattern {
-    readonly id = "assumption-explicitizer";
-    readonly name = "Assumption Explicitizer";
-    readonly description = "Make implicit assumptions explicit to prevent misunderstandings";
-    readonly applicableIntents: PromptIntent[];
-    readonly scope: PatternScope;
-    readonly priority: PatternPriority;
-    readonly phases: PatternPhase[];
-    static readonly configSchema: PatternConfigSchema;
-    apply(prompt: string, context: PatternContext): PatternResult;
-    private identifyAssumptions;
-    private identifyMissingContext;
-    private getCodeAssumptions;
-    private getPlanningAssumptions;
-    private getMigrationAssumptions;
-    private getTestingAssumptions;
-    private getDebuggingAssumptions;
-    private getDomainAssumptions;
-    private deduplicateAssumptions;
-    private formatAssumptionsSection;
-}
-//# sourceMappingURL=assumption-explicitizer.d.ts.map