clavix 4.12.0 → 5.0.0

package/dist/cli/commands/task-complete.js

@@ -1,269 +0,0 @@
-import { Command, Flags, Args } from '@oclif/core';
-import chalk from 'chalk';
-import { TaskManager } from '../../core/task-manager.js';
-import { ConfigManager } from '../../core/config-manager.js';
-import { GitManager } from '../../core/git-manager.js';
-import * as path from 'path';
-import fs from 'fs-extra';
-export default class TaskComplete extends Command {
-    static description = 'Mark a task as completed with validation and optional git commit';
-    static examples = [
-        '<%= config.bin %> <%= command.id %> phase-1-auth-1',
-        '<%= config.bin %> <%= command.id %> phase-2-api-3 --no-git',
-        '<%= config.bin %> <%= command.id %> setup-1 --force',
-    ];
-    static args = {
-        taskId: Args.string({
-            description: 'Task ID to mark as completed',
-            required: true,
-        }),
-    };
-    static flags = {
-        'no-git': Flags.boolean({
-            description: 'Skip git commit even if strategy is enabled',
-            default: false,
-        }),
-        force: Flags.boolean({
-            char: 'f',
-            description: 'Force completion even if already marked complete',
-            default: false,
-        }),
-        config: Flags.string({
-            char: 'c',
-            description: 'Path to config file (defaults to auto-discover)',
-        }),
-    };
-    async run() {
-        const { args, flags } = await this.parse(TaskComplete);
-        const taskId = args.taskId;
-        console.log(chalk.bold.cyan(`\nTask Completion: ${taskId}\n`));
-        try {
-            const taskManager = new TaskManager();
-            const configManager = new ConfigManager();
-            const gitManager = new GitManager();
-            // Find config file
-            const configPath = await this.findConfigFile(flags.config);
-            console.log(chalk.dim(`Config: ${configPath}\n`));
-            // Read config
-            const config = await configManager.read(configPath);
-            const tasksPath = config.tasksPath;
-            // Read tasks
-            const phases = await taskManager.readTasksFile(tasksPath);
-            // Validate task exists
-            const task = taskManager.validateTaskExists(phases, taskId);
-            if (!task) {
-                // Smart recovery: List available tasks
-                console.log(chalk.red(`✗ Task ID "${taskId}" not found\n`));
-                console.log(chalk.yellow('Available task IDs:\n'));
-                phases.forEach(phase => {
-                    console.log(chalk.bold(`  ${phase.name}:`));
-                    phase.tasks.forEach(t => {
-                        const status = t.completed ? chalk.green('[x]') : chalk.gray('[ ]');
-                        console.log(`    ${status} ${chalk.cyan(t.id)} - ${t.description}`);
-                    });
-                    console.log();
-                });
-                this.error('Task not found. Please use one of the task IDs listed above.');
-            }
-            // Check if already completed
-            if (task.completed && !flags.force) {
-                console.log(chalk.yellow(`⚠ Task "${taskId}" is already marked as completed\n`));
-                // Check if it's in config too
-                const isInConfig = await configManager.isTaskCompleted(configPath, taskId);
-                if (isInConfig) {
-                    console.log(chalk.dim('Task is tracked in config as completed.\n'));
-                }
-                console.log(chalk.gray('Use --force to re-mark this task as completed.\n'));
-                // Show next task
-                await this.showNextTask(taskManager, phases);
-                return;
-            }
-            // Mark task as completed with validation
-            console.log(chalk.dim('Marking task as completed...'));
-            const result = await taskManager.markTaskCompletedWithValidation(tasksPath, taskId);
-            if (!result.success) {
-                // Smart recovery: Show error and suggestions
-                console.log(chalk.red(`\n✗ Failed to mark task as completed\n`));
-                console.log(chalk.yellow(`Error: ${result.error}\n`));
-                if (result.warnings && result.warnings.length > 0) {
-                    console.log(chalk.yellow('Warnings:'));
-                    result.warnings.forEach(warning => console.log(chalk.yellow(`  • ${warning}`)));
-                    console.log();
-                }
-                // Provide recovery suggestions
-                console.log(chalk.bold('Recovery Options:\n'));
-                console.log(chalk.gray('  1. Check if tasks.md file is readable and writable'));
-                console.log(chalk.gray('  2. Verify task ID matches exactly (run "clavix implement" to see current task)'));
-                console.log(chalk.gray('  3. Try running with --force flag if task is already completed'));
-                console.log(chalk.gray('  4. Check tasks.md.backup file if one was created\n'));
-                this.error('Task completion failed');
-            }
-            // Display warnings if any
-            if (result.warnings && result.warnings.length > 0) {
-                console.log(chalk.yellow('\nWarnings:'));
-                result.warnings.forEach(warning => console.log(chalk.yellow(`  • ${warning}`)));
-                console.log();
-            }
-            // Success!
-            if (result.alreadyCompleted) {
-                console.log(chalk.green(`✓ Task was already completed (tracking updated)\n`));
-            }
-            else {
-                console.log(chalk.green(`✓ Task marked as completed\n`));
-            }
-            // Re-read tasks file to get updated state (CRITICAL: phases object is stale)
-            const updatedPhases = await taskManager.readTasksFile(tasksPath);
-            // Track completion in config
-            console.log(chalk.dim('Updating configuration...'));
-            await configManager.trackCompletion(configPath, taskId);
-            // Update stats
-            const updatedStats = taskManager.getTaskStats(updatedPhases);
-            await configManager.update(configPath, { stats: updatedStats });
-            console.log(chalk.green('✓ Configuration updated\n'));
-            // Show progress
-            console.log(chalk.bold('Progress:'));
-            console.log(chalk.cyan(`  Completed: ${updatedStats.completed}/${updatedStats.total} tasks (${updatedStats.percentage.toFixed(0)}%)`));
-            console.log(chalk.cyan(`  Remaining: ${updatedStats.remaining} tasks\n`));
-            // Create git commit if enabled
-            if (!flags['no-git'] && config.commitStrategy !== 'none') {
-                await this.handleGitCommit(gitManager, configManager, configPath, config.commitStrategy, task, updatedPhases);
-            }
-            // Show next task
-            await this.showNextTask(taskManager, updatedPhases);
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : 'An unexpected error occurred';
-            console.log(chalk.red(`\n✗ Error: ${errorMessage}\n`));
-            this.error(errorMessage);
-        }
-    }
-    /**
-     * Find config file (auto-discover or use provided path)
-     */
-    async findConfigFile(providedPath) {
-        if (providedPath) {
-            if (await fs.pathExists(providedPath)) {
-                return providedPath;
-            }
-            throw new Error(`Config file not found: ${providedPath}`);
-        }
-        // Auto-discover: Look for .clavix/outputs/*/.clavix-implement-config.json
-        const outputsDir = path.join(process.cwd(), '.clavix', 'outputs');
-        if (!(await fs.pathExists(outputsDir))) {
-            throw new Error('No .clavix/outputs directory found.\n\nHint: Run "clavix implement" first to initialize');
-        }
-        // Search for config files
-        const entries = await fs.readdir(outputsDir, { withFileTypes: true });
-        const configFiles = [];
-        for (const entry of entries) {
-            if (!entry.isDirectory() || entry.name === 'archive') {
-                continue;
-            }
-            const configPath = path.join(outputsDir, entry.name, '.clavix-implement-config.json');
-            if (await fs.pathExists(configPath)) {
-                configFiles.push(configPath);
-            }
-        }
-        if (configFiles.length === 0) {
-            throw new Error('No config files found.\n\nHint: Run "clavix implement" first to initialize');
-        }
-        // Use most recent config
-        const configsWithStats = await Promise.all(configFiles.map(async (filePath) => {
-            const stat = await fs.stat(filePath);
-            return { path: filePath, mtime: stat.mtime };
-        }));
-        configsWithStats.sort((a, b) => b.mtime.getTime() - a.mtime.getTime());
-        return configsWithStats[0].path;
-    }
-    /**
-     * Handle git commit based on strategy
-     */
-    async handleGitCommit(gitManager, configManager, configPath, strategy, completedTask, phases) {
-        console.log(chalk.dim(`Checking git commit strategy (${strategy})...`));
-        const config = await configManager.read(configPath);
-        const completedCount = config.completedTaskIds?.length ?? 0;
-        let shouldCommit = false;
-        let commitMessage = '';
-        switch (strategy) {
-            case 'per-task':
-                shouldCommit = true;
-                commitMessage = `clavix: ${completedTask.description}`;
-                break;
-            case 'per-5-tasks':
-                shouldCommit = completedCount % 5 === 0;
-                if (shouldCommit) {
-                    const last5 = config.completedTaskIds?.slice(-5) ?? [];
-                    const taskDescriptions = phases
-                        .flatMap(p => p.tasks)
-                        .filter((t) => last5.includes(t.id))
-                        .map((t) => t.description);
-                    commitMessage = `clavix: Completed ${last5.length} tasks\n\nCompleted tasks:\n${taskDescriptions.map(d => `- ${d}`).join('\n')}`;
-                }
-                break;
-            case 'per-phase': {
-                // Check if current phase is complete
-                const currentPhase = phases.find(p => p.name === completedTask.phase);
-                if (currentPhase) {
-                    const phaseComplete = currentPhase.tasks.every((t) => t.completed);
-                    shouldCommit = phaseComplete;
-                    if (shouldCommit) {
-                        commitMessage = `clavix: Completed ${currentPhase.name}\n\nCompleted tasks:\n${currentPhase.tasks.map((t) => `- ${t.description}`).join('\n')}`;
-                    }
-                }
-                break;
-            }
-            case 'none':
-            default:
-                shouldCommit = false;
-                break;
-        }
-        if (!shouldCommit) {
-            console.log(chalk.dim('No commit needed (strategy criteria not met)\n'));
-            return;
-        }
-        // Check git status
-        const gitStatus = await gitManager.validateGitSetup();
-        if (!gitStatus.isRepo) {
-            console.log(chalk.yellow('⚠ Not a git repository - skipping commit\n'));
-            return;
-        }
-        if (!gitStatus.hasChanges) {
-            console.log(chalk.dim('No git changes to commit\n'));
-            return;
-        }
-        // Create commit
-        console.log(chalk.dim('Creating git commit...'));
-        const fullMessage = `${commitMessage}\n\nGenerated by Clavix task-complete`;
-        const success = await gitManager.createCommit({
-            message: fullMessage,
-            description: completedTask.description,
-            projectName: path.basename(path.dirname(configPath)),
-        });
-        if (success) {
-            console.log(chalk.green('✓ Git commit created\n'));
-        }
-        else {
-            console.log(chalk.yellow('⚠ Git commit failed (non-critical)\n'));
-        }
-    }
-    /**
-     * Show next incomplete task
-     */
-    async showNextTask(taskManager, phases) {
-        const nextTask = taskManager.findFirstIncompleteTask(phases);
-        if (!nextTask) {
-            console.log(chalk.bold.green('🎉 All tasks completed!\n'));
-            console.log(chalk.gray('Great work! All implementation tasks are done.\n'));
-            console.log(chalk.dim('Hint: Run "clavix archive" to archive this project\n'));
-            return;
-        }
-        console.log(chalk.bold('Next Task:'));
-        console.log(chalk.bold.white(`  ID: ${chalk.cyan(nextTask.id)}`));
-        console.log(chalk.bold.white(`  ${nextTask.description}`));
-        if (nextTask.prdReference) {
-            console.log(chalk.dim(`  Reference: ${nextTask.prdReference}`));
-        }
-        console.log(chalk.dim(`  Phase: ${nextTask.phase}\n`));
-    }
-}
-//# sourceMappingURL=task-complete.js.map

