clavix 4.12.0 → 5.0.0

package/dist/core/verification-manager.js

@@ -1,415 +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 fs from 'fs-extra';
-import * as path from 'path';
-import { ChecklistParser } from './checklist-parser.js';
-import { VerificationHooks } from './verification-hooks.js';
-import { PromptManager } from './prompt-manager.js';
-/**
- * Verification Manager
- */
-export class VerificationManager {
-    promptManager;
-    checklistParser;
-    verificationHooks;
-    outputDir;
-    constructor(baseDir) {
-        this.outputDir = baseDir || path.join(process.cwd(), '.clavix', 'outputs', 'prompts');
-        this.promptManager = new PromptManager(this.outputDir);
-        this.checklistParser = new ChecklistParser();
-        this.verificationHooks = new VerificationHooks();
-    }
-    /**
-     * Initialize verification for a prompt
-     */
-    async initializeVerification(promptId) {
-        // Load prompt
-        const promptData = await this.promptManager.loadPrompt(promptId);
-        if (!promptData) {
-            throw new Error(`Prompt not found: ${promptId}`);
-        }
-        // Parse checklist from prompt content
-        const checklist = this.checklistParser.parse(promptData.content);
-        // Get all items
-        const items = [...checklist.validationItems, ...checklist.edgeCases, ...checklist.risks];
-        // Detect available hooks
-        const detectedHooks = await this.verificationHooks.detectHooks();
-        // v4.11: Create initial report with depthUsed
-        const report = {
-            version: '2.0',
-            promptId,
-            depthUsed: promptData.metadata.depthUsed,
-            startedAt: new Date().toISOString(),
-            status: items.length > 0 ? 'pending' : 'completed',
-            items,
-            results: items.map((item) => ({
-                itemId: item.id,
-                status: 'pending',
-                method: item.verificationType === 'automated' ? 'automated' : 'manual',
-                confidence: 'low',
-                verifiedAt: '',
-            })),
-            summary: this.calculateSummary([]),
-            detectedHooks,
-        };
-        // Save initial report
-        await this.saveReport(report);
-        return report;
-    }
-    /**
-     * v4.11: Get verification report path (unified storage)
-     */
-    getReportPath(promptId) {
-        return path.join(this.outputDir, `${promptId}.verification.json`);
-    }
-    /**
-     * v4.11: Load verification report
-     */
-    async loadReport(promptId) {
-        const reportPath = this.getReportPath(promptId);
-        if (await fs.pathExists(reportPath)) {
-            try {
-                return await fs.readJson(reportPath);
-            }
-            catch {
-                // Corrupt file, ignore
-            }
-        }
-        return null;
-    }
-    /**
-     * v4.11: Save verification report
-     */
-    async saveReport(report) {
-        const reportPath = this.getReportPath(report.promptId);
-        await fs.ensureDir(path.dirname(reportPath));
-        await fs.writeJson(reportPath, report, { spaces: 2 });
-    }
-    /**
-     * Mark a single item as verified
-     */
-    async markItemVerified(promptId, itemId, status, options = {}) {
-        let report = await this.loadReport(promptId);
-        if (!report) {
-            // Initialize if doesn't exist
-            report = await this.initializeVerification(promptId);
-        }
-        // Find and update result
-        const resultIndex = report.results.findIndex((r) => r.itemId === itemId);
-        if (resultIndex === -1) {
-            throw new Error(`Item not found: ${itemId}`);
-        }
-        const item = report.items.find((i) => i.id === itemId);
-        report.results[resultIndex] = {
-            itemId,
-            status,
-            method: options.method || (item?.verificationType === 'automated' ? 'automated' : 'manual'),
-            confidence: options.confidence || 'medium',
-            evidence: options.evidence,
-            reason: options.reason,
-            verifiedAt: new Date().toISOString(),
-        };
-        // Recalculate summary and status
-        report.summary = this.calculateSummary(report.results);
-        report.status = this.calculateReportStatus(report.results);
-        if (report.status === 'completed') {
-            report.completedAt = new Date().toISOString();
-        }
-        await this.saveReport(report);
-        return report;
-    }
-    /**
-     * Run automated verification for a prompt
-     */
-    async runAutomatedVerification(promptId) {
-        let report = await this.loadReport(promptId);
-        if (!report) {
-            report = await this.initializeVerification(promptId);
-        }
-        // Find automated items that are pending
-        const automatedItems = report.items.filter((item) => item.verificationType === 'automated' &&
-            report.results.find((r) => r.itemId === item.id)?.status === 'pending');
-        if (automatedItems.length === 0) {
-            return report;
-        }
-        // Detect hooks
-        const detectedHooks = await this.verificationHooks.detectHooks();
-        // Run relevant hooks
-        const hookResults = await this.verificationHooks.runAllHooks();
-        // Map hook results to checklist items
-        for (const item of automatedItems) {
-            const lowerContent = item.content.toLowerCase();
-            // Match item to hook result
-            let matched = false;
-            for (const hookResult of hookResults) {
-                if (this.matchItemToHook(lowerContent, hookResult.hook.name)) {
-                    const resultIndex = report.results.findIndex((r) => r.itemId === item.id);
-                    if (resultIndex !== -1) {
-                        report.results[resultIndex] = {
-                            itemId: item.id,
-                            status: hookResult.success ? 'passed' : 'failed',
-                            method: 'automated',
-                            confidence: hookResult.confidence,
-                            evidence: this.truncateOutput(hookResult.output),
-                            reason: hookResult.success ? undefined : 'Hook failed',
-                            verifiedAt: new Date().toISOString(),
-                        };
-                        matched = true;
-                        break;
-                    }
-                }
-            }
-            // If no hook matched, mark as requiring manual verification
-            if (!matched) {
-                const resultIndex = report.results.findIndex((r) => r.itemId === item.id);
-                if (resultIndex !== -1 && report.results[resultIndex].status === 'pending') {
-                    report.results[resultIndex].method = 'manual';
-                }
-            }
-        }
-        // Update summary and status
-        report.summary = this.calculateSummary(report.results);
-        report.status = this.calculateReportStatus(report.results);
-        report.detectedHooks = detectedHooks;
-        await this.saveReport(report);
-        return report;
-    }
-    /**
-     * Match checklist item content to hook type
-     */
-    matchItemToHook(content, hookName) {
-        const hookKeywords = {
-            test: ['tests pass', 'test pass', 'all tests', 'unit test', 'test coverage'],
-            build: ['compiles', 'builds', 'build succeeds', 'no errors', 'runs without errors'],
-            lint: ['lint', 'no warnings', 'style guide', 'conventions'],
-            typecheck: ['typecheck', 'type check', 'type errors', 'typescript'],
-        };
-        const keywords = hookKeywords[hookName] || [];
-        return keywords.some((kw) => content.includes(kw));
-    }
-    /**
-     * Truncate output for storage
-     */
-    truncateOutput(output, maxLength = 500) {
-        if (output.length <= maxLength) {
-            return output;
-        }
-        return output.substring(0, maxLength) + '... (truncated)';
-    }
-    /**
-     * Calculate summary from results
-     */
-    calculateSummary(results) {
-        const total = results.length;
-        const passed = results.filter((r) => r.status === 'passed').length;
-        const failed = results.filter((r) => r.status === 'failed').length;
-        const skipped = results.filter((r) => r.status === 'skipped').length;
-        const notApplicable = results.filter((r) => r.status === 'not-applicable').length;
-        const automatedChecks = results.filter((r) => r.method === 'automated').length;
-        const manualChecks = results.filter((r) => r.method === 'manual' || r.method === 'semi-automated').length;
-        const denominator = total - skipped - notApplicable;
-        const coveragePercent = denominator > 0 ? Math.round((passed / denominator) * 100) : 0;
-        return {
-            total,
-            passed,
-            failed,
-            skipped,
-            notApplicable,
-            coveragePercent,
-            automatedChecks,
-            manualChecks,
-        };
-    }
-    /**
-     * Calculate overall report status
-     */
-    calculateReportStatus(results) {
-        const pending = results.filter((r) => r.status === 'pending').length;
-        const failed = results.filter((r) => r.status === 'failed').length;
-        if (pending === results.length) {
-            return 'pending';
-        }
-        if (pending > 0) {
-            return 'in-progress';
-        }
-        if (failed > 0) {
-            return 'requires-attention';
-        }
-        return 'completed';
-    }
-    /**
-     * Get pending items from report
-     */
-    getPendingItems(report) {
-        const pendingIds = new Set(report.results.filter((r) => r.status === 'pending').map((r) => r.itemId));
-        return report.items.filter((item) => pendingIds.has(item.id));
-    }
-    /**
-     * Get failed items from report
-     */
-    getFailedItems(report) {
-        return report.results
-            .filter((r) => r.status === 'failed')
-            .map((result) => ({
-            item: report.items.find((i) => i.id === result.itemId),
-            result,
-        }))
-            .filter((r) => r.item);
-    }
-    /**
-     * Check if verification is complete
-     */
-    isComplete(report) {
-        return report.status === 'completed';
-    }
-    /**
-     * Check if verification requires attention (has failures)
-     */
-    requiresAttention(report) {
-        return report.status === 'requires-attention';
-    }
-    /**
-     * v4.11: Delete verification report
-     */
-    async deleteReport(promptId) {
-        const reportPath = this.getReportPath(promptId);
-        if (await fs.pathExists(reportPath)) {
-            await fs.remove(reportPath);
-            return true;
-        }
-        return false;
-    }
-    /**
-     * v4.11: Get all verification reports
-     */
-    async listReports() {
-        const reports = [];
-        if (await fs.pathExists(this.outputDir)) {
-            const files = await fs.readdir(this.outputDir);
-            for (const file of files) {
-                if (file.endsWith('.verification.json')) {
-                    try {
-                        const report = await fs.readJson(path.join(this.outputDir, file));
-                        reports.push(report);
-                    }
-                    catch {
-                        // Ignore corrupt files
-                    }
-                }
-            }
-        }
-        return reports;
-    }
-    /**
-     * Get verification status for a prompt
-     */
-    async getVerificationStatus(promptId) {
-        const report = await this.loadReport(promptId);
-        if (!report) {
-            return {
-                hasReport: false,
-                status: null,
-                summary: null,
-            };
-        }
-        return {
-            hasReport: true,
-            status: report.status,
-            summary: report.summary,
-        };
-    }
-    /**
-     * Format verification report for display
-     */
-    formatReportForDisplay(report) {
-        const lines = [];
-        const sep = '═'.repeat(70);
-        lines.push(sep);
-        lines.push('                    VERIFICATION REPORT');
-        lines.push(`                    ${report.promptId}`);
-        lines.push(sep);
-        lines.push('');
-        // Group results by category
-        const byCategory = new Map();
-        for (const item of report.items) {
-            const result = report.results.find((r) => r.itemId === item.id);
-            if (!result)
-                continue;
-            const category = item.category;
-            if (!byCategory.has(category)) {
-                byCategory.set(category, []);
-            }
-            byCategory.get(category).push({ item, result });
-        }
-        // Display each category
-        for (const [category, items] of byCategory.entries()) {
-            const categoryName = category === 'validation'
-                ? 'VALIDATION CHECKLIST'
-                : category === 'edge-case'
-                    ? 'EDGE CASES'
-                    : 'RISKS';
-            lines.push(`📋 ${categoryName} (${items.length} items)`);
-            lines.push('');
-            for (const { item, result } of items) {
-                const statusIcon = this.getStatusIcon(result.status);
-                const method = result.method === 'automated'
-                    ? '[automated]'
-                    : result.method === 'semi-automated'
-                        ? '[semi-auto]'
-                        : '[manual]';
-                lines.push(`${statusIcon} ${method} ${item.content}`);
-                if (result.evidence) {
-                    lines.push(`   Evidence: ${result.evidence.substring(0, 80)}`);
-                }
-                if (result.status === 'failed' && result.reason) {
-                    lines.push(`   Reason: ${result.reason}`);
-                }
-                if (result.confidence) {
-                    lines.push(`   Confidence: ${result.confidence.toUpperCase()}`);
-                }
-                lines.push('');
-            }
-        }
-        // Summary
-        lines.push(sep);
-        lines.push('                         SUMMARY');
-        lines.push(sep);
-        lines.push(`Total:        ${report.summary.total} items`);
-        lines.push(`Passed:       ${report.summary.passed} (${report.summary.coveragePercent}%)`);
-        lines.push(`Failed:       ${report.summary.failed}${report.summary.failed > 0 ? ' (requires attention)' : ''}`);
-        lines.push(`Skipped:      ${report.summary.skipped}`);
-        lines.push('');
-        lines.push(`Automated:    ${report.summary.automatedChecks} checks`);
-        lines.push(`Manual:       ${report.summary.manualChecks} checks`);
-        if (report.summary.failed > 0) {
-            lines.push('');
-            lines.push(`⚠️  ${report.summary.failed} item(s) require attention before marking complete`);
-        }
-        lines.push(sep);
-        return lines.join('\n');
-    }
-    /**
-     * Get status icon for display
-     */
-    getStatusIcon(status) {
-        switch (status) {
-            case 'passed':
-                return '✅';
-            case 'failed':
-                return '❌';
-            case 'skipped':
-                return '⏭️';
-            case 'not-applicable':
-                return '➖';
-            case 'pending':
-            default:
-                return '⏳';
-        }
-    }
-}
-//# sourceMappingURL=verification-manager.js.map

