clavix 4.12.0 → 5.0.1

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

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

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

@@ -1,107 +0,0 @@
-/**
- * Clavix v4.11: Verification Manager
- *
- * Manages verification state, execution flow, and persistence.
- * Coordinates between checklist parsing, hook execution, and result storage.
- * v4.11: Updated for unified storage (no fast/deep subdirs)
- */
-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>;
-    /**
-     * v4.11: Get verification report path (unified storage)
-     */
-    getReportPath(promptId: string): string;
-    /**
-     * v4.11: Load verification report
-     */
-    loadReport(promptId: string): Promise<VerificationReport | null>;
-    /**
-     * v4.11: 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;
-    /**
-     * v4.11: Delete verification report
-     */
-    deleteReport(promptId: string): Promise<boolean>;
-    /**
-     * v4.11: 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