clavix 4.7.0 → 4.8.0

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

package/dist/core/verification-hooks.js

@@ -0,0 +1,309 @@
+/**
+ * Clavix v4.8: Verification Hooks
+ *
+ * Detects and executes CLI hooks for automated verification of checklist items.
+ * Supports npm, yarn, and pnpm package managers.
+ */
+import { spawn } from 'child_process';
+import fs from 'fs-extra';
+import * as path from 'path';
+/**
+ * Default timeout for hooks (60 seconds)
+ */
+const DEFAULT_TIMEOUT = 60000;
+/**
+ * Built-in hook definitions
+ */
+const HOOK_DEFINITIONS = {
+    test: {
+        displayName: 'Tests',
+        commands: ['npm test', 'npm run test', 'yarn test', 'pnpm test'],
+        successPatterns: [
+            /(\d+)\s+(passing|passed)/i,
+            /tests?\s+passed/i,
+            /all\s+tests?\s+passed/i,
+            /0\s+failed/i,
+            /test\s+suites?:\s+\d+\s+passed/i,
+        ],
+        failurePatterns: [/(\d+)\s+failed/i, /test\s+failed/i, /FAIL/i, /error/i],
+    },
+    build: {
+        displayName: 'Build',
+        commands: ['npm run build', 'yarn build', 'pnpm build', 'tsc'],
+        successPatterns: [/successfully/i, /done/i, /built/i, /compiled/i],
+        failurePatterns: [/error/i, /failed/i, /TS\d{4}:/],
+    },
+    lint: {
+        displayName: 'Lint',
+        commands: ['npm run lint', 'yarn lint', 'pnpm lint', 'eslint .'],
+        successPatterns: [/0\s+errors?/i, /no\s+errors?/i, /all\s+files?\s+pass/i],
+        failurePatterns: [/(\d+)\s+errors?/i, /error/i],
+    },
+    typecheck: {
+        displayName: 'Type Check',
+        commands: ['tsc --noEmit', 'npm run typecheck', 'yarn typecheck'],
+        successPatterns: [/^$/], // Empty output means success for tsc
+        failurePatterns: [/error\s+TS\d{4}/i, /Type\s+error/i],
+    },
+    custom: {
+        displayName: 'Custom',
+        commands: [],
+        successPatterns: [],
+        failurePatterns: [],
+    },
+};
+/**
+ * Verification Hooks Manager
+ */
+export class VerificationHooks {
+    cwd;
+    detectedHooks = null;
+    constructor(cwd) {
+        this.cwd = cwd || process.cwd();
+    }
+    /**
+     * Detect available hooks in the project
+     */
+    async detectHooks() {
+        if (this.detectedHooks) {
+            return this.detectedHooks;
+        }
+        const packageJsonPath = path.join(this.cwd, 'package.json');
+        const hasPackageJson = await fs.pathExists(packageJsonPath);
+        const packageManager = await this.detectPackageManager();
+        const hooks = [];
+        if (hasPackageJson) {
+            try {
+                const packageJson = await fs.readJson(packageJsonPath);
+                const scripts = packageJson.scripts || {};
+                // Check for test script
+                if (scripts.test) {
+                    hooks.push(this.createHook('test', `${packageManager} test`, packageManager));
+                }
+                // Check for build script
+                if (scripts.build) {
+                    hooks.push(this.createHook('build', `${packageManager} run build`, packageManager));
+                }
+                // Check for lint script
+                if (scripts.lint) {
+                    hooks.push(this.createHook('lint', `${packageManager} run lint`, packageManager));
+                }
+                // Check for typecheck script
+                if (scripts.typecheck || scripts['type-check']) {
+                    const cmd = scripts.typecheck ? 'typecheck' : 'type-check';
+                    hooks.push(this.createHook('typecheck', `${packageManager} run ${cmd}`, packageManager));
+                }
+                else {
+                    // Check for TypeScript
+                    const hasTsConfig = await fs.pathExists(path.join(this.cwd, 'tsconfig.json'));
+                    if (hasTsConfig) {
+                        hooks.push(this.createHook('typecheck', 'npx tsc --noEmit', packageManager));
+                    }
+                }
+            }
+            catch {
+                // Ignore errors reading package.json
+            }
+        }
+        this.detectedHooks = {
+            hooks,
+            packageManager,
+            hasPackageJson,
+        };
+        return this.detectedHooks;
+    }
+    /**
+     * Detect package manager used in the project
+     */
+    async detectPackageManager() {
+        // Check for lock files
+        if (await fs.pathExists(path.join(this.cwd, 'pnpm-lock.yaml'))) {
+            return 'pnpm';
+        }
+        if (await fs.pathExists(path.join(this.cwd, 'yarn.lock'))) {
+            return 'yarn';
+        }
+        if (await fs.pathExists(path.join(this.cwd, 'package-lock.json'))) {
+            return 'npm';
+        }
+        return 'unknown';
+    }
+    /**
+     * Create a hook definition
+     */
+    createHook(type, command, _packageManager) {
+        const def = HOOK_DEFINITIONS[type];
+        return {
+            name: type,
+            displayName: def.displayName,
+            command,
+            successPattern: def.successPatterns[0],
+            failurePattern: def.failurePatterns[0],
+            timeout: DEFAULT_TIMEOUT,
+        };
+    }
+    /**
+     * Run a specific hook
+     */
+    async runHook(hook) {
+        const startTime = Date.now();
+        try {
+            const { exitCode, output } = await this.executeCommand(hook.command, hook.timeout);
+            const executionTimeMs = Date.now() - startTime;
+            // Determine success based on exit code and patterns
+            const success = this.determineSuccess(hook, exitCode, output);
+            const confidence = this.determineConfidence(hook, exitCode, output, success);
+            return {
+                hook,
+                success,
+                exitCode,
+                output,
+                confidence,
+                executionTimeMs,
+            };
+        }
+        catch (error) {
+            const executionTimeMs = Date.now() - startTime;
+            return {
+                hook,
+                success: false,
+                exitCode: -1,
+                output: '',
+                confidence: 'low',
+                executionTimeMs,
+                error: error instanceof Error ? error.message : String(error),
+            };
+        }
+    }
+    /**
+     * Run all detected hooks
+     */
+    async runAllHooks() {
+        const detected = await this.detectHooks();
+        const results = [];
+        for (const hook of detected.hooks) {
+            const result = await this.runHook(hook);
+            results.push(result);
+        }
+        return results;
+    }
+    /**
+     * Run a hook by type
+     */
+    async runHookByType(type) {
+        const detected = await this.detectHooks();
+        const hook = detected.hooks.find((h) => h.name === type);
+        if (!hook) {
+            return null;
+        }
+        return this.runHook(hook);
+    }
+    /**
+     * Execute a command and capture output
+     */
+    executeCommand(command, timeout) {
+        return new Promise((resolve, reject) => {
+            const [cmd, ...args] = command.split(' ');
+            let output = '';
+            const proc = spawn(cmd, args, {
+                cwd: this.cwd,
+                shell: true,
+                env: { ...process.env, CI: 'true', FORCE_COLOR: '0' },
+            });
+            const timeoutId = setTimeout(() => {
+                proc.kill('SIGTERM');
+                reject(new Error(`Command timed out after ${timeout}ms`));
+            }, timeout);
+            proc.stdout?.on('data', (data) => {
+                output += data.toString();
+            });
+            proc.stderr?.on('data', (data) => {
+                output += data.toString();
+            });
+            proc.on('close', (code) => {
+                clearTimeout(timeoutId);
+                resolve({
+                    exitCode: code ?? 0,
+                    output: output.trim(),
+                });
+            });
+            proc.on('error', (error) => {
+                clearTimeout(timeoutId);
+                reject(error);
+            });
+        });
+    }
+    /**
+     * Determine if the hook succeeded
+     */
+    determineSuccess(hook, exitCode, output) {
+        // Exit code 0 is primary success indicator
+        if (exitCode !== 0) {
+            return false;
+        }
+        // Check for explicit failure patterns
+        const def = HOOK_DEFINITIONS[hook.name];
+        for (const pattern of def.failurePatterns) {
+            if (pattern.test(output)) {
+                // Check if it's a "0 errors" type match
+                const match = output.match(pattern);
+                if (match && match[1] === '0') {
+                    continue; // "0 errors" is success
+                }
+                return false;
+            }
+        }
+        return true;
+    }
+    /**
+     * Determine confidence level in the result
+     */
+    determineConfidence(hook, exitCode, output, success) {
+        const def = HOOK_DEFINITIONS[hook.name];
+        // Clear exit code with matching success patterns = high confidence
+        if (exitCode === 0 && success) {
+            for (const pattern of def.successPatterns) {
+                if (pattern.test(output)) {
+                    return 'high';
+                }
+            }
+            // Exit 0 but no explicit success pattern
+            return 'medium';
+        }
+        // Clear failure indicators
+        if (exitCode !== 0 || !success) {
+            for (const pattern of def.failurePatterns) {
+                if (pattern.test(output)) {
+                    return 'high';
+                }
+            }
+            return 'medium';
+        }
+        return 'low';
+    }
+    /**
+     * Get hook by type
+     */
+    async getHook(type) {
+        const detected = await this.detectHooks();
+        return detected.hooks.find((h) => h.name === type) || null;
+    }
+    /**
+     * Check if a hook type is available
+     */
+    async hasHook(type) {
+        const detected = await this.detectHooks();
+        return detected.hooks.some((h) => h.name === type);
+    }
+    /**
+     * Get summary of available hooks
+     */
+    async getHookSummary() {
+        const detected = await this.detectHooks();
+        const allTypes = ['test', 'build', 'lint', 'typecheck'];
+        const available = detected.hooks.map((h) => h.name);
+        const unavailable = allTypes.filter((t) => !available.includes(t));
+        return { available, unavailable };
+    }
+}
+//# sourceMappingURL=verification-hooks.js.map

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

