clavix 2.8.2 → 3.0.1

package/dist/core/intelligence/patterns/objective-clarifier.js

@@ -0,0 +1,97 @@
+import { BasePattern } from './base-pattern.js';
+export class ObjectiveClarifier extends BasePattern {
+    id = 'objective-clarifier';
+    name = 'Objective Clarifier';
+    description = 'Extracts or infers clear goal statement';
+    applicableIntents = ['code-generation', 'planning', 'refinement', 'debugging', 'documentation'];
+    mode = 'both';
+    priority = 9;
+    apply(prompt, context) {
+        // Check if prompt already has clear objective section
+        if (this.hasExplicitObjective(prompt)) {
+            return {
+                enhancedPrompt: prompt,
+                improvement: {
+                    dimension: 'clarity',
+                    description: 'Objective already clearly stated',
+                    impact: 'low'
+                },
+                applied: false
+            };
+        }
+        // Extract or infer objective
+        const objective = this.extractObjective(prompt, context.intent.primaryIntent);
+        // If we couldn't infer a clear objective, just ensure it's at the top
+        if (!objective) {
+            return {
+                enhancedPrompt: prompt,
+                improvement: {
+                    dimension: 'clarity',
+                    description: 'Could not infer clear objective',
+                    impact: 'low'
+                },
+                applied: false
+            };
+        }
+        // Add objective section
+        const enhanced = `# Objective\n${objective}\n\n${prompt}`;
+        return {
+            enhancedPrompt: enhanced,
+            improvement: {
+                dimension: 'clarity',
+                description: 'Added clear objective statement',
+                impact: 'high'
+            },
+            applied: true
+        };
+    }
+    hasExplicitObjective(prompt) {
+        const objectiveMarkers = [
+            /^#+ objective/im,
+            /^objective:/im,
+            /^goal:/im,
+            /^purpose:/im
+        ];
+        return objectiveMarkers.some(marker => marker.test(prompt));
+    }
+    extractObjective(prompt, intent) {
+        const lowerPrompt = prompt.toLowerCase();
+        // Look for explicit goal statements
+        const goalPatterns = [
+            /(?:i need to|i want to|i'm trying to|goal is to|objective is to|purpose is to)\s+(.+?)(?:\.|$)/i,
+            /(?:create|build|make|implement|develop|write)\s+(.+?)(?:\.|$)/i
+        ];
+        for (const pattern of goalPatterns) {
+            const match = prompt.match(pattern);
+            if (match && match[1]) {
+                return match[1].trim();
+            }
+        }
+        // Intent-specific inference
+        if (intent === 'code-generation') {
+            if (lowerPrompt.includes('function')) {
+                return 'Create a function that meets the specified requirements';
+            }
+            else if (lowerPrompt.includes('component')) {
+                return 'Build a component with the described functionality';
+            }
+            else if (lowerPrompt.includes('api')) {
+                return 'Implement an API endpoint as specified';
+            }
+        }
+        else if (intent === 'debugging') {
+            return 'Fix the identified error or bug';
+        }
+        else if (intent === 'refinement') {
+            return 'Improve and optimize the existing code';
+        }
+        else if (intent === 'documentation') {
+            return 'Provide clear documentation and explanation';
+        }
+        else if (intent === 'planning') {
+            return 'Plan and design the described system or feature';
+        }
+        return null;
+    }
+}
+//# sourceMappingURL=objective-clarifier.js.map

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

@@ -0,0 +1,31 @@
+import { BasePattern } from './base-pattern.js';
+import { PatternContext, PatternResult, PromptIntent } from '../types.js';
+/**
+ * Structure Organizer Pattern
+ *
+ * Reorders information logically following the flow:
+ * Objective → Requirements → Technical Constraints → Expected Output → Success Criteria
+ *
+ * Priority: HIGH (8)
+ */
+export declare class StructureOrganizer extends BasePattern {
+    id: string;
+    name: string;
+    description: string;
+    applicableIntents: PromptIntent[];
+    mode: 'fast' | 'deep' | 'both';
+    priority: number;
+    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

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

@@ -0,0 +1,185 @@
+import { BasePattern } from './base-pattern.js';
+/**
+ * Structure Organizer Pattern
+ *
+ * Reorders information logically following the flow:
+ * Objective → Requirements → Technical Constraints → Expected Output → Success Criteria
+ *
+ * Priority: HIGH (8)
+ */
+export class StructureOrganizer extends BasePattern {
+    id = 'structure-organizer';
+    name = 'Structure Organizer';
+    description = 'Reorders information into logical sections';
+    applicableIntents = ['code-generation', 'planning', 'refinement', 'debugging', 'documentation'];
+    mode = 'both';
+    priority = 8; // High priority
+    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/technical-context-enricher.d.ts

@@ -0,0 +1,16 @@
+import { BasePattern } from './base-pattern.js';
+import { PatternContext, PatternResult, PromptIntent } from '../types.js';
+export declare class TechnicalContextEnricher extends BasePattern {
+    id: string;
+    name: string;
+    description: string;
+    applicableIntents: PromptIntent[];
+    mode: 'fast' | 'deep' | 'both';
+    priority: number;
+    apply(prompt: string, context: PatternContext): PatternResult;
+    private hasTechnicalContext;
+    private detectLanguage;
+    private detectFramework;
+    private hasVersionInfo;
+}
+//# sourceMappingURL=technical-context-enricher.d.ts.map

package/dist/core/intelligence/patterns/technical-context-enricher.js

@@ -0,0 +1,132 @@
+import { BasePattern } from './base-pattern.js';
+export class TechnicalContextEnricher extends BasePattern {
+    id = 'technical-context-enricher';
+    name = 'Technical Context Enricher';
+    description = 'Adds missing technical context (language, framework, versions)';
+    applicableIntents = ['code-generation', 'refinement', 'debugging'];
+    mode = 'both';
+    priority = 8;
+    apply(prompt, context) {
+        const lowerPrompt = prompt.toLowerCase();
+        const enhancements = [];
+        // Check if technical context is already present
+        if (this.hasTechnicalContext(prompt)) {
+            return {
+                enhancedPrompt: prompt,
+                improvement: {
+                    dimension: 'completeness',
+                    description: 'Technical context already specified',
+                    impact: 'low'
+                },
+                applied: false
+            };
+        }
+        // Detect language mentions without versions
+        const detectedLanguage = this.detectLanguage(lowerPrompt);
+        if (detectedLanguage && !this.hasVersionInfo(prompt)) {
+            enhancements.push(`Language: ${detectedLanguage} (please specify version if critical)`);
+        }
+        // Suggest adding framework if code generation
+        if (context.intent.primaryIntent === 'code-generation') {
+            const framework = this.detectFramework(lowerPrompt);
+            if (framework) {
+                enhancements.push(`Framework: ${framework}`);
+            }
+        }
+        // No enhancements needed
+        if (enhancements.length === 0) {
+            return {
+                enhancedPrompt: prompt,
+                improvement: {
+                    dimension: 'completeness',
+                    description: 'No additional technical context needed',
+                    impact: 'low'
+                },
+                applied: false
+            };
+        }
+        // Add technical context section
+        const contextSection = `\n\n# Technical Constraints\n${enhancements.map(e => `- ${e}`).join('\n')}`;
+        const enhanced = prompt + contextSection;
+        return {
+            enhancedPrompt: enhanced,
+            improvement: {
+                dimension: 'completeness',
+                description: `Added ${enhancements.length} technical context specifications`,
+                impact: 'medium'
+            },
+            applied: true
+        };
+    }
+    hasTechnicalContext(prompt) {
+        const contextMarkers = [
+            /version|v\d+\.\d+/i,
+            /technical (context|constraints|requirements)/i,
+            /language:.*framework:/i,
+            /using (python|javascript|typescript|java|rust|go) \d/i
+        ];
+        return contextMarkers.some(marker => marker.test(prompt));
+    }
+    detectLanguage(prompt) {
+        const languages = {
+            'python': 'Python',
+            'javascript': 'JavaScript',
+            'typescript': 'TypeScript',
+            'java': 'Java',
+            'rust': 'Rust',
+            'go': 'Go',
+            'php': 'PHP',
+            'ruby': 'Ruby',
+            'swift': 'Swift',
+            'kotlin': 'Kotlin',
+            'c++': 'C++',
+            'csharp': 'C#',
+            'c#': 'C#'
+        };
+        for (const [key, name] of Object.entries(languages)) {
+            if (prompt.includes(key)) {
+                return name;
+            }
+        }
+        // Check for common patterns
+        if (prompt.includes('react') || prompt.includes('vue') || prompt.includes('angular')) {
+            return 'JavaScript/TypeScript';
+        }
+        if (prompt.includes('django') || prompt.includes('flask')) {
+            return 'Python';
+        }
+        if (prompt.includes('spring') || prompt.includes('hibernate')) {
+            return 'Java';
+        }
+        return null;
+    }
+    detectFramework(prompt) {
+        const frameworks = {
+            'react': 'React',
+            'vue': 'Vue.js',
+            'angular': 'Angular',
+            'svelte': 'Svelte',
+            'next': 'Next.js',
+            'nextjs': 'Next.js',
+            'nuxt': 'Nuxt.js',
+            'django': 'Django',
+            'flask': 'Flask',
+            'fastapi': 'FastAPI',
+            'express': 'Express.js',
+            'nestjs': 'NestJS',
+            'spring': 'Spring Boot',
+            'rails': 'Ruby on Rails',
+            'laravel': 'Laravel'
+        };
+        for (const [key, name] of Object.entries(frameworks)) {
+            if (prompt.includes(key)) {
+                return name;
+            }
+        }
+        return null;
+    }
+    hasVersionInfo(prompt) {
+        return /\d+\.\d+/.test(prompt) || /v\d+/.test(prompt);
+    }
+}
+//# sourceMappingURL=technical-context-enricher.js.map

package/dist/core/intelligence/quality-assessor.d.ts

@@ -0,0 +1,42 @@
+import { IntentAnalysis, QualityMetrics } from './types.js';
+export declare class QualityAssessor {
+    /**
+     * Assess quality of a prompt (backward compatibility wrapper)
+     * @deprecated Use assess() method instead for full quality metrics
+     */
+    assessQuality(prompt: string, intent: string): {
+        clarity: number;
+        efficiency: number;
+        structure: number;
+        completeness: number;
+        actionability: number;
+        overall: number;
+    };
+    /**
+     * Assess quality of a prompt
+     */
+    assess(original: string, enhanced: string, intent: IntentAnalysis): QualityMetrics;
+    private assessClarity;
+    private assessEfficiency;
+    private assessStructure;
+    private assessCompleteness;
+    private assessActionability;
+    private calculateOverall;
+    private identifyStrengths;
+    private identifyImprovements;
+    private hasObjective;
+    private hasTechStack;
+    private hasOutputFormat;
+    private hasSuccessCriteria;
+    private hasSection;
+    private countSignalWords;
+    private hasInputOutput;
+    private hasEdgeCases;
+    private hasProblemStatement;
+    private hasGoal;
+    private hasConstraints;
+    private hasExpectedBehavior;
+    private hasActualBehavior;
+    private hasExamples;
+}
+//# sourceMappingURL=quality-assessor.d.ts.map