clavix 4.6.0 → 4.8.0

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

@@ -0,0 +1,344 @@
+/**
+ * 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

@@ -0,0 +1,48 @@
+/**
+ * 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

@@ -0,0 +1,238 @@
+/**
+ * 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

package/dist/core/prompt-manager.d.ts

@@ -11,6 +11,9 @@ export interface PromptMetadata {
     executedAt: string | null;
     ageInDays?: number;
     linkedProject?: string;
+    verificationRequired: boolean;
+    verified: boolean;
+    verifiedAt: string | null;
 }
 export interface PromptsIndex {
     version: string;
@@ -67,6 +70,10 @@ export declare class PromptManager {
      * Mark prompt as executed
      */
     markExecuted(id: string): Promise<void>;
+    /**
+     * Mark prompt as verified (v4.8)
+     */
+    markVerified(id: string): Promise<void>;
     /**
      * Delete prompts by filter
      */