clavix 4.12.0 → 5.0.0

package/dist/core/basic-checklist-generator.js

@@ -1,344 +0,0 @@
-/**
- * Clavix v4.8: Basic Checklist Generator
- *
- * Generates basic verification checklists for fast mode prompts
- * that don't have comprehensive checklists from deep mode.
- */
-/**
- * Intent-specific checklist templates
- */
-const INTENT_CHECKLISTS = {
-    'code-generation': [
-        {
-            content: 'Code compiles/runs without errors',
-            group: 'Functionality',
-            verificationType: 'automated',
-        },
-        {
-            content: 'All requirements from prompt are implemented',
-            group: 'Functionality',
-            verificationType: 'manual',
-        },
-        {
-            content: 'No console errors or warnings',
-            group: 'Quality',
-            verificationType: 'semi-automated',
-        },
-        {
-            content: 'Code follows project conventions',
-            group: 'Quality',
-            verificationType: 'automated',
-        },
-    ],
-    testing: [
-        {
-            content: 'All tests pass',
-            group: 'Functionality',
-            verificationType: 'automated',
-        },
-        {
-            content: 'Test coverage is acceptable',
-            group: 'Coverage',
-            verificationType: 'automated',
-        },
-        {
-            content: 'Edge cases are tested',
-            group: 'Coverage',
-            verificationType: 'manual',
-        },
-        {
-            content: 'Tests are independent (no shared state)',
-            group: 'Quality',
-            verificationType: 'manual',
-        },
-    ],
-    debugging: [
-        {
-            content: 'Bug is fixed',
-            group: 'Functionality',
-            verificationType: 'manual',
-        },
-        {
-            content: 'No regression introduced',
-            group: 'Regression',
-            verificationType: 'automated',
-        },
-        {
-            content: 'Root cause is addressed',
-            group: 'Analysis',
-            verificationType: 'manual',
-        },
-        {
-            content: 'Related areas tested for side effects',
-            group: 'Regression',
-            verificationType: 'manual',
-        },
-    ],
-    'security-review': [
-        {
-            content: 'Authentication is verified',
-            group: 'Auth',
-            verificationType: 'manual',
-        },
-        {
-            content: 'Input is properly sanitized',
-            group: 'Input',
-            verificationType: 'manual',
-        },
-        {
-            content: 'Sensitive data is protected',
-            group: 'Data',
-            verificationType: 'manual',
-        },
-        {
-            content: 'No known vulnerabilities',
-            group: 'Security',
-            verificationType: 'manual',
-        },
-    ],
-    refinement: [
-        {
-            content: 'Improvement is implemented',
-            group: 'Functionality',
-            verificationType: 'manual',
-        },
-        {
-            content: 'No functionality regression',
-            group: 'Regression',
-            verificationType: 'automated',
-        },
-        {
-            content: 'Performance is not degraded',
-            group: 'Performance',
-            verificationType: 'manual',
-        },
-        {
-            content: 'Code quality is maintained',
-            group: 'Quality',
-            verificationType: 'automated',
-        },
-    ],
-    planning: [
-        {
-            content: 'Plan is clear and actionable',
-            group: 'Clarity',
-            verificationType: 'manual',
-        },
-        {
-            content: 'All requirements are addressed',
-            group: 'Completeness',
-            verificationType: 'manual',
-        },
-        {
-            content: 'Risks are identified',
-            group: 'Risk',
-            verificationType: 'manual',
-        },
-    ],
-    documentation: [
-        {
-            content: 'Documentation is accurate',
-            group: 'Accuracy',
-            verificationType: 'manual',
-        },
-        {
-            content: 'Examples are correct and work',
-            group: 'Accuracy',
-            verificationType: 'manual',
-        },
-        {
-            content: 'Documentation is complete',
-            group: 'Completeness',
-            verificationType: 'manual',
-        },
-    ],
-    migration: [
-        {
-            content: 'Migration completes successfully',
-            group: 'Functionality',
-            verificationType: 'manual',
-        },
-        {
-            content: 'Data integrity is preserved',
-            group: 'Data',
-            verificationType: 'manual',
-        },
-        {
-            content: 'All features work post-migration',
-            group: 'Functionality',
-            verificationType: 'manual',
-        },
-        {
-            content: 'Rollback plan is tested',
-            group: 'Safety',
-            verificationType: 'manual',
-        },
-    ],
-    learning: [
-        {
-            content: 'Concept is understood',
-            group: 'Understanding',
-            verificationType: 'manual',
-        },
-        {
-            content: 'Examples are working',
-            group: 'Practice',
-            verificationType: 'manual',
-        },
-    ],
-    'prd-generation': [
-        {
-            content: 'PRD covers all requirements',
-            group: 'Completeness',
-            verificationType: 'manual',
-        },
-        {
-            content: 'Success criteria are defined',
-            group: 'Clarity',
-            verificationType: 'manual',
-        },
-    ],
-    summarization: [
-        {
-            content: 'Summary captures key points',
-            group: 'Accuracy',
-            verificationType: 'manual',
-        },
-        {
-            content: 'No important details omitted',
-            group: 'Completeness',
-            verificationType: 'manual',
-        },
-    ],
-};
-/**
- * Default checklist for unknown intents
- */
-const DEFAULT_CHECKLIST = [
-    {
-        content: 'Task is completed successfully',
-        group: 'Functionality',
-        verificationType: 'manual',
-    },
-    {
-        content: 'No errors or warnings',
-        group: 'Quality',
-        verificationType: 'semi-automated',
-    },
-    {
-        content: 'Output meets requirements',
-        group: 'Functionality',
-        verificationType: 'manual',
-    },
-];
-/**
- * Basic Checklist Generator
- */
-export class BasicChecklistGenerator {
-    /**
-     * Generate a basic checklist based on intent
-     */
-    generate(intent) {
-        const template = INTENT_CHECKLISTS[intent] || DEFAULT_CHECKLIST;
-        const validationItems = template.map((item, index) => ({
-            id: `generated-${index + 1}`,
-            category: 'validation',
-            content: item.content,
-            group: item.group,
-            verificationType: item.verificationType,
-        }));
-        return {
-            validationItems,
-            edgeCases: [],
-            risks: [],
-            hasChecklist: validationItems.length > 0,
-            totalItems: validationItems.length,
-        };
-    }
-    /**
-     * Generate checklist for a specific prompt content
-     * Detects additional items based on prompt keywords
-     */
-    generateFromPrompt(content, intent) {
-        const baseChecklist = this.generate(intent);
-        const additionalItems = [];
-        const lowerContent = content.toLowerCase();
-        let itemIndex = baseChecklist.validationItems.length;
-        // API-related checks
-        if (this.hasKeywords(lowerContent, ['api', 'endpoint', 'route', 'rest', 'graphql'])) {
-            additionalItems.push({
-                id: `generated-${++itemIndex}`,
-                category: 'validation',
-                content: 'API endpoints return correct responses',
-                group: 'API',
-                verificationType: 'manual',
-            });
-        }
-        // UI-related checks
-        if (this.hasKeywords(lowerContent, ['ui', 'component', 'form', 'page', 'button'])) {
-            additionalItems.push({
-                id: `generated-${++itemIndex}`,
-                category: 'validation',
-                content: 'UI renders correctly',
-                group: 'UI',
-                verificationType: 'semi-automated',
-            });
-        }
-        // Database-related checks
-        if (this.hasKeywords(lowerContent, ['database', 'db', 'query', 'schema', 'migration'])) {
-            additionalItems.push({
-                id: `generated-${++itemIndex}`,
-                category: 'validation',
-                content: 'Database operations work correctly',
-                group: 'Data',
-                verificationType: 'manual',
-            });
-        }
-        // Auth-related checks
-        if (this.hasKeywords(lowerContent, ['auth', 'login', 'session', 'token', 'permission'])) {
-            additionalItems.push({
-                id: `generated-${++itemIndex}`,
-                category: 'validation',
-                content: 'Authentication/authorization works correctly',
-                group: 'Security',
-                verificationType: 'manual',
-            });
-        }
-        // Performance-related checks
-        if (this.hasKeywords(lowerContent, ['performance', 'optimize', 'speed', 'fast', 'slow'])) {
-            additionalItems.push({
-                id: `generated-${++itemIndex}`,
-                category: 'validation',
-                content: 'Performance is acceptable',
-                group: 'Performance',
-                verificationType: 'manual',
-            });
-        }
-        return {
-            validationItems: [...baseChecklist.validationItems, ...additionalItems],
-            edgeCases: baseChecklist.edgeCases,
-            risks: baseChecklist.risks,
-            hasChecklist: true,
-            totalItems: baseChecklist.validationItems.length + additionalItems.length,
-        };
-    }
-    /**
-     * Check if content contains any of the keywords
-     */
-    hasKeywords(content, keywords) {
-        return keywords.some((kw) => content.includes(kw));
-    }
-    /**
-     * Get available intents
-     */
-    getAvailableIntents() {
-        return Object.keys(INTENT_CHECKLISTS);
-    }
-    /**
-     * Check if intent has a specific checklist
-     */
-    hasChecklistForIntent(intent) {
-        return intent in INTENT_CHECKLISTS;
-    }
-}
-//# sourceMappingURL=basic-checklist-generator.js.map

