clavix 4.11.2 → 5.0.0

package/dist/core/intelligence/patterns/completeness-validator.js

@@ -1,221 +0,0 @@
-import { BasePattern, } from './base-pattern.js';
-/**
- * v4.5 Pattern: Completeness Validator
- *
- * Ensures all necessary requirements are present.
- * Adds placeholder sections for missing critical elements.
- */
-export class CompletenessValidator extends BasePattern {
-    // -------------------------------------------------------------------------
-    // Pattern Metadata (v4.5 unified types)
-    // -------------------------------------------------------------------------
-    id = 'completeness-validator';
-    name = 'Completeness Validator';
-    description = 'Ensures all necessary requirements are present';
-    applicableIntents = ['code-generation', 'planning', 'refinement'];
-    scope = 'both';
-    priority = 6; // MEDIUM - standard enhancement
-    phases = ['all'];
-    // -------------------------------------------------------------------------
-    // Configuration Schema (v4.5)
-    // -------------------------------------------------------------------------
-    static configSchema = {
-        showCompletenessScore: {
-            type: 'boolean',
-            default: true,
-            description: 'Display completeness percentage in output',
-        },
-        minCompletenessThreshold: {
-            type: 'number',
-            default: 60,
-            description: 'Minimum completeness percentage to consider prompt adequate',
-            validation: { min: 0, max: 100 },
-        },
-    };
-    // -------------------------------------------------------------------------
-    // Pattern Application
-    // -------------------------------------------------------------------------
-    apply(prompt, _context) {
-        const missing = this.findMissingElements(prompt);
-        if (missing.length === 0) {
-            return {
-                enhancedPrompt: prompt,
-                improvement: {
-                    dimension: 'completeness',
-                    description: 'All required elements present',
-                    impact: 'low',
-                },
-                applied: false,
-            };
-        }
-        // Calculate completeness score
-        const totalElements = 5;
-        const presentElements = totalElements - missing.length;
-        const score = Math.round((presentElements / totalElements) * 100);
-        let enhanced = prompt + '\n\n';
-        // Add missing elements section
-        enhanced += '---\n\n';
-        enhanced += `**Completeness Check**: ${score}% (${presentElements}/${totalElements} elements present)\n\n`;
-        enhanced += '**Missing Information** (please specify):\n\n';
-        for (const element of missing) {
-            enhanced += this.getMissingElementPrompt(element) + '\n';
-        }
-        const result = enhanced.trim();
-        return {
-            enhancedPrompt: result,
-            improvement: {
-                dimension: 'completeness',
-                description: `Added ${missing.length} missing element prompts (${score}% complete)`,
-                impact: missing.length >= 3 ? 'high' : missing.length >= 2 ? 'medium' : 'low',
-            },
-            applied: true,
-        };
-    }
-    findMissingElements(prompt) {
-        const missing = [];
-        const lowerPrompt = prompt.toLowerCase();
-        // Check for objective/goal
-        if (!this.hasObjective(lowerPrompt)) {
-            missing.push('objective');
-        }
-        // Check for tech stack
-        if (!this.hasTechStack(lowerPrompt)) {
-            missing.push('tech-stack');
-        }
-        // Check for success criteria
-        if (!this.hasSuccessCriteria(lowerPrompt)) {
-            missing.push('success-criteria');
-        }
-        // Check for constraints
-        if (!this.hasConstraints(lowerPrompt)) {
-            missing.push('constraints');
-        }
-        // Check for output format
-        if (!this.hasOutputFormat(lowerPrompt)) {
-            missing.push('output-format');
-        }
-        return missing;
-    }
-    hasObjective(prompt) {
-        const objectivePatterns = [
-            'objective',
-            'goal',
-            'purpose',
-            'need to',
-            'want to',
-            'trying to',
-            'aim',
-            'intend',
-        ];
-        return objectivePatterns.some((pattern) => prompt.includes(pattern));
-    }
-    hasTechStack(prompt) {
-        const techPatterns = [
-            // Languages
-            'javascript',
-            'typescript',
-            'python',
-            'java',
-            'rust',
-            'go',
-            'php',
-            'ruby',
-            'swift',
-            'kotlin',
-            'c++',
-            'c#',
-            // Frameworks
-            'react',
-            'vue',
-            'angular',
-            'svelte',
-            'next',
-            'nuxt',
-            'express',
-            'fastapi',
-            'django',
-            'flask',
-            'spring',
-            'rails',
-            // Databases
-            'postgres',
-            'mysql',
-            'mongodb',
-            'redis',
-            'sqlite',
-            // Tools
-            'docker',
-            'kubernetes',
-            'aws',
-            'azure',
-            'gcp',
-            // Generic
-            'tech stack',
-            'technology',
-            'framework',
-            'library',
-            'using',
-            'built with',
-        ];
-        return techPatterns.some((pattern) => prompt.includes(pattern));
-    }
-    hasSuccessCriteria(prompt) {
-        const successPatterns = [
-            'success',
-            'criteria',
-            'measure',
-            'metric',
-            'kpi',
-            'should work',
-            'expected to',
-            'result in',
-            'achieve',
-        ];
-        return successPatterns.some((pattern) => prompt.includes(pattern));
-    }
-    hasConstraints(prompt) {
-        const constraintPatterns = [
-            'constraint',
-            'limit',
-            'limitation',
-            'must not',
-            'cannot',
-            'should not',
-            'avoid',
-            'within',
-            'budget',
-            'time',
-            'deadline',
-        ];
-        return constraintPatterns.some((pattern) => prompt.includes(pattern));
-    }
-    hasOutputFormat(prompt) {
-        const outputPatterns = [
-            'output',
-            'format',
-            'return',
-            'result',
-            'deliverable',
-            'component',
-            'function',
-            'class',
-            'api',
-            'endpoint',
-            'file',
-            'document',
-            'report',
-        ];
-        return outputPatterns.some((pattern) => prompt.includes(pattern));
-    }
-    getMissingElementPrompt(element) {
-        const prompts = {
-            objective: '- **Objective**: What is the primary goal? What problem are you solving?',
-            'tech-stack': '- **Tech Stack**: Which technologies/frameworks? (e.g., React, Node.js, PostgreSQL)',
-            'success-criteria': '- **Success Criteria**: How will you know it works? What metrics matter?',
-            constraints: '- **Constraints**: Any limitations? (time, budget, performance, compatibility)',
-            'output-format': '- **Expected Output**: What should the result look like? (component, API, file, etc.)',
-        };
-        return prompts[element] || `- **${element}**: Please specify`;
-    }
-}
-//# sourceMappingURL=completeness-validator.js.map

