clavix 4.7.0 → 4.8.1

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/command-transformer.d.ts

@@ -0,0 +1,55 @@
+import { IntegrationFeatures } from '../types/agent.js';
+/**
+ * CommandTransformer - Transforms slash command references in template content
+ *
+ * Handles conversion between command formats:
+ * - Colon format: /clavix:fast (Claude Code style - uses subdirectories)
+ * - Hyphen format: /clavix-fast (Cursor, Droid style - flat files)
+ *
+ * Preserves CLI commands (clavix prompts list) unchanged - only transforms
+ * slash commands that start with /clavix:
+ *
+ * @since v4.8.1
+ */
+export declare class CommandTransformer {
+    /**
+     * Matches /clavix:commandname pattern
+     * Supports hyphenated commands like task-complete
+     * Does NOT match CLI usage (no leading slash)
+     */
+    private static readonly SLASH_COMMAND_PATTERN;
+    /** Default command format (canonical/Claude Code style) */
+    private static readonly DEFAULT_SEPARATOR;
+    /**
+     * Transform slash command references in content based on adapter's command format
+     *
+     * @param content - Template content with canonical /clavix:command references
+     * @param features - Adapter's integration features (may include commandFormat)
+     * @returns Transformed content with correct command format
+     *
+     * @example
+     * // For Cursor/Droid (hyphen format):
+     * transform('/clavix:fast', { commandFormat: { separator: '-' } })
+     * // Returns: '/clavix-fast'
+     *
+     * @example
+     * // For Claude Code (colon format, default):
+     * transform('/clavix:fast', { commandFormat: { separator: ':' } })
+     * // Returns: '/clavix:fast' (unchanged)
+     */
+    static transform(content: string, features?: IntegrationFeatures): string;
+    /**
+     * Get the formatted command name for a specific adapter
+     * Useful for generating documentation or references
+     *
+     * @param commandName - Base command name (e.g., 'fast', 'execute', 'task-complete')
+     * @param features - Adapter's integration features
+     * @returns Formatted slash command (e.g., '/clavix:fast' or '/clavix-fast')
+     *
+     * @example
+     * formatCommand('execute', { commandFormat: { separator: '-' } })
+     * // Returns: '/clavix-execute'
+     */
+    static formatCommand(commandName: string, features?: IntegrationFeatures): string;
+}
+//# sourceMappingURL=command-transformer.d.ts.map

package/dist/core/command-transformer.js

@@ -0,0 +1,65 @@
+/**
+ * CommandTransformer - Transforms slash command references in template content
+ *
+ * Handles conversion between command formats:
+ * - Colon format: /clavix:fast (Claude Code style - uses subdirectories)
+ * - Hyphen format: /clavix-fast (Cursor, Droid style - flat files)
+ *
+ * Preserves CLI commands (clavix prompts list) unchanged - only transforms
+ * slash commands that start with /clavix:
+ *
+ * @since v4.8.1
+ */
+export class CommandTransformer {
+    /**
+     * Matches /clavix:commandname pattern
+     * Supports hyphenated commands like task-complete
+     * Does NOT match CLI usage (no leading slash)
+     */
+    static SLASH_COMMAND_PATTERN = /\/clavix:(\w+(?:-\w+)*)/g;
+    /** Default command format (canonical/Claude Code style) */
+    static DEFAULT_SEPARATOR = ':';
+    /**
+     * Transform slash command references in content based on adapter's command format
+     *
+     * @param content - Template content with canonical /clavix:command references
+     * @param features - Adapter's integration features (may include commandFormat)
+     * @returns Transformed content with correct command format
+     *
+     * @example
+     * // For Cursor/Droid (hyphen format):
+     * transform('/clavix:fast', { commandFormat: { separator: '-' } })
+     * // Returns: '/clavix-fast'
+     *
+     * @example
+     * // For Claude Code (colon format, default):
+     * transform('/clavix:fast', { commandFormat: { separator: ':' } })
+     * // Returns: '/clavix:fast' (unchanged)
+     */
+    static transform(content, features) {
+        const separator = features?.commandFormat?.separator ?? this.DEFAULT_SEPARATOR;
+        // If using canonical format (colon), no transformation needed
+        if (separator === ':') {
+            return content;
+        }
+        // Transform /clavix:command to /clavix-command (or other separator)
+        return content.replace(this.SLASH_COMMAND_PATTERN, `/clavix${separator}$1`);
+    }
+    /**
+     * Get the formatted command name for a specific adapter
+     * Useful for generating documentation or references
+     *
+     * @param commandName - Base command name (e.g., 'fast', 'execute', 'task-complete')
+     * @param features - Adapter's integration features
+     * @returns Formatted slash command (e.g., '/clavix:fast' or '/clavix-fast')
+     *
+     * @example
+     * formatCommand('execute', { commandFormat: { separator: '-' } })
+     * // Returns: '/clavix-execute'
+     */
+    static formatCommand(commandName, features) {
+        const separator = features?.commandFormat?.separator ?? this.DEFAULT_SEPARATOR;
+        return `/clavix${separator}${commandName}`;
+    }
+}
+//# sourceMappingURL=command-transformer.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
      */

