clavix 4.7.0 → 4.8.1

package/dist/core/adapters/roocode-adapter.d.ts

@@ -20,6 +20,9 @@ export declare class RoocodeAdapter extends BaseAdapter {
     readonly features: {
         supportsSubdirectories: boolean;
         supportsFrontmatter: boolean;
+        commandFormat: {
+            separator: "-";
+        };
     };
     /**
      * Detect if Roocode is available in the project

package/dist/core/adapters/roocode-adapter.js

@@ -20,6 +20,7 @@ export class RoocodeAdapter extends BaseAdapter {
     features = {
         supportsSubdirectories: false,
         supportsFrontmatter: true,
+        commandFormat: { separator: '-' },
     };
     /**
      * Detect if Roocode is available in the project

package/dist/core/adapters/windsurf-adapter.d.ts

@@ -19,6 +19,9 @@ export declare class WindsurfAdapter extends BaseAdapter {
     readonly features: {
         supportsSubdirectories: boolean;
         supportsFrontmatter: boolean;
+        commandFormat: {
+            separator: "-";
+        };
     };
     /**
      * Detect if Windsurf is available in the project

package/dist/core/adapters/windsurf-adapter.js

@@ -20,6 +20,7 @@ export class WindsurfAdapter extends BaseAdapter {
     features = {
         supportsSubdirectories: true,
         supportsFrontmatter: false,
+        commandFormat: { separator: '-' },
     };
     /**
      * Detect if Windsurf is available in the project

package/dist/core/basic-checklist-generator.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Clavix v4.8: Basic Checklist Generator
+ *
+ * Generates basic verification checklists for fast mode prompts
+ * that don't have comprehensive checklists from deep mode.
+ */
+import { PromptIntent } from './intelligence/types.js';
+import { ParsedChecklist } from '../types/verification.js';
+/**
+ * Basic Checklist Generator
+ */
+export declare class BasicChecklistGenerator {
+    /**
+     * Generate a basic checklist based on intent
+     */
+    generate(intent: PromptIntent): ParsedChecklist;
+    /**
+     * Generate checklist for a specific prompt content
+     * Detects additional items based on prompt keywords
+     */
+    generateFromPrompt(content: string, intent: PromptIntent): ParsedChecklist;
+    /**
+     * Check if content contains any of the keywords
+     */
+    private hasKeywords;
+    /**
+     * Get available intents
+     */
+    getAvailableIntents(): PromptIntent[];
+    /**
+     * Check if intent has a specific checklist
+     */
+    hasChecklistForIntent(intent: PromptIntent): boolean;
+}
+//# sourceMappingURL=basic-checklist-generator.d.ts.map

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