package/dist/core/checklist-parser.d.ts

@@ -1,48 +0,0 @@
-/**
- * Clavix v4.8: Checklist Parser
- *
- * Parses validation checklists, edge cases, and risk sections from
- * deep mode prompt output files.
- */
-import { ChecklistItem, ParsedChecklist, VerificationType } from '../types/verification.js';
-/**
- * Parse checklist items from prompt content
- */
-export declare class ChecklistParser {
-    /**
-     * Parse all checklist sections from prompt content
-     */
-    parse(content: string): ParsedChecklist;
-    /**
-     * Parse the Validation Checklist section
-     */
-    parseValidationSection(content: string): ChecklistItem[];
-    /**
-     * Parse the Edge Cases to Consider section
-     */
-    parseEdgeCaseSection(content: string): ChecklistItem[];
-    /**
-     * Parse the What Could Go Wrong section
-     */
-    parseRiskSection(content: string): ChecklistItem[];
-    /**
-     * Detect verification type based on item content
-     */
-    detectVerificationType(content: string): VerificationType;
-    /**
-     * Get a summary of the parsed checklist
-     */
-    getSummary(checklist: ParsedChecklist): {
-        validation: number;
-        edgeCases: number;
-        risks: number;
-        automated: number;
-        semiAutomated: number;
-        manual: number;
-    };
-    /**
-     * Check if content has any checklist sections
-     */
-    hasChecklist(content: string): boolean;
-}
-//# sourceMappingURL=checklist-parser.d.ts.map