package/dist/cli/commands/verify.d.ts

@@ -1,28 +0,0 @@
-import { Command } from '@oclif/core';
-export default class Verify extends Command {
-    static description: string;
-    static examples: string[];
-    static flags: {
-        latest: import("@oclif/core/interfaces").BooleanFlag<boolean>;
-        standard: import("@oclif/core/interfaces").BooleanFlag<boolean>;
-        comprehensive: import("@oclif/core/interfaces").BooleanFlag<boolean>;
-        id: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
-        status: import("@oclif/core/interfaces").BooleanFlag<boolean>;
-        'retry-failed': import("@oclif/core/interfaces").BooleanFlag<boolean>;
-        export: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
-        'run-hooks': import("@oclif/core/interfaces").BooleanFlag<boolean>;
-    };
-    private promptManager;
-    private verificationManager;
-    private checklistParser;
-    private basicChecklistGenerator;
-    private intentDetector;
-    run(): Promise<void>;
-    private selectPromptInteractively;
-    private showStatus;
-    private exportReport;
-    private runVerification;
-    private verifyItemInteractively;
-    private formatStatus;
-}
-//# sourceMappingURL=verify.d.ts.map

package/dist/cli/commands/verify.js

@@ -1,349 +0,0 @@
-import { Command, Flags } from '@oclif/core';
-import chalk from 'chalk';
-import inquirer from 'inquirer';
-import { PromptManager } from '../../core/prompt-manager.js';
-import { VerificationManager } from '../../core/verification-manager.js';
-import { ChecklistParser } from '../../core/checklist-parser.js';
-import { BasicChecklistGenerator } from '../../core/basic-checklist-generator.js';
-import { IntentDetector } from '../../core/intelligence/intent-detector.js';
-export default class Verify extends Command {
-    static description = 'Verify implementation against checklist from improve mode';
-    static examples = [
-        '<%= config.bin %> <%= command.id %> --latest',
-        '<%= config.bin %> <%= command.id %> --latest --comprehensive',
-        '<%= config.bin %> <%= command.id %> --id comp-20250117-143022-a3f2',
-        '<%= config.bin %> <%= command.id %> --status',
-        '<%= config.bin %> <%= command.id %> --retry-failed',
-    ];
-    static flags = {
-        latest: Flags.boolean({
-            description: 'Verify latest executed prompt',
-            default: false,
-        }),
-        standard: Flags.boolean({
-            char: 's',
-            description: 'Filter to standard depth prompts only (use with --latest)',
-            default: false,
-        }),
-        comprehensive: Flags.boolean({
-            char: 'c',
-            description: 'Filter to comprehensive depth prompts only (use with --latest)',
-            default: false,
-        }),
-        id: Flags.string({
-            description: 'Verify specific prompt by ID',
-        }),
-        status: Flags.boolean({
-            description: 'Show verification status only',
-            default: false,
-        }),
-        'retry-failed': Flags.boolean({
-            description: 'Re-run only failed items',
-            default: false,
-        }),
-        export: Flags.string({
-            description: 'Export report format',
-            options: ['markdown', 'json'],
-        }),
-        'run-hooks': Flags.boolean({
-            description: 'Run automated hooks during verification',
-            default: true,
-        }),
-    };
-    promptManager;
-    verificationManager;
-    checklistParser;
-    basicChecklistGenerator;
-    intentDetector;
-    async run() {
-        const { flags } = await this.parse(Verify);
-        this.promptManager = new PromptManager();
-        this.verificationManager = new VerificationManager();
-        this.checklistParser = new ChecklistParser();
-        this.basicChecklistGenerator = new BasicChecklistGenerator();
-        this.intentDetector = new IntentDetector();
-        try {
-            // Get all prompts
-            const allPrompts = await this.promptManager.listPrompts();
-            if (allPrompts.length === 0) {
-                console.log(chalk.yellow('\n⚠️  No prompts found\n'));
-                console.log(chalk.cyan('Generate an optimized prompt first:'));
-                console.log(chalk.cyan('  /clavix:improve "your requirement"'));
-                console.log();
-                return;
-            }
-            let selectedPrompt = null;
-            // Select prompt by ID
-            if (flags.id) {
-                selectedPrompt = allPrompts.find((p) => p.id === flags.id) || null;
-                if (!selectedPrompt) {
-                    console.log(chalk.red(`\n✗ Prompt not found: ${flags.id}\n`));
-                    console.log(chalk.cyan('Run clavix prompts list to see available prompts'));
-                    console.log();
-                    return;
-                }
-            }
-            // Auto-select latest with optional filtering
-            else if (flags.latest) {
-                let filtered = allPrompts;
-                // Filter by depth
-                if (flags.standard && !flags.comprehensive) {
-                    filtered = allPrompts.filter((p) => p.depthUsed === 'standard');
-                }
-                else if (flags.comprehensive && !flags.standard) {
-                    filtered = allPrompts.filter((p) => p.depthUsed === 'comprehensive');
-                }
-                // Filter to executed prompts preferably
-                const executedFiltered = filtered.filter((p) => p.executed);
-                if (executedFiltered.length > 0) {
-                    filtered = executedFiltered;
-                }
-                if (filtered.length === 0) {
-                    const depth = flags.standard ? 'standard' : flags.comprehensive ? 'comprehensive' : 'any';
-                    console.log(chalk.yellow(`\n⚠️  No ${depth} prompts found\n`));
-                    return;
-                }
-                selectedPrompt = filtered[0];
-            }
-            // Interactive selection
-            else {
-                selectedPrompt = await this.selectPromptInteractively(allPrompts);
-                if (!selectedPrompt)
-                    return;
-            }
-            // Handle status-only flag
-            if (flags.status) {
-                await this.showStatus(selectedPrompt);
-                return;
-            }
-            // Handle export flag
-            if (flags.export) {
-                await this.exportReport(selectedPrompt, flags.export);
-                return;
-            }
-            // Run verification
-            await this.runVerification(selectedPrompt, {
-                retryFailed: flags['retry-failed'],
-                runHooks: flags['run-hooks'],
-            });
-        }
-        catch (error) {
-            console.log(chalk.red(`\n✗ Error: ${error}\n`));
-        }
-    }
-    async selectPromptInteractively(prompts) {
-        console.log(chalk.bold.cyan('\n📋 Select Prompt to Verify\n'));
-        const choices = prompts.map((p) => {
-            const executed = p.executed ? chalk.green('✓') : chalk.gray('○');
-            const age = p.ageInDays === 0 ? 'today' : `${p.ageInDays}d ago`;
-            const ageColor = (p.ageInDays || 0) > 30 ? chalk.red : (p.ageInDays || 0) > 7 ? chalk.yellow : chalk.gray;
-            const depthLabel = p.depthUsed === 'comprehensive' ? 'comp' : 'std';
-            return {
-                name: `${executed} [${depthLabel}] ${p.originalPrompt.substring(0, 50)}... ${ageColor(`(${age})`)}`,
-                value: p.id,
-                short: p.id,
-            };
-        });
-        const { promptId } = await inquirer.prompt([
-            {
-                type: 'list',
-                name: 'promptId',
-                message: 'Select a prompt to verify:',
-                choices,
-                pageSize: 15,
-            },
-        ]);
-        return prompts.find((p) => p.id === promptId) || null;
-    }
-    async showStatus(prompt) {
-        console.log(chalk.bold.cyan(`\n🔍 Verification Status: ${prompt.id}\n`));
-        const status = await this.verificationManager.getVerificationStatus(prompt.id);
-        if (!status.hasReport) {
-            console.log(chalk.yellow('No verification report found.'));
-            console.log(chalk.cyan('\nRun: clavix verify --latest'));
-            console.log();
-            return;
-        }
-        console.log(chalk.gray(`Status: ${this.formatStatus(status.status)}`));
-        console.log();
-        if (status.summary) {
-            console.log(chalk.bold('Summary:'));
-            console.log(`  Total:    ${status.summary.total} items`);
-            console.log(`  Passed:   ${chalk.green(status.summary.passed)} (${status.summary.coveragePercent}%)`);
-            console.log(`  Failed:   ${chalk.red(status.summary.failed)}`);
-            console.log(`  Skipped:  ${chalk.gray(status.summary.skipped)}`);
-            console.log();
-        }
-    }
-    async exportReport(prompt, format) {
-        const report = await this.verificationManager.loadReport(prompt.id);
-        if (!report) {
-            console.log(chalk.yellow('No verification report found.'));
-            return;
-        }
-        if (format === 'json') {
-            console.log(JSON.stringify(report, null, 2));
-        }
-        else if (format === 'markdown') {
-            console.log(this.verificationManager.formatReportForDisplay(report));
-        }
-    }
-    async runVerification(prompt, options) {
-        console.log(chalk.bold.cyan(`\n🔍 Verifying: ${prompt.id}\n`));
-        console.log(chalk.gray(`Depth: ${prompt.depthUsed}`));
-        console.log(chalk.gray(`Created: ${new Date(prompt.timestamp).toLocaleDateString()}`));
-        console.log();
-        // Load prompt content
-        const promptData = await this.promptManager.loadPrompt(prompt.id);
-        if (!promptData) {
-            console.log(chalk.red('Could not load prompt content.'));
-            return;
-        }
-        // Parse checklist from prompt
-        let checklist = this.checklistParser.parse(promptData.content);
-        // Handle standard depth - generate basic checklist if none exists
-        if (!checklist.hasChecklist && prompt.depthUsed === 'standard') {
-            console.log(chalk.yellow('⚠️  No checklist found (standard depth prompt)'));
-            console.log(chalk.cyan('Generating basic checklist based on intent...\n'));
-            // Detect intent from original prompt
-            const intent = this.intentDetector.analyze(prompt.originalPrompt);
-            checklist = this.basicChecklistGenerator.generateFromPrompt(prompt.originalPrompt, intent.primaryIntent);
-            console.log(chalk.gray(`Intent: ${intent.primaryIntent} (${intent.confidence}% confidence)`));
-            console.log(chalk.gray(`Generated ${checklist.totalItems} checklist items\n`));
-            console.log(chalk.yellow('💡 For comprehensive checklists, use /clavix:improve --comprehensive\n'));
-        }
-        if (!checklist.hasChecklist) {
-            console.log(chalk.yellow('No checklist items to verify.'));
-            return;
-        }
-        // Initialize or load existing report
-        let report = await this.verificationManager.loadReport(prompt.id);
-        if (!report) {
-            report = await this.verificationManager.initializeVerification(prompt.id);
-            // Update with parsed checklist if from standard depth
-            if (prompt.depthUsed === 'standard') {
-                report.items = [...checklist.validationItems, ...checklist.edgeCases, ...checklist.risks];
-                report.results = report.items.map((item) => ({
-                    itemId: item.id,
-                    status: 'pending',
-                    method: item.verificationType === 'automated' ? 'automated' : 'manual',
-                    confidence: 'low',
-                    verifiedAt: '',
-                }));
-                await this.verificationManager.saveReport(report);
-            }
-        }
-        // Run automated hooks if requested
-        if (options.runHooks) {
-            console.log(chalk.cyan('Running automated verification hooks...\n'));
-            report = await this.verificationManager.runAutomatedVerification(prompt.id);
-            // Display hook results
-            const automatedResults = report.results.filter((r) => r.method === 'automated' && r.status !== 'pending');
-            for (const result of automatedResults) {
-                const item = report.items.find((i) => i.id === result.itemId);
-                if (item) {
-                    const icon = result.status === 'passed' ? chalk.green('✓') : chalk.red('✗');
-                    console.log(`${icon} [automated] ${item.content}`);
-                    if (result.evidence) {
-                        console.log(chalk.gray(`  Evidence: ${result.evidence.substring(0, 60)}...`));
-                    }
-                }
-            }
-            if (automatedResults.length > 0) {
-                console.log();
-            }
-        }
-        // Get pending items for manual verification
-        const pendingItems = this.verificationManager.getPendingItems(report);
-        if (pendingItems.length > 0) {
-            console.log(chalk.cyan(`Manual verification needed for ${pendingItems.length} items:\n`));
-            for (const item of pendingItems) {
-                report = await this.verifyItemInteractively(report, item);
-            }
-        }
-        // Show final report
-        console.log();
-        console.log(this.verificationManager.formatReportForDisplay(report));
-        // Mark prompt as verified if complete
-        if (this.verificationManager.isComplete(report)) {
-            console.log(chalk.green('\n✓ Verification complete!\n'));
-        }
-        else if (this.verificationManager.requiresAttention(report)) {
-            console.log(chalk.yellow('\n⚠️  Some items require attention.\n'));
-            console.log(chalk.cyan('Fix issues and re-run: clavix verify --retry-failed --id ' + prompt.id));
-            console.log();
-        }
-    }
-    async verifyItemInteractively(report, item) {
-        console.log(chalk.bold(`\n📋 ${item.content}`));
-        if (item.group) {
-            console.log(chalk.gray(`   Category: ${item.group}`));
-        }
-        console.log();
-        const { status } = await inquirer.prompt([
-            {
-                type: 'list',
-                name: 'status',
-                message: 'Verification status:',
-                choices: [
-                    { name: '✓ Passed - Item is verified', value: 'passed' },
-                    { name: '✗ Failed - Item is not covered', value: 'failed' },
-                    { name: '⏭️  Skip - Will verify later', value: 'skipped' },
-                    { name: '➖ N/A - Does not apply', value: 'not-applicable' },
-                ],
-            },
-        ]);
-        let evidence;
-        let reason;
-        if (status === 'passed') {
-            const { evidenceInput } = await inquirer.prompt([
-                {
-                    type: 'input',
-                    name: 'evidenceInput',
-                    message: 'Evidence (optional):',
-                },
-            ]);
-            evidence = evidenceInput || undefined;
-        }
-        else if (status === 'failed') {
-            const { reasonInput } = await inquirer.prompt([
-                {
-                    type: 'input',
-                    name: 'reasonInput',
-                    message: 'Why is it not covered?',
-                },
-            ]);
-            reason = reasonInput || 'Not specified';
-        }
-        else if (status === 'skipped') {
-            const { reasonInput } = await inquirer.prompt([
-                {
-                    type: 'input',
-                    name: 'reasonInput',
-                    message: 'Reason for skipping:',
-                },
-            ]);
-            reason = reasonInput || 'Will verify later';
-        }
-        return this.verificationManager.markItemVerified(report.promptId, item.id, status, {
-            evidence,
-            reason,
-            confidence: 'medium',
-            method: 'manual',
-        });
-    }
-    formatStatus(status) {
-        switch (status) {
-            case 'completed':
-                return chalk.green('Completed');
-            case 'in-progress':
-                return chalk.yellow('In Progress');
-            case 'requires-attention':
-                return chalk.red('Requires Attention');
-            case 'pending':
-            default:
-                return chalk.gray('Pending');
-        }
-    }
-}
-//# sourceMappingURL=verify.js.map