@@ -0,0 +1,106 @@
+/**
+ * Clavix v4.8: Verification Manager
+ *
+ * Manages verification state, execution flow, and persistence.
+ * Coordinates between checklist parsing, hook execution, and result storage.
+ */
+import { VerificationReport, VerificationResult, VerificationSummary, ChecklistItem, ReportStatus, VerificationStatus, VerificationConfidence, VerificationMethod } from '../types/verification.js';
+/**
+ * Verification Manager
+ */
+export declare class VerificationManager {
+    private readonly promptManager;
+    private readonly checklistParser;
+    private readonly verificationHooks;
+    private readonly outputDir;
+    constructor(baseDir?: string);
+    /**
+     * Initialize verification for a prompt
+     */
+    initializeVerification(promptId: string): Promise<VerificationReport>;
+    /**
+     * Get verification report path for a prompt
+     */
+    getReportPath(promptId: string, source: 'fast' | 'deep'): string;
+    /**
+     * Load verification report
+     */
+    loadReport(promptId: string): Promise<VerificationReport | null>;
+    /**
+     * Save verification report
+     */
+    saveReport(report: VerificationReport): Promise<void>;
+    /**
+     * Mark a single item as verified
+     */
+    markItemVerified(promptId: string, itemId: string, status: VerificationStatus, options?: {
+        evidence?: string;
+        reason?: string;
+        confidence?: VerificationConfidence;
+        method?: VerificationMethod;
+    }): Promise<VerificationReport>;
+    /**
+     * Run automated verification for a prompt
+     */
+    runAutomatedVerification(promptId: string): Promise<VerificationReport>;
+    /**
+     * Match checklist item content to hook type
+     */
+    private matchItemToHook;
+    /**
+     * Truncate output for storage
+     */
+    private truncateOutput;
+    /**
+     * Calculate summary from results
+     */
+    calculateSummary(results: VerificationResult[]): VerificationSummary;
+    /**
+     * Calculate overall report status
+     */
+    private calculateReportStatus;
+    /**
+     * Get pending items from report
+     */
+    getPendingItems(report: VerificationReport): ChecklistItem[];
+    /**
+     * Get failed items from report
+     */
+    getFailedItems(report: VerificationReport): Array<{
+        item: ChecklistItem;
+        result: VerificationResult;
+    }>;
+    /**
+     * Check if verification is complete
+     */
+    isComplete(report: VerificationReport): boolean;
+    /**
+     * Check if verification requires attention (has failures)
+     */
+    requiresAttention(report: VerificationReport): boolean;
+    /**
+     * Delete verification report
+     */
+    deleteReport(promptId: string): Promise<boolean>;
+    /**
+     * Get all verification reports
+     */
+    listReports(): Promise<VerificationReport[]>;
+    /**
+     * Get verification status for a prompt
+     */
+    getVerificationStatus(promptId: string): Promise<{
+        hasReport: boolean;
+        status: ReportStatus | null;
+        summary: VerificationSummary | null;
+    }>;
+    /**
+     * Format verification report for display
+     */
+    formatReportForDisplay(report: VerificationReport): string;
+    /**
+     * Get status icon for display
+     */
+    private getStatusIcon;
+}
+//# sourceMappingURL=verification-manager.d.ts.map