package/dist/index 2.js

@@ -1,13 +0,0 @@
-#!/usr/bin/env node
-import { run, handle, settings } from '@oclif/core';
-// Disable debug mode (stack traces) unless explicitly requested via DEBUG env var
-if (!process.env.DEBUG) {
-    settings.debug = false;
-}
-// Run if called directly
-if (import.meta.url === `file://${process.argv[1]}`) {
-    run().catch(handle);
-}
-// Export for testing
-export { run };
-//# sourceMappingURL=index.js.map

package/dist/index.d 2.ts

@@ -1,4 +0,0 @@
-#!/usr/bin/env node
-import { run } from '@oclif/core';
-export { run };
-//# sourceMappingURL=index.d.ts.map

package/dist/types/session.d.ts

@@ -1,78 +0,0 @@
-/**
- * Session management types
- *
- * Sessions store conversational state for the `clavix start` command,
- * allowing users to have multi-turn conversations that can be summarized later.
- */
-/**
- * Complete session object with all data
- */
-export interface Session {
-    id: string;
-    projectName: string;
-    agent: string;
-    created: Date;
-    updated: Date;
-    status: SessionStatus;
-    messages: SessionMessage[];
-    tags?: string[];
-    description?: string;
-}
-/**
- * Session status tracking
- */
-export type SessionStatus = 'active' | 'completed' | 'archived';
-/**
- * Individual message in a conversation
- */
-export interface SessionMessage {
-    role: 'user' | 'assistant';
-    content: string;
-    timestamp: Date;
-}
-/**
- * Lightweight metadata for session listings
- */
-export interface SessionMetadata {
-    id: string;
-    projectName: string;
-    agent: string;
-    created: string;
-    updated: string;
-    status: SessionStatus;
-    messageCount: number;
-    tags?: string[];
-    description?: string;
-}
-/**
- * Filter options for session queries
- */
-export interface SessionFilter {
-    status?: SessionStatus;
-    projectName?: string;
-    agent?: string;
-    tags?: string[];
-    startDate?: Date;
-    endDate?: Date;
-}
-/**
- * Serialized session for file storage
- * Uses ISO strings instead of Date objects
- */
-export interface SerializedSession {
-    id: string;
-    projectName: string;
-    agent: string;
-    created: string;
-    updated: string;
-    status: SessionStatus;
-    messages: SerializedSessionMessage[];
-    tags?: string[];
-    description?: string;
-}
-export interface SerializedSessionMessage {
-    role: 'user' | 'assistant';
-    content: string;
-    timestamp: string;
-}
-//# sourceMappingURL=session.d.ts.map

package/dist/types/session.js

@@ -1,8 +0,0 @@
-/**
- * Session management types
- *
- * Sessions store conversational state for the `clavix start` command,
- * allowing users to have multi-turn conversations that can be summarized later.
- */
-export {};
-//# sourceMappingURL=session.js.map