package/dist/core/prompt-manager.js

@@ -56,6 +56,10 @@ export class PromptManager {
             executed: false,
             executedAt: null,
             linkedProject,
+            // Verification tracking (v4.8)
+            verificationRequired: true,
+            verified: false,
+            verifiedAt: null,
         };
         // Create file with frontmatter
         const frontmatter = [
@@ -66,9 +70,13 @@ export class PromptManager {
             `executed: ${metadata.executed}`,
             `originalPrompt: ${originalPrompt}`,
             linkedProject ? `linkedProject: ${linkedProject}` : '',
+            `verificationRequired: ${metadata.verificationRequired}`,
+            `verified: ${metadata.verified}`,
             '---',
             '',
-        ].filter(Boolean).join('\n');
+        ]
+            .filter(Boolean)
+            .join('\n');
         const fileContent = frontmatter + content;
         await fs.writeFile(filePath, fileContent, 'utf-8');
         // Update index
@@ -80,12 +88,12 @@ export class PromptManager {
      */
     async loadPrompt(id) {
         const index = await this.loadIndex();
-        const metadata = index.prompts.find(p => p.id === id);
+        const metadata = index.prompts.find((p) => p.id === id);
         if (!metadata) {
             return null;
         }
         const filePath = path.join(this.promptsDir, metadata.source, metadata.filename);
-        if (!await fs.pathExists(filePath)) {
+        if (!(await fs.pathExists(filePath))) {
             return null;
         }
         const content = await fs.readFile(filePath, 'utf-8');
@@ -105,24 +113,24 @@ export class PromptManager {
         // Ensure index exists when filtering by source (for corruption recovery tests)
         if (filters?.source) {
             const indexPath = this.getIndexPath(filters.source);
-            if (!await fs.pathExists(indexPath)) {
+            if (!(await fs.pathExists(indexPath))) {
                 await this.saveIndex({ version: '1.0', prompts: [] }, filters.source);
             }
         }
         // Apply filters
         if (filters) {
             if (filters.executed !== undefined) {
-                prompts = prompts.filter(p => p.executed === filters.executed);
+                prompts = prompts.filter((p) => p.executed === filters.executed);
             }
             if (filters.stale) {
-                prompts = prompts.filter(p => this.getPromptAge(p) > 30);
+                prompts = prompts.filter((p) => this.getPromptAge(p) > 30);
             }
             if (filters.old) {
-                prompts = prompts.filter(p => this.getPromptAge(p) > 7);
+                prompts = prompts.filter((p) => this.getPromptAge(p) > 7);
             }
         }
         // Add age calculation
-        prompts = prompts.map(p => ({
+        prompts = prompts.map((p) => ({
             ...p,
             createdAt: new Date(p.timestamp),
             ageInDays: this.getPromptAge(p),
@@ -139,19 +147,38 @@ export class PromptManager {
     async markExecuted(id) {
         // Load all indexes to find the prompt
         const allPrompts = await this.listPrompts();
-        const prompt = allPrompts.find(p => p.id === id);
+        const prompt = allPrompts.find((p) => p.id === id);
         if (!prompt) {
             throw new Error(`Prompt not found: ${id}`);
         }
         // Load source-specific index
         const index = await this.loadIndex(prompt.source);
-        const indexPrompt = index.prompts.find(p => p.id === id);
+        const indexPrompt = index.prompts.find((p) => p.id === id);
         if (indexPrompt) {
             indexPrompt.executed = true;
             indexPrompt.executedAt = new Date().toISOString();
             await this.saveIndex(index, prompt.source);
         }
     }
+    /**
+     * Mark prompt as verified (v4.8)
+     */
+    async markVerified(id) {
+        // Load all indexes to find the prompt
+        const allPrompts = await this.listPrompts();
+        const prompt = allPrompts.find((p) => p.id === id);
+        if (!prompt) {
+            throw new Error(`Prompt not found: ${id}`);
+        }
+        // Load source-specific index
+        const index = await this.loadIndex(prompt.source);
+        const indexPrompt = index.prompts.find((p) => p.id === id);
+        if (indexPrompt) {
+            indexPrompt.verified = true;
+            indexPrompt.verifiedAt = new Date().toISOString();
+            await this.saveIndex(index, prompt.source);
+        }
+    }
     /**
      * Delete prompts by filter
      */
@@ -174,7 +201,7 @@ export class PromptManager {
         // Update each source index
         for (const [source, deletedIds] of bySource.entries()) {
             const index = await this.loadIndex(source);
-            index.prompts = index.prompts.filter(p => !deletedIds.has(p.id));
+            index.prompts = index.prompts.filter((p) => !deletedIds.has(p.id));
             await this.saveIndex(index, source);
         }
         return deleteCount;
@@ -201,15 +228,13 @@ export class PromptManager {
         const allPrompts = await this.listPrompts();
         const stats = {
             totalPrompts: allPrompts.length,
-            fastPrompts: allPrompts.filter(p => p.source === 'fast').length,
-            deepPrompts: allPrompts.filter(p => p.source === 'deep').length,
-            executedPrompts: allPrompts.filter(p => p.executed).length,
-            pendingPrompts: allPrompts.filter(p => !p.executed).length,
-            stalePrompts: allPrompts.filter(p => (p.ageInDays || 0) > 30).length,
-            oldPrompts: allPrompts.filter(p => (p.ageInDays || 0) > 7).length,
-            oldestPromptAge: allPrompts.length > 0
-                ? Math.max(...allPrompts.map(p => p.ageInDays || 0))
-                : 0,
+            fastPrompts: allPrompts.filter((p) => p.source === 'fast').length,
+            deepPrompts: allPrompts.filter((p) => p.source === 'deep').length,
+            executedPrompts: allPrompts.filter((p) => p.executed).length,
+            pendingPrompts: allPrompts.filter((p) => !p.executed).length,
+            stalePrompts: allPrompts.filter((p) => (p.ageInDays || 0) > 30).length,
+            oldPrompts: allPrompts.filter((p) => (p.ageInDays || 0) > 7).length,
+            oldestPromptAge: allPrompts.length > 0 ? Math.max(...allPrompts.map((p) => p.ageInDays || 0)) : 0,
         };
         return stats;
     }
@@ -230,7 +255,7 @@ export class PromptManager {
         }
         // Load specific source index
         const indexPath = this.getIndexPath(source);
-        if (!await fs.pathExists(indexPath)) {
+        if (!(await fs.pathExists(indexPath))) {
             return {
                 version: '1.0',
                 prompts: [],
@@ -267,7 +292,7 @@ export class PromptManager {
     async addToIndex(metadata) {
         const index = await this.loadIndex(metadata.source);
         // Remove any existing entry with same ID (shouldn't happen, but be safe)
-        index.prompts = index.prompts.filter(p => p.id !== metadata.id);
+        index.prompts = index.prompts.filter((p) => p.id !== metadata.id);
         // Add new entry
         index.prompts.push(metadata);
         await this.saveIndex(index, metadata.source);

package/dist/core/verification-hooks.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Clavix v4.8: Verification Hooks
+ *
+ * Detects and executes CLI hooks for automated verification of checklist items.
+ * Supports npm, yarn, and pnpm package managers.
+ */
+import { VerificationHook, HookResult, HookType, DetectedHooks } from '../types/verification.js';
+/**
+ * Verification Hooks Manager
+ */
+export declare class VerificationHooks {
+    private readonly cwd;
+    private detectedHooks;
+    constructor(cwd?: string);
+    /**
+     * Detect available hooks in the project
+     */
+    detectHooks(): Promise<DetectedHooks>;
+    /**
+     * Detect package manager used in the project
+     */
+    private detectPackageManager;
+    /**
+     * Create a hook definition
+     */
+    private createHook;
+    /**
+     * Run a specific hook
+     */
+    runHook(hook: VerificationHook): Promise<HookResult>;
+    /**
+     * Run all detected hooks
+     */
+    runAllHooks(): Promise<HookResult[]>;
+    /**
+     * Run a hook by type
+     */
+    runHookByType(type: HookType): Promise<HookResult | null>;
+    /**
+     * Execute a command and capture output
+     */
+    private executeCommand;
+    /**
+     * Determine if the hook succeeded
+     */
+    private determineSuccess;
+    /**
+     * Determine confidence level in the result
+     */
+    private determineConfidence;
+    /**
+     * Get hook by type
+     */
+    getHook(type: HookType): Promise<VerificationHook | null>;
+    /**
+     * Check if a hook type is available
+     */
+    hasHook(type: HookType): Promise<boolean>;
+    /**
+     * Get summary of available hooks
+     */
+    getHookSummary(): Promise<{
+        available: HookType[];
+        unavailable: HookType[];
+    }>;
+}
+//# sourceMappingURL=verification-hooks.d.ts.map