package/dist/core/intelligence/patterns/conciseness-filter.d.ts

@@ -1,20 +0,0 @@
-import { BasePattern, PatternScope, PatternPriority, PatternPhase, PatternConfigSchema } from './base-pattern.js';
-import { PatternContext, PatternResult, PromptIntent } from '../types.js';
-/**
- * v4.5 Pattern: Conciseness Filter
- *
- * Removes unnecessary pleasantries, fluff words, and redundancy
- * to make prompts more direct and efficient.
- */
-export declare class ConcisenessFilter extends BasePattern {
-    readonly id = "conciseness-filter";
-    readonly name = "Conciseness Filter";
-    readonly description = "Removes unnecessary pleasantries, fluff words, and redundancy";
-    readonly applicableIntents: PromptIntent[];
-    readonly scope: PatternScope;
-    readonly priority: PatternPriority;
-    readonly phases: PatternPhase[];
-    static readonly configSchema: PatternConfigSchema;
-    apply(prompt: string, _context: PatternContext): PatternResult;
-}
-//# sourceMappingURL=conciseness-filter.d.ts.map

package/dist/core/intelligence/patterns/conciseness-filter.js

@@ -1,92 +0,0 @@
-import { BasePattern, } from './base-pattern.js';
-/**
- * v4.5 Pattern: Conciseness Filter
- *
- * Removes unnecessary pleasantries, fluff words, and redundancy
- * to make prompts more direct and efficient.
- */
-export class ConcisenessFilter extends BasePattern {
-    // -------------------------------------------------------------------------
-    // Pattern Metadata (v4.5 unified types)
-    // -------------------------------------------------------------------------
-    id = 'conciseness-filter';
-    name = 'Conciseness Filter';
-    description = 'Removes unnecessary pleasantries, fluff words, and redundancy';
-    applicableIntents = [
-        'code-generation',
-        'planning',
-        'refinement',
-        'debugging',
-        'documentation',
-    ];
-    scope = 'both';
-    priority = 4; // LOW - Polish phase
-    phases = ['all'];
-    // -------------------------------------------------------------------------
-    // Configuration Schema (v4.5)
-    // -------------------------------------------------------------------------
-    static configSchema = {
-        fluffThreshold: {
-            type: 'number',
-            default: 3,
-            description: 'Number of fluff words to tolerate before applying filter',
-            validation: { min: 1, max: 10 },
-        },
-        preserveTechnicalTerms: {
-            type: 'boolean',
-            default: true,
-            description: 'Keep technical terms even if they appear verbose',
-        },
-    };
-    // -------------------------------------------------------------------------
-    // Pattern Application
-    // -------------------------------------------------------------------------
-    apply(prompt, _context) {
-        const settings = this.getSettings();
-        const fluffThreshold = settings.fluffThreshold ?? 3;
-        let cleaned = prompt;
-        let changesCount = 0;
-        // Remove pleasantries at start
-        const pleasantries = [
-            /^(please|could you|would you mind|I would appreciate if you could|kindly)\s+/gi,
-            /thank you/gi,
-            /thanks in advance/gi,
-            /I appreciate your help/gi,
-        ];
-        for (const pattern of pleasantries) {
-            const before = cleaned;
-            cleaned = cleaned.replace(pattern, '');
-            if (before !== cleaned)
-                changesCount++;
-        }
-        // Remove fluff words
-        const fluffWords = ['very', 'really', 'just', 'basically', 'simply', 'actually', 'literally'];
-        for (const word of fluffWords) {
-            const regex = new RegExp(`\\b${word}\\b`, 'gi');
-            const before = cleaned;
-            cleaned = cleaned.replace(regex, '');
-            if (before !== cleaned)
-                changesCount++;
-        }
-        // Remove redundant phrases
-        cleaned = cleaned.replace(/in order to/gi, 'to');
-        cleaned = cleaned.replace(/at this point in time/gi, 'now');
-        cleaned = cleaned.replace(/due to the fact that/gi, 'because');
-        cleaned = cleaned.replace(/for the purpose of/gi, 'for');
-        cleaned = cleaned.replace(/in the event that/gi, 'if');
-        // Clean up extra whitespace
-        cleaned = this.cleanWhitespace(cleaned);
-        // Only apply if changes exceed threshold
-        const applied = changesCount >= fluffThreshold || cleaned !== prompt;
-        return {
-            enhancedPrompt: applied ? cleaned : prompt,
-            improvement: {
-                dimension: 'efficiency',
-                description: `Removed ${changesCount} unnecessary phrases for conciseness`,
-                impact: changesCount > 3 ? 'high' : changesCount > 1 ? 'medium' : 'low',
-            },
-            applied,
-        };
-    }
-}
-//# sourceMappingURL=conciseness-filter.js.map

