clavix 4.12.0 → 5.0.0

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

@@ -1,165 +0,0 @@
-import { BasePattern, } from './base-pattern.js';
-/**
- * v4.5 Pattern: Technical Context Enricher
- *
- * Adds missing technical context (language, framework, versions).
- * Detects technologies and suggests version specifications.
- */
-export class TechnicalContextEnricher extends BasePattern {
-    // -------------------------------------------------------------------------
-    // Pattern Metadata (v4.5 unified types)
-    // -------------------------------------------------------------------------
-    id = 'technical-context-enricher';
-    name = 'Technical Context Enricher';
-    description = 'Adds missing technical context (language, framework, versions)';
-    applicableIntents = ['code-generation', 'refinement', 'debugging'];
-    scope = 'both';
-    priority = 5; // MEDIUM-LOW - supplementary context
-    phases = ['all'];
-    // v4.5: Dependencies
-    dependencies = {
-        runAfter: ['objective-clarifier'], // Clarify objective first, then add technical context
-        enhancedBy: ['domain-context-enricher'],
-    };
-    // -------------------------------------------------------------------------
-    // Configuration Schema (v4.5)
-    // -------------------------------------------------------------------------
-    static configSchema = {
-        detectFrameworks: {
-            type: 'boolean',
-            default: true,
-            description: 'Detect and add framework information',
-        },
-        suggestVersions: {
-            type: 'boolean',
-            default: true,
-            description: 'Suggest adding version information when missing',
-        },
-    };
-    // -------------------------------------------------------------------------
-    // Pattern Application
-    // -------------------------------------------------------------------------
-    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/patterns/topic-coherence-analyzer.d.ts

@@ -1,26 +0,0 @@
-import { BasePattern, PatternScope, PatternPriority, PatternPhase, PatternConfigSchema } from './base-pattern.js';
-import { PromptIntent, PatternContext, PatternResult } from '../types.js';
-/**
- * v4.5 Pattern: Topic Coherence Analyzer
- *
- * Detects topic shifts and multi-topic conversations.
- * Helps organize scattered discussions into coherent themes.
- * Enhanced with expanded topic dictionary and better detection.
- */
-export declare class TopicCoherenceAnalyzer extends BasePattern {
-    readonly id = "topic-coherence-analyzer";
-    readonly name = "Topic Coherence Analyzer";
-    readonly description = "Detects topic shifts and multi-topic conversations";
-    readonly applicableIntents: PromptIntent[];
-    readonly scope: PatternScope;
-    readonly priority: PatternPriority;
-    readonly phases: PatternPhase[];
-    static readonly configSchema: PatternConfigSchema;
-    private readonly topicIndicators;
-    apply(prompt: string, _context: PatternContext): PatternResult;
-    private detectTopics;
-    private hasTopicOrganization;
-    private organizeByTopic;
-    private extractTopicContent;
-}
-//# sourceMappingURL=topic-coherence-analyzer.d.ts.map

package/dist/core/intelligence/patterns/topic-coherence-analyzer.js

@@ -1,300 +0,0 @@
-import { BasePattern, } from './base-pattern.js';
-/**
- * v4.5 Pattern: Topic Coherence Analyzer
- *
- * Detects topic shifts and multi-topic conversations.
- * Helps organize scattered discussions into coherent themes.
- * Enhanced with expanded topic dictionary and better detection.
- */
-export class TopicCoherenceAnalyzer extends BasePattern {
-    // -------------------------------------------------------------------------
-    // Pattern Metadata (v4.5 unified types)
-    // -------------------------------------------------------------------------
-    id = 'topic-coherence-analyzer';
-    name = 'Topic Coherence Analyzer';
-    description = 'Detects topic shifts and multi-topic conversations';
-    applicableIntents = ['summarization', 'planning'];
-    scope = 'comprehensive';
-    priority = 6; // MEDIUM - standard enhancement
-    phases = ['conversation-tracking', 'summarization'];
-    // -------------------------------------------------------------------------
-    // Configuration Schema (v4.5)
-    // -------------------------------------------------------------------------
-    static configSchema = {
-        minTopicsForOrganization: {
-            type: 'number',
-            default: 2,
-            description: 'Minimum number of topics before organizing',
-            validation: { min: 2, max: 5 },
-        },
-    };
-    // -------------------------------------------------------------------------
-    // Pattern Data
-    // -------------------------------------------------------------------------
-    // Expanded topic indicators (~15 topics with more keywords)
-    topicIndicators = {
-        'User Interface': [
-            'ui',
-            'interface',
-            'design',
-            'layout',
-            'button',
-            'form',
-            'page',
-            'screen',
-            'component',
-            'modal',
-            'dialog',
-            'navigation',
-            'menu',
-            'sidebar',
-            'header',
-            'footer',
-        ],
-        'Backend/API': [
-            'api',
-            'backend',
-            'server',
-            'endpoint',
-            'route',
-            'controller',
-            'service',
-            'middleware',
-            'rest',
-            'graphql',
-            'websocket',
-        ],
-        Database: [
-            'database',
-            'db',
-            'schema',
-            'table',
-            'query',
-            'migration',
-            'model',
-            'orm',
-            'sql',
-            'nosql',
-            'index',
-            'relationship',
-        ],
-        Authentication: [
-            'auth',
-            'login',
-            'password',
-            'session',
-            'token',
-            'permission',
-            'role',
-            'oauth',
-            'jwt',
-            'sso',
-            'mfa',
-            '2fa',
-        ],
-        Performance: [
-            'performance',
-            'speed',
-            'cache',
-            'optimize',
-            'latency',
-            'load time',
-            'bundle',
-            'lazy',
-            'memory',
-            'cpu',
-        ],
-        Testing: [
-            'test',
-            'spec',
-            'coverage',
-            'qa',
-            'validation',
-            'unit test',
-            'integration',
-            'e2e',
-            'mock',
-            'fixture',
-        ],
-        Deployment: [
-            'deploy',
-            'ci/cd',
-            'pipeline',
-            'release',
-            'environment',
-            'production',
-            'staging',
-            'docker',
-            'kubernetes',
-        ],
-        'User Experience': [
-            'ux',
-            'usability',
-            'accessibility',
-            'user flow',
-            'journey',
-            'experience',
-            'onboarding',
-            'feedback',
-        ],
-        'Business Logic': [
-            'business',
-            'workflow',
-            'process',
-            'rule',
-            'logic',
-            'requirement',
-            'feature',
-            'use case',
-        ],
-        Integration: [
-            'integration',
-            'third-party',
-            'external',
-            'webhook',
-            'sync',
-            'connect',
-            'import',
-            'export',
-        ],
-        Security: [
-            'security',
-            'encryption',
-            'vulnerability',
-            'xss',
-            'csrf',
-            'injection',
-            'sanitize',
-            'audit',
-        ],
-        Analytics: [
-            'analytics',
-            'tracking',
-            'metrics',
-            'dashboard',
-            'report',
-            'insight',
-            'data',
-            'statistics',
-        ],
-        'Error Handling': [
-            'error',
-            'exception',
-            'fallback',
-            'retry',
-            'timeout',
-            'failure',
-            'recovery',
-            'logging',
-        ],
-        Documentation: [
-            'documentation',
-            'docs',
-            'readme',
-            'guide',
-            'tutorial',
-            'api docs',
-            'comment',
-            'jsdoc',
-        ],
-        'State Management': [
-            'state',
-            'store',
-            'redux',
-            'context',
-            'global state',
-            'local state',
-            'persist',
-            'hydrate',
-        ],
-    };
-    apply(prompt, _context) {
-        // Detect topics in the content
-        const topics = this.detectTopics(prompt);
-        // If single topic or already organized, skip
-        if (topics.length <= 1) {
-            return {
-                enhancedPrompt: prompt,
-                improvement: {
-                    dimension: 'structure',
-                    description: 'Single coherent topic detected',
-                    impact: 'low',
-                },
-                applied: false,
-            };
-        }
-        // Check if already has topic organization
-        if (this.hasTopicOrganization(prompt)) {
-            return {
-                enhancedPrompt: prompt,
-                improvement: {
-                    dimension: 'structure',
-                    description: 'Topics already organized',
-                    impact: 'low',
-                },
-                applied: false,
-            };
-        }
-        // Add topic organization
-        const enhanced = this.organizeByTopic(prompt, topics);
-        return {
-            enhancedPrompt: enhanced,
-            improvement: {
-                dimension: 'structure',
-                description: `Organized ${topics.length} distinct topics for clarity`,
-                impact: 'medium',
-            },
-            applied: true,
-        };
-    }
-    detectTopics(prompt) {
-        const topics = [];
-        const lowerPrompt = prompt.toLowerCase();
-        for (const [topic, keywords] of Object.entries(this.topicIndicators)) {
-            const hasKeyword = keywords.some((kw) => lowerPrompt.includes(kw));
-            if (hasKeyword) {
-                topics.push(topic);
-            }
-        }
-        return topics;
-    }
-    hasTopicOrganization(prompt) {
-        // Check for existing topic headers
-        const topicHeaders = /##\s*(user interface|backend|database|auth|performance|testing|deploy)/i;
-        return topicHeaders.test(prompt);
-    }
-    organizeByTopic(prompt, topics) {
-        // Add topic summary at the beginning
-        let organized = '### Topics Covered\n';
-        organized += 'This conversation touches on multiple areas:\n';
-        organized += topics.map((t, i) => `${i + 1}. **${t}**`).join('\n');
-        organized += '\n\n---\n\n';
-        // Extract content relevant to each topic
-        organized += '### Discussion by Topic\n\n';
-        for (const topic of topics) {
-            const relevantContent = this.extractTopicContent(prompt, topic);
-            if (relevantContent) {
-                organized += `#### ${topic}\n`;
-                organized += relevantContent + '\n\n';
-            }
-        }
-        organized += '---\n\n**Full Context:**\n' + prompt;
-        return organized;
-    }
-    extractTopicContent(prompt, topic) {
-        const keywords = this.topicIndicators[topic] || [];
-        const sentences = this.extractSentences(prompt);
-        const relevantSentences = sentences.filter((sentence) => {
-            const lower = sentence.toLowerCase();
-            return keywords.some((kw) => lower.includes(kw));
-        });
-        if (relevantSentences.length === 0) {
-            return `- Discussion related to ${topic}`;
-        }
-        return relevantSentences
-            .slice(0, 3)
-            .map((s) => `- ${s.trim()}`)
-            .join('\n');
-    }
-}
-//# sourceMappingURL=topic-coherence-analyzer.js.map

package/dist/core/intelligence/patterns/user-persona-enricher.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: User Persona Enricher
- *
- * Adds missing user context and personas to PRD content.
- * Ensures the "who" is clearly defined alongside the "what".
- */
-export declare class UserPersonaEnricher extends BasePattern {
-    readonly id = "user-persona-enricher";
-    readonly name = "User Persona Enricher";
-    readonly description = "Adds missing user context and personas";
-    readonly applicableIntents: PromptIntent[];
-    readonly scope: PatternScope;
-    readonly priority: PatternPriority;
-    readonly phases: PatternPhase[];
-    static readonly configSchema: PatternConfigSchema;
-    apply(prompt: string, _context: PatternContext): PatternResult;
-    private hasUserContext;
-    private needsUserContext;
-    private addUserPersona;
-    private inferUserType;
-}
-//# sourceMappingURL=user-persona-enricher.d.ts.map

package/dist/core/intelligence/patterns/user-persona-enricher.js

@@ -1,141 +0,0 @@
-import { BasePattern, } from './base-pattern.js';
-/**
- * v4.5 Pattern: User Persona Enricher
- *
- * Adds missing user context and personas to PRD content.
- * Ensures the "who" is clearly defined alongside the "what".
- */
-export class UserPersonaEnricher extends BasePattern {
-    // -------------------------------------------------------------------------
-    // Pattern Metadata (v4.5 unified types)
-    // -------------------------------------------------------------------------
-    id = 'user-persona-enricher';
-    name = 'User Persona Enricher';
-    description = 'Adds missing user context and personas';
-    applicableIntents = ['prd-generation', 'planning'];
-    scope = 'comprehensive';
-    priority = 6; // MEDIUM - standard enhancement
-    phases = ['question-validation', 'output-generation'];
-    // -------------------------------------------------------------------------
-    // Configuration Schema (v4.5)
-    // -------------------------------------------------------------------------
-    static configSchema = {
-        inferUserType: {
-            type: 'boolean',
-            default: true,
-            description: 'Attempt to infer user type from content',
-        },
-    };
-    // -------------------------------------------------------------------------
-    // Pattern Application
-    // -------------------------------------------------------------------------
-    apply(prompt, _context) {
-        // Check if user/persona context already exists
-        if (this.hasUserContext(prompt)) {
-            return {
-                enhancedPrompt: prompt,
-                improvement: {
-                    dimension: 'completeness',
-                    description: 'User context already present',
-                    impact: 'low',
-                },
-                applied: false,
-            };
-        }
-        // Check if this is PRD-like content that needs users
-        if (!this.needsUserContext(prompt)) {
-            return {
-                enhancedPrompt: prompt,
-                improvement: {
-                    dimension: 'completeness',
-                    description: 'Content does not require user persona',
-                    impact: 'low',
-                },
-                applied: false,
-            };
-        }
-        // Add user persona section
-        const enhanced = this.addUserPersona(prompt);
-        return {
-            enhancedPrompt: enhanced,
-            improvement: {
-                dimension: 'completeness',
-                description: 'Added user persona context (who will use this)',
-                impact: 'medium',
-            },
-            applied: true,
-        };
-    }
-    hasUserContext(prompt) {
-        const userKeywords = [
-            'user persona',
-            'target user',
-            'end user',
-            'user profile',
-            'audience',
-            'stakeholder',
-            'as a user',
-            'users can',
-            'users will',
-            'for users',
-            'customer',
-            'developer',
-            'admin',
-            'target audience',
-        ];
-        return this.hasSection(prompt, userKeywords);
-    }
-    needsUserContext(prompt) {
-        // PRD-like content that talks about features but not users
-        const featureKeywords = [
-            'feature',
-            'build',
-            'create',
-            'implement',
-            'functionality',
-            'should',
-            'must',
-            'requirement',
-        ];
-        return this.hasSection(prompt, featureKeywords);
-    }
-    addUserPersona(prompt) {
-        // Detect the likely user type from content
-        const userType = this.inferUserType(prompt);
-        const personaSection = `\n\n### Target Users\n` +
-            `**Primary User:** ${userType}\n` +
-            `- Goals: [What they want to achieve]\n` +
-            `- Pain Points: [Current frustrations]\n` +
-            `- Context: [When and how they'll use this]`;
-        return prompt + personaSection;
-    }
-    inferUserType(prompt) {
-        const lowerPrompt = prompt.toLowerCase();
-        // Try to infer user type from content
-        if (lowerPrompt.includes('api') ||
-            lowerPrompt.includes('sdk') ||
-            lowerPrompt.includes('library')) {
-            return 'Developers integrating with the system';
-        }
-        if (lowerPrompt.includes('admin') ||
-            lowerPrompt.includes('manage') ||
-            lowerPrompt.includes('dashboard')) {
-            return 'Administrators managing the system';
-        }
-        if (lowerPrompt.includes('e-commerce') ||
-            lowerPrompt.includes('shop') ||
-            lowerPrompt.includes('buy')) {
-            return 'Customers making purchases';
-        }
-        if (lowerPrompt.includes('content') ||
-            lowerPrompt.includes('blog') ||
-            lowerPrompt.includes('cms')) {
-            return 'Content creators and editors';
-        }
-        if (lowerPrompt.includes('mobile') || lowerPrompt.includes('app')) {
-            return 'Mobile app users';
-        }
-        return '[Define primary user type]';
-    }
-}
-//# sourceMappingURL=user-persona-enricher.js.map

package/dist/core/intelligence/patterns/validation-checklist-creator.d.ts

@@ -1,31 +0,0 @@
-import { BasePattern, PatternScope, PatternPriority, PatternPhase, PatternConfigSchema, PatternDependency } from './base-pattern.js';
-import { PromptIntent, PatternContext, PatternResult } from '../types.js';
-/**
- * v4.5 Pattern: Validation Checklist Creator
- *
- * Creates implementation validation checklists to ensure
- * comprehensive verification of completed work.
- */
-export declare class ValidationChecklistCreator extends BasePattern {
-    readonly id = "validation-checklist-creator";
-    readonly name = "Validation Checklist Creator";
-    readonly description = "Create implementation validation checklist for verification";
-    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 createChecklist;
-    private getCodeGenerationChecklist;
-    private getTestingChecklist;
-    private getMigrationChecklist;
-    private getSecurityChecklist;
-    private getDebuggingChecklist;
-    private getDomainChecklist;
-    private getGeneralChecklist;
-    private formatChecklistSection;
-    private formatCategory;
-}
-//# sourceMappingURL=validation-checklist-creator.d.ts.map