package/dist/core/checklist-parser.js

@@ -1,238 +0,0 @@
-/**
- * Clavix v4.8: Checklist Parser
- *
- * Parses validation checklists, edge cases, and risk sections from
- * deep mode prompt output files.
- */
-/**
- * Regex patterns for parsing checklist sections
- */
-const PATTERNS = {
-    // Section headers (support both ## and ### headers)
-    validationSection: /#{2,3}\s*Validation\s+Checklist[\s\S]*?(?=#{2,3}|$)/i,
-    edgeCaseSection: /#{2,3}\s*Edge\s+Cases?\s+to\s+Consider[\s\S]*?(?=#{2,3}|$)/i,
-    riskSection: /#{2,3}\s*What\s+Could\s+Go\s+Wrong[\s\S]*?(?=#{2,3}|$)/i,
-    // Item patterns
-    checklistItem: /[☐□○●◯]\s*(.+)$/gm, // Various checkbox characters
-    categoryHeader: /\*\*(.+?):\*\*/g,
-    edgeCaseItem: /[•\-*]\s*\*\*(.+?)\*\*:?\s*(.+?)$/gm,
-    riskItem: /[•\-*]\s*\*\*(.+?)\*\*:?\s*(.+?)$/gm,
-    bulletItem: /[•\-*]\s+(.+?)$/gm,
-};
-/**
- * Keywords for determining verification type
- */
-const VERIFICATION_TYPE_KEYWORDS = {
-    automated: [
-        'compiles',
-        'builds',
-        'tests pass',
-        'all tests',
-        'test coverage',
-        'lint',
-        'typecheck',
-        'no errors',
-        'exit code',
-        'npm test',
-        'npm run',
-        'build succeeds',
-        'build passes',
-    ],
-    semiAutomated: [
-        'renders',
-        'displays',
-        'console errors',
-        'console warnings',
-        'no warnings',
-        'ui renders',
-        'responsive',
-        'screen sizes',
-        'visual',
-        'layout',
-    ],
-    // Everything else defaults to manual
-};
-/**
- * Parse checklist items from prompt content
- */
-export class ChecklistParser {
-    /**
-     * Parse all checklist sections from prompt content
-     */
-    parse(content) {
-        const validationItems = this.parseValidationSection(content);
-        const edgeCases = this.parseEdgeCaseSection(content);
-        const risks = this.parseRiskSection(content);
-        const totalItems = validationItems.length + edgeCases.length + risks.length;
-        return {
-            validationItems,
-            edgeCases,
-            risks,
-            hasChecklist: totalItems > 0,
-            totalItems,
-        };
-    }
-    /**
-     * Parse the Validation Checklist section
-     */
-    parseValidationSection(content) {
-        const sectionMatch = content.match(PATTERNS.validationSection);
-        if (!sectionMatch)
-            return [];
-        const section = sectionMatch[0];
-        const items = [];
-        let currentGroup;
-        let itemIndex = 0;
-        // Split by lines and process
-        const lines = section.split('\n');
-        for (const line of lines) {
-            // Check for category header
-            const categoryMatch = line.match(/\*\*(.+?):\*\*/);
-            if (categoryMatch) {
-                currentGroup = categoryMatch[1].trim();
-                continue;
-            }
-            // Check for checklist item (Unicode checkbox or markdown checkbox)
-            const itemMatch = line.match(/(?:[☐□○●◯]|-\s*\[\s*\])\s*(.+)$/);
-            if (itemMatch) {
-                const itemContent = itemMatch[1].trim();
-                const verificationType = this.detectVerificationType(itemContent);
-                items.push({
-                    id: `validation-${++itemIndex}`,
-                    category: 'validation',
-                    content: itemContent,
-                    group: currentGroup,
-                    verificationType,
-                });
-            }
-        }
-        return items;
-    }
-    /**
-     * Parse the Edge Cases to Consider section
-     */
-    parseEdgeCaseSection(content) {
-        const sectionMatch = content.match(PATTERNS.edgeCaseSection);
-        if (!sectionMatch)
-            return [];
-        const section = sectionMatch[0];
-        const items = [];
-        let itemIndex = 0;
-        // Match edge case items with scenario and consideration
-        const regex = /[•\-*]\s*\*\*(.+?)\*\*:?\s*(.+?)$/gm;
-        let match;
-        while ((match = regex.exec(section)) !== null) {
-            const scenario = match[1].trim();
-            const consideration = match[2].trim();
-            const itemContent = `${scenario}: ${consideration}`;
-            items.push({
-                id: `edge-case-${++itemIndex}`,
-                category: 'edge-case',
-                content: itemContent,
-                group: scenario,
-                verificationType: 'manual', // Edge cases are typically manual
-            });
-        }
-        // Also try to match simple bullet items without bold scenario
-        if (items.length === 0) {
-            const simpleRegex = /[•\-*]\s+([^*\n]+)$/gm;
-            while ((match = simpleRegex.exec(section)) !== null) {
-                const itemContent = match[1].trim();
-                if (itemContent && !itemContent.startsWith('#')) {
-                    items.push({
-                        id: `edge-case-${++itemIndex}`,
-                        category: 'edge-case',
-                        content: itemContent,
-                        verificationType: 'manual',
-                    });
-                }
-            }
-        }
-        return items;
-    }
-    /**
-     * Parse the What Could Go Wrong section
-     */
-    parseRiskSection(content) {
-        const sectionMatch = content.match(PATTERNS.riskSection);
-        if (!sectionMatch)
-            return [];
-        const section = sectionMatch[0];
-        const items = [];
-        let itemIndex = 0;
-        // Match risk items with bold titles
-        const regex = /[•\-*]\s*\*\*(.+?)\*\*:?\s*(.*)$/gm;
-        let match;
-        while ((match = regex.exec(section)) !== null) {
-            const risk = match[1].trim();
-            const details = match[2]?.trim() || '';
-            const itemContent = details ? `${risk}: ${details}` : risk;
-            items.push({
-                id: `risk-${++itemIndex}`,
-                category: 'risk',
-                content: itemContent,
-                group: risk,
-                verificationType: 'manual', // Risks are typically manual verification
-            });
-        }
-        // Also try to match simple bullet items
-        if (items.length === 0) {
-            const simpleRegex = /[•\-*]\s+([^*\n]+)$/gm;
-            while ((match = simpleRegex.exec(section)) !== null) {
-                const itemContent = match[1].trim();
-                if (itemContent && !itemContent.startsWith('#')) {
-                    items.push({
-                        id: `risk-${++itemIndex}`,
-                        category: 'risk',
-                        content: itemContent,
-                        verificationType: 'manual',
-                    });
-                }
-            }
-        }
-        return items;
-    }
-    /**
-     * Detect verification type based on item content
-     */
-    detectVerificationType(content) {
-        const lowerContent = content.toLowerCase();
-        // Check for automated keywords
-        for (const keyword of VERIFICATION_TYPE_KEYWORDS.automated) {
-            if (lowerContent.includes(keyword)) {
-                return 'automated';
-            }
-        }
-        // Check for semi-automated keywords
-        for (const keyword of VERIFICATION_TYPE_KEYWORDS.semiAutomated) {
-            if (lowerContent.includes(keyword)) {
-                return 'semi-automated';
-            }
-        }
-        // Default to manual
-        return 'manual';
-    }
-    /**
-     * Get a summary of the parsed checklist
-     */
-    getSummary(checklist) {
-        const allItems = [...checklist.validationItems, ...checklist.edgeCases, ...checklist.risks];
-        return {
-            validation: checklist.validationItems.length,
-            edgeCases: checklist.edgeCases.length,
-            risks: checklist.risks.length,
-            automated: allItems.filter((i) => i.verificationType === 'automated').length,
-            semiAutomated: allItems.filter((i) => i.verificationType === 'semi-automated').length,
-            manual: allItems.filter((i) => i.verificationType === 'manual').length,
-        };
-    }
-    /**
-     * Check if content has any checklist sections
-     */
-    hasChecklist(content) {
-        return (PATTERNS.validationSection.test(content) ||
-            PATTERNS.edgeCaseSection.test(content) ||
-            PATTERNS.riskSection.test(content));
-    }
-}
-//# sourceMappingURL=checklist-parser.js.map