package/dist/core/intelligence/patterns/context-precision.d.ts

@@ -1,32 +0,0 @@
-import { BasePattern, PatternScope, PatternPriority, PatternPhase, PatternConfigSchema } from './base-pattern.js';
-import { PromptIntent, PatternContext, PatternResult } from '../types.js';
-/**
- * v4.5 Pattern: Context Precision Booster
- *
- * Adds precise context when missing to ensure
- * the AI has sufficient information for accurate responses.
- */
-export declare class ContextPrecisionBooster extends BasePattern {
-    readonly id = "context-precision";
-    readonly name = "Context Precision Booster";
-    readonly description = "Add precise context when missing";
-    readonly applicableIntents: PromptIntent[];
-    readonly scope: PatternScope;
-    readonly priority: PatternPriority;
-    readonly phases: PatternPhase[];
-    static readonly configSchema: PatternConfigSchema;
-    apply(prompt: string, context: PatternContext): PatternResult;
-    private identifyMissingContext;
-    private checkGeneralContext;
-    private checkCodeGenerationContext;
-    private checkDebuggingContext;
-    private checkCodeReviewContext;
-    private checkRefactoringContext;
-    private checkTestingContext;
-    private checkMigrationContext;
-    private checkSecurityContext;
-    private hasVersionNumber;
-    private deduplicateGaps;
-    private formatContextSection;
-}
-//# sourceMappingURL=context-precision.d.ts.map