@invariant-ai/cli 0.1.0

package/dist/commands/run.js

@@ -0,0 +1,839 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runCommand = runCommand;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const child_process_1 = require("child_process");
+const chalk_1 = __importDefault(require("chalk"));
+const ora_1 = __importDefault(require("ora"));
+const detect_js_1 = require("../lib/detect.js");
+const report_js_1 = require("../lib/report.js");
+const changes_js_1 = require("../lib/changes.js");
+const lint_js_1 = require("../lib/lint.js");
+const visual_diff_js_1 = require("../lib/visual-diff.js");
+const auto_sync_js_1 = require("../lib/auto-sync.js");
+// Default retention: 7 days
+const RETENTION_DAYS = 7;
+/**
+ * Clean up old test runs based on retention policy
+ * Deletes runs older than RETENTION_DAYS
+ */
+function cleanupOldRuns(testDir) {
+    const runsDir = (0, path_1.join)(testDir, '.invariant', 'runs');
+    if (!(0, fs_1.existsSync)(runsDir))
+        return 0;
+    const now = Date.now();
+    const maxAge = RETENTION_DAYS * 24 * 60 * 60 * 1000; // days to ms
+    let deletedCount = 0;
+    try {
+        const entries = (0, fs_1.readdirSync)(runsDir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (!entry.isDirectory())
+                continue;
+            const runPath = (0, path_1.join)(runsDir, entry.name);
+            try {
+                // Get directory creation time from the folder name (timestamp format: YYYY-MM-DDTHH-MM-SS)
+                // or fall back to file stats
+                let runTime;
+                // Try to parse timestamp from folder name (e.g., "2026-02-02T17-18-36")
+                const match = entry.name.match(/^(\d{4})-(\d{2})-(\d{2})T(\d{2})-(\d{2})-(\d{2})$/);
+                if (match) {
+                    const [, year, month, day, hour, min, sec] = match;
+                    runTime = new Date(`${year}-${month}-${day}T${hour}:${min}:${sec}`).getTime();
+                }
+                else {
+                    // Fall back to directory mtime
+                    const stats = (0, fs_1.statSync)(runPath);
+                    runTime = stats.mtime.getTime();
+                }
+                // Delete if older than retention period
+                if (now - runTime > maxAge) {
+                    (0, fs_1.rmSync)(runPath, { recursive: true, force: true });
+                    deletedCount++;
+                }
+            }
+            catch {
+                // Skip runs we can't process
+            }
+        }
+    }
+    catch {
+        // Ignore errors during cleanup
+    }
+    return deletedCount;
+}
+/**
+ * Count test files in a directory recursively
+ */
+function countTestFiles(dir) {
+    if (!(0, fs_1.existsSync)(dir))
+        return 0;
+    let count = 0;
+    try {
+        const entries = (0, fs_1.readdirSync)(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (entry.isDirectory()) {
+                count += countTestFiles((0, path_1.join)(dir, entry.name));
+            }
+            else if (entry.isFile() && entry.name.match(/\.(spec|test)\.(ts|js|mjs)$/)) {
+                count++;
+            }
+        }
+    }
+    catch {
+        // Ignore errors
+    }
+    return count;
+}
+/**
+ * Check if Playwright browsers are installed
+ */
+function checkBrowsersInstalled(testDir) {
+    try {
+        (0, child_process_1.execSync)('npx playwright --version', { cwd: testDir, stdio: 'pipe' });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Check if project uses TypeScript
+ */
+function projectUsesTypeScript(projectDir) {
+    return (0, fs_1.existsSync)((0, path_1.join)(projectDir, 'tsconfig.json'));
+}
+/**
+ * Run TypeScript type checking
+ */
+function runTypeCheck(projectDir) {
+    try {
+        (0, child_process_1.execSync)('npx tsc --noEmit', {
+            cwd: projectDir,
+            encoding: 'utf-8',
+            stdio: 'pipe',
+        });
+        return { passed: true, errorCount: 0, errors: [] };
+    }
+    catch (error) {
+        const output = error.stdout || error.stderr || '';
+        const errors = parseTypeScriptErrors(output);
+        return {
+            passed: false,
+            errorCount: errors.length,
+            errors
+        };
+    }
+}
+/**
+ * Parse TypeScript error output
+ */
+function parseTypeScriptErrors(output) {
+    const errors = [];
+    // Parse lines like:
+    // src/components/Button.tsx(15,3): error TS2322: Type 'string' is not assignable...
+    // or: src/components/Button.tsx:15:3 - error TS2322: Type 'string' is not assignable...
+    const lines = output.split('\n');
+    for (const line of lines) {
+        // Format 1: file(line,col): error TSxxxx: message
+        const match1 = line.match(/^(.+)\((\d+),(\d+)\): error (TS\d+): (.+)$/);
+        if (match1) {
+            errors.push({
+                file: match1[1],
+                line: parseInt(match1[2], 10),
+                column: parseInt(match1[3], 10),
+                code: match1[4],
+                message: match1[5],
+            });
+            continue;
+        }
+        // Format 2: file:line:col - error TSxxxx: message
+        const match2 = line.match(/^(.+):(\d+):(\d+) - error (TS\d+): (.+)$/);
+        if (match2) {
+            errors.push({
+                file: match2[1],
+                line: parseInt(match2[2], 10),
+                column: parseInt(match2[3], 10),
+                code: match2[4],
+                message: match2[5],
+            });
+        }
+    }
+    return errors;
+}
+/**
+ * Categorize type errors into new (blockers) vs existing (warnings)
+ * using diff-aware (changed-lines) gating.
+ *
+ * An error is a blocker only if:
+ * - The file is new/untracked, OR
+ * - The error line falls inside a git diff hunk, OR
+ * - The error has no line number (safe default)
+ *
+ * Errors on unchanged lines in edited files stay warnings.
+ * This prevents "touching a dirty file makes you own all debt."
+ */
+function categorizeTypeErrors(result, projectDir, changedFiles, changeSource, changedLineRanges) {
+    // If no changes detected, all errors are warnings (midway adoption)
+    if (changedFiles.length === 0) {
+        return {
+            passed: true, // Don't block if no changes detected
+            totalErrorCount: result.errorCount,
+            newErrorCount: 0,
+            existingErrorCount: result.errorCount,
+            newErrors: [],
+            existingErrors: result.errors,
+            noChangesDetected: true,
+            changeSource,
+        };
+    }
+    // Categorize each error using line-level (diff-aware) gating
+    const newErrors = [];
+    const existingErrors = [];
+    for (const error of result.errors) {
+        // First: is this file changed at all?
+        if (!(0, changes_js_1.isFileChanged)(error.file, changedFiles, projectDir)) {
+            existingErrors.push(error);
+            continue;
+        }
+        // File is changed — check if error is on a changed line
+        if ((0, changes_js_1.isLineInChangedRange)(error.file, error.line, changedLineRanges, projectDir)) {
+            newErrors.push(error);
+        }
+        else {
+            existingErrors.push(error);
+        }
+    }
+    return {
+        passed: newErrors.length === 0, // Pass if no NEW errors
+        totalErrorCount: result.errors.length,
+        newErrorCount: newErrors.length,
+        existingErrorCount: existingErrors.length,
+        newErrors,
+        existingErrors,
+        noChangesDetected: false,
+        changeSource,
+    };
+}
+async function runCommand(options) {
+    console.log(chalk_1.default.bold('\n🧪 Invariant - Running Tests\n'));
+    const cwd = process.cwd();
+    // Find playwright config (could be in current dir or frontend subdir)
+    const configInfo = (0, detect_js_1.findPlaywrightConfig)(cwd);
+    if (!configInfo.found) {
+        console.log(chalk_1.default.red('✗ No playwright.config.ts found\n'));
+        console.log(chalk_1.default.white('To fix this:'));
+        console.log(chalk_1.default.gray('  1. Run: ') + chalk_1.default.cyan('invariant init'));
+        console.log(chalk_1.default.gray('  2. Or create playwright.config.ts manually\n'));
+        process.exit(1);
+    }
+    const testDir = configInfo.dir;
+    // Clean up old runs (retention policy)
+    const deletedRuns = cleanupOldRuns(testDir);
+    if (deletedRuns > 0) {
+        console.log(chalk_1.default.gray(`♻ Cleaned up ${deletedRuns} old run${deletedRuns > 1 ? 's' : ''} (>${RETENTION_DAYS} days)`));
+    }
+    // Check for test files
+    const testsDir = (0, path_1.join)(testDir, 'tests', 'e2e');
+    const testFileCount = countTestFiles(testsDir);
+    if (testFileCount === 0) {
+        console.log(chalk_1.default.red('✗ No test files found\n'));
+        console.log(chalk_1.default.white('Expected test files in: ') + chalk_1.default.cyan('tests/e2e/*.spec.ts'));
+        console.log(chalk_1.default.gray('\nTo fix this:'));
+        console.log(chalk_1.default.gray('  1. Create a test file: ') + chalk_1.default.cyan('tests/e2e/example.spec.ts'));
+        console.log(chalk_1.default.gray('  2. Or run: ') + chalk_1.default.cyan('invariant init') + chalk_1.default.gray(' to generate a sample test\n'));
+        process.exit(1);
+    }
+    // Show pre-run checklist
+    console.log(chalk_1.default.green('✓') + chalk_1.default.gray(` Project: ${testDir}`));
+    console.log(chalk_1.default.green('✓') + chalk_1.default.gray(` Found ${testFileCount} test file${testFileCount > 1 ? 's' : ''}`));
+    // Check for .invariant directory
+    const invariantDir = (0, path_1.join)(testDir, '.invariant');
+    if ((0, fs_1.existsSync)(invariantDir)) {
+        console.log(chalk_1.default.green('✓') + chalk_1.default.gray(' Invariant configured'));
+    }
+    else {
+        console.log(chalk_1.default.yellow('!') + chalk_1.default.gray(' No .invariant directory (run `invariant init`)'));
+    }
+    // Compute changed files and line ranges once (shared by TypeCheck + Lint)
+    const { files: changedFiles, source: changeSource } = (0, changes_js_1.getChangedFiles)(testDir);
+    const changedLineRanges = (0, changes_js_1.getChangedLineRanges)(testDir);
+    // Run TypeScript type check if project uses TypeScript
+    let categorizedTypeCheck = null;
+    if (projectUsesTypeScript(testDir)) {
+        const typeSpinner = (0, ora_1.default)({
+            text: 'Running TypeScript type check...',
+            spinner: 'dots'
+        }).start();
+        const rawResult = runTypeCheck(testDir);
+        categorizedTypeCheck = categorizeTypeErrors(rawResult, testDir, changedFiles, changeSource, changedLineRanges);
+        if (categorizedTypeCheck.totalErrorCount === 0) {
+            typeSpinner.succeed('TypeScript: 0 errors');
+        }
+        else if (categorizedTypeCheck.noChangesDetected) {
+            typeSpinner.warn(`TypeScript: ${categorizedTypeCheck.existingErrorCount} existing error${categorizedTypeCheck.existingErrorCount > 1 ? 's' : ''} (no tracked edits)`);
+        }
+        else if (categorizedTypeCheck.newErrorCount === 0) {
+            typeSpinner.warn(`TypeScript: ${categorizedTypeCheck.existingErrorCount} existing error${categorizedTypeCheck.existingErrorCount > 1 ? 's' : ''} (warnings)`);
+        }
+        else if (categorizedTypeCheck.existingErrorCount === 0) {
+            typeSpinner.fail(`TypeScript: ${categorizedTypeCheck.newErrorCount} new error${categorizedTypeCheck.newErrorCount > 1 ? 's' : ''}`);
+        }
+        else {
+            typeSpinner.fail(`TypeScript: ${categorizedTypeCheck.newErrorCount} new, ${categorizedTypeCheck.existingErrorCount} existing`);
+        }
+    }
+    // Run lint check if linters are detected
+    let lintResult = null;
+    const detectedLinters = (0, lint_js_1.detectLinters)(testDir);
+    if (detectedLinters.eslint || detectedLinters.pylint) {
+        const lintSpinner = (0, ora_1.default)({
+            text: 'Running lint checks...',
+            spinner: 'dots'
+        }).start();
+        try {
+            lintResult = (0, lint_js_1.runLintCheck)(testDir, changedFiles, changedLineRanges);
+            if (lintResult.blockerCountTotal > 0) {
+                lintSpinner.fail(`Lint: ${lintResult.blockerCountTotal} blockers`);
+            }
+            else if (lintResult.warningCountTotal > 0) {
+                const existWarnCount = (lintResult.tools.eslint?.existingWarnings?.length || 0) + (lintResult.tools.pylint?.existingWarnings?.length || 0);
+                const existBlockCount = (lintResult.tools.eslint?.existingBlockers?.length || 0) + (lintResult.tools.pylint?.existingBlockers?.length || 0);
+                const parts = [];
+                if (lintResult.newWarningCountTotal > 0)
+                    parts.push(`${lintResult.newWarningCountTotal} new`);
+                if (existWarnCount > 0)
+                    parts.push(`${existWarnCount} existing warning${existWarnCount > 1 ? 's' : ''}`);
+                if (existBlockCount > 0)
+                    parts.push(`${existBlockCount} existing severity-2`);
+                lintSpinner.warn(`Lint: ${parts.join(', ')}`);
+            }
+            else {
+                const allSkipped = (lintResult.tools.eslint?.skipped ?? true) &&
+                    (lintResult.tools.pylint?.skipped ?? true);
+                if (allSkipped) {
+                    lintSpinner.info('Lint: Skipped (no targets)');
+                }
+                else {
+                    lintSpinner.succeed('Lint: No issues');
+                }
+            }
+            // Surface "did not run" warnings
+            if (lintResult.tools.eslint?.skipReason === 'error') {
+                console.log(chalk_1.default.yellow(`\n⚠ ESLint did not run: ${lintResult.tools.eslint.runError?.slice(0, 100)}`));
+                console.log(chalk_1.default.gray('  Proof may be weaker - ESLint errors not checked.\n'));
+            }
+            if (lintResult.tools.pylint?.skipReason === 'error') {
+                console.log(chalk_1.default.yellow(`\n⚠ Pylint did not run: ${lintResult.tools.pylint.runError?.slice(0, 100)}`));
+                console.log(chalk_1.default.gray('  Proof may be weaker - Pylint errors not checked.\n'));
+            }
+            // Surface setup warnings (e.g. TS files skipped because no parser)
+            if (lintResult.context.setupWarnings) {
+                for (const warning of lintResult.context.setupWarnings) {
+                    console.log(chalk_1.default.yellow(`\n⚠ ${warning}`));
+                }
+            }
+        }
+        catch (error) {
+            lintSpinner.warn(`Lint: Error - ${error.message?.slice(0, 100)}`);
+        }
+    }
+    console.log();
+    // Build playwright command
+    const args = ['playwright', 'test'];
+    if (options.headed) {
+        args.push('--headed');
+    }
+    // Always include JSON reporter for structured proof data alongside list for terminal output
+    args.push('--reporter=list,json');
+    if (options.quick) {
+        args.push('--max-failures=1');
+    }
+    // Create timestamp for this run
+    const timestamp = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19);
+    const runDir = (0, path_1.join)(testDir, '.invariant', 'runs', timestamp);
+    (0, fs_1.mkdirSync)(runDir, { recursive: true });
+    const spinner = (0, ora_1.default)({
+        text: 'Running Playwright tests...',
+        spinner: 'dots'
+    }).start();
+    const startTime = Date.now();
+    try {
+        // Run playwright tests
+        const result = (0, child_process_1.execSync)(`npx ${args.join(' ')}`, {
+            cwd: testDir,
+            encoding: 'utf-8',
+            stdio: ['pipe', 'pipe', 'pipe'],
+            env: {
+                ...process.env,
+                // Ensure artifacts go to the right place
+                PLAYWRIGHT_OUTPUT_DIR: (0, path_1.join)(testDir, 'test-results'),
+                // JSON reporter output for structured proof data
+                PLAYWRIGHT_JSON_OUTPUT_NAME: (0, path_1.join)(testDir, 'test-results', 'report.json'),
+                // Tell visual fixture where to save screenshots
+                INVARIANT_RUN_DIR: runDir,
+            }
+        });
+        const duration = ((Date.now() - startTime) / 1000).toFixed(1);
+        spinner.succeed(`Tests completed in ${duration}s`);
+        // Process visual regression (auto-capture screenshots compared to baselines)
+        const visualResult = (0, visual_diff_js_1.processVisualRegression)(testDir, runDir);
+        // Parse results and generate proof report
+        const report = await (0, report_js_1.generateProofReport)(testDir, runDir, {
+            passed: true,
+            duration: parseFloat(duration),
+            output: result,
+            typeCheck: categorizedTypeCheck ? {
+                enabled: true,
+                passed: categorizedTypeCheck.passed,
+                totalErrorCount: categorizedTypeCheck.totalErrorCount,
+                newErrorCount: categorizedTypeCheck.newErrorCount,
+                existingErrorCount: categorizedTypeCheck.existingErrorCount,
+                newErrors: categorizedTypeCheck.newErrors,
+                existingErrors: categorizedTypeCheck.existingErrors,
+                noChangesDetected: categorizedTypeCheck.noChangesDetected,
+            } : undefined,
+            lintCheck: lintResult ?? undefined,
+            visual: visualResult.enabled ? visualResult : undefined,
+        });
+        printProofReport(report, runDir, testDir);
+        // Auto-sync to cloud if logged in
+        await (0, auto_sync_js_1.autoSyncRun)(runDir, timestamp);
+    }
+    catch (error) {
+        const duration = ((Date.now() - startTime) / 1000).toFixed(1);
+        // Check for common error types
+        const errorOutput = error.stderr || error.message || '';
+        const stdout = error.stdout || '';
+        // Browser not installed
+        if (errorOutput.includes('Executable doesn\'t exist') || errorOutput.includes('browserType.launch')) {
+            spinner.fail('Playwright browser not installed');
+            console.log(chalk_1.default.yellow('\nBrowsers are required to run tests.\n'));
+            console.log(chalk_1.default.white('To fix this, run:'));
+            console.log(chalk_1.default.cyan(`  cd ${testDir} && npx playwright install chromium\n`));
+            process.exit(1);
+        }
+        // Timeout error - match Playwright-specific timeout patterns, not just any text with "Timeout"
+        const playwrightTimeoutPatterns = [
+            /Test timeout of \d+ms exceeded/i,
+            /Timeout \d+ms exceeded/i,
+            /waiting for locator.*Timeout/i,
+            /page\.waitFor.*Timeout/i,
+            /locator\..*Timeout \d+ms exceeded/i,
+            /exceeded timeout/i,
+        ];
+        const combinedOutput = errorOutput + stdout;
+        const isPlaywrightTimeout = playwrightTimeoutPatterns.some(pattern => pattern.test(combinedOutput));
+        if (isPlaywrightTimeout) {
+            spinner.fail(`Tests timed out after ${duration}s`);
+            console.log(chalk_1.default.yellow('\nTests took too long to complete.\n'));
+            console.log(chalk_1.default.white('Possible causes:'));
+            console.log(chalk_1.default.gray('  - Web server not running (start with npm run dev)'));
+            console.log(chalk_1.default.gray('  - Slow network or application'));
+            console.log(chalk_1.default.gray('  - Incorrect selectors in tests\n'));
+        }
+        else {
+            // Don't show fail message yet - we need to check if it's just warnings
+            spinner.stop();
+        }
+        // Process visual regression even on failure (captures may still exist)
+        const visualResult = (0, visual_diff_js_1.processVisualRegression)(testDir, runDir);
+        // Generate proof report for failures
+        const report = await (0, report_js_1.generateProofReport)(testDir, runDir, {
+            passed: false,
+            duration: parseFloat(duration),
+            output: stdout,
+            error: errorOutput,
+            typeCheck: categorizedTypeCheck ? {
+                enabled: true,
+                passed: categorizedTypeCheck.passed,
+                totalErrorCount: categorizedTypeCheck.totalErrorCount,
+                newErrorCount: categorizedTypeCheck.newErrorCount,
+                existingErrorCount: categorizedTypeCheck.existingErrorCount,
+                newErrors: categorizedTypeCheck.newErrors,
+                existingErrors: categorizedTypeCheck.existingErrors,
+                noChangesDetected: categorizedTypeCheck.noChangesDetected,
+            } : undefined,
+            lintCheck: lintResult ?? undefined,
+            visual: visualResult.enabled ? visualResult : undefined,
+        });
+        // Now show appropriate spinner message based on actual result
+        if (report.passed) {
+            // Only warnings (visual/a11y) - show warning message, not failure
+            spinner.warn(`Tests completed with warnings in ${duration}s`);
+        }
+        else {
+            // Real failures
+            spinner.fail(`Tests failed after ${duration}s`);
+        }
+        printProofReport(report, runDir, testDir);
+        // Check if proof actually passed (only warnings like visual/a11y, no real failures)
+        // If so, don't exit with error code - AI agents can continue
+        if (report.passed) {
+            // Auto-sync to cloud if logged in
+            await (0, auto_sync_js_1.autoSyncRun)(runDir, timestamp);
+            // Proof passed (only warnings) - exit cleanly
+            return;
+        }
+        // Real failures - still sync, then exit with error code
+        await (0, auto_sync_js_1.autoSyncRun)(runDir, timestamp);
+        process.exit(1);
+    }
+}
+// === Box formatting helpers ===
+const BOX_INNER_WIDTH = 43;
+// ESC[ ... m — matches ANSI color/style escape sequences
+const ESC = String.fromCharCode(27);
+const ANSI_RE = new RegExp(ESC + '\\[[0-9;]*m', 'g');
+function stripAnsi(str) {
+    return str.replace(ANSI_RE, '');
+}
+function truncateAnsi(str, maxVisible) {
+    const stripped = stripAnsi(str);
+    if (stripped.length <= maxVisible)
+        return str;
+    let visible = 0;
+    let i = 0;
+    while (i < str.length && visible < maxVisible - 1) {
+        if (str[i] === '\x1b') {
+            const end = str.indexOf('m', i);
+            if (end !== -1) {
+                i = end + 1;
+                continue;
+            }
+        }
+        visible++;
+        i++;
+    }
+    return str.slice(0, i) + '…';
+}
+function padLine(content, width = BOX_INNER_WIDTH) {
+    const truncated = truncateAnsi(content, width);
+    const visible = stripAnsi(truncated).length;
+    const padding = Math.max(0, width - visible);
+    // Reset ANSI before padding to prevent color bleed from truncation
+    return `│${truncated}\x1b[0m${' '.repeat(padding)}│`;
+}
+function divider(start = '├', width = BOX_INNER_WIDTH) {
+    const end = start === '┌' ? '┐' : start === '└' ? '┘' : '┤';
+    return `${start}${'─'.repeat(width)}${end}`;
+}
+function printProofReport(report, runDir, testDir) {
+    const relPath = (0, path_1.relative)(testDir, runDir);
+    console.log();
+    console.log(chalk_1.default.bold(divider('┌')));
+    const title = 'INVARIANT PROOF REPORT';
+    const leftPad = Math.floor((BOX_INNER_WIDTH - title.length) / 2);
+    const rightPad = BOX_INNER_WIDTH - leftPad - title.length;
+    console.log(chalk_1.default.bold(`│${' '.repeat(leftPad)}${title}${' '.repeat(rightPad)}│`));
+    console.log(chalk_1.default.bold(divider('├')));
+    // Check if we have warnings (visual, accessibility, existing type errors, or lint warnings)
+    const hasVisualV0Warnings = !!(report.visualRegression?.changes?.length);
+    const hasVisualV1Warnings = report.visual?.status === 'warn';
+    const hasVisualWarnings = hasVisualV0Warnings || hasVisualV1Warnings;
+    const hasAccessibilityWarnings = report.accessibility?.hasViolations || false;
+    const hasExistingTypeErrors = (report.typeCheck?.existingErrorCount || 0) > 0;
+    const hasLintBlockers = (report.lintCheck?.blockerCountTotal || 0) > 0;
+    const hasNewLintWarnings = (report.lintCheck?.newWarningCountTotal ?? report.lintCheck?.warningCountTotal ?? 0) > 0;
+    const hasAnyLintWarnings = (report.lintCheck?.warningCountTotal || 0) > 0;
+    const hasAnyWarnings = hasVisualWarnings || hasAccessibilityWarnings || hasExistingTypeErrors || hasNewLintWarnings;
+    let statusIcon, statusText;
+    if (report.passed && hasAnyWarnings) {
+        statusIcon = chalk_1.default.yellow('⚠');
+        statusText = chalk_1.default.yellow('PASSED (warnings)');
+    }
+    else if (report.passed) {
+        statusIcon = chalk_1.default.green('✓');
+        statusText = chalk_1.default.green('PASSED');
+    }
+    else {
+        statusIcon = chalk_1.default.red('✗');
+        statusText = chalk_1.default.red('FAILED');
+    }
+    console.log(padLine(`  Status:      ${statusIcon} ${statusText}`));
+    console.log(padLine(`  Tests:       ${chalk_1.default.white(report.summary.total)} total, ${chalk_1.default.green(report.summary.passed)} passed, ${chalk_1.default.red(report.summary.failed)} failed`));
+    console.log(padLine(`  Duration:    ${chalk_1.default.white(report.duration + 's')}`));
+    console.log(padLine(`  Screenshots: ${chalk_1.default.white(report.artifacts.screenshots)} captured`));
+    if (report.artifacts.videos > 0) {
+        console.log(padLine(`  Videos:      ${chalk_1.default.white(report.artifacts.videos)} captured`));
+    }
+    if (report.artifacts.traces > 0) {
+        console.log(padLine(`  Traces:      ${chalk_1.default.white(report.artifacts.traces)} captured`));
+    }
+    // Show type check results
+    if (report.typeCheck?.enabled) {
+        const newCount = report.typeCheck.newErrorCount || 0;
+        const existingCount = report.typeCheck.existingErrorCount || 0;
+        const totalCount = report.typeCheck.totalErrorCount || 0;
+        if (totalCount === 0) {
+            console.log(padLine(`  TypeCheck:   ${chalk_1.default.green('✓')} ${chalk_1.default.green('0 errors')}`));
+        }
+        else if (newCount === 0) {
+            console.log(padLine(`  TypeCheck:   ${chalk_1.default.yellow('⚠')} ${chalk_1.default.yellow(existingCount + ' existing')} (warnings)`));
+        }
+        else if (existingCount === 0) {
+            console.log(padLine(`  TypeCheck:   ${chalk_1.default.red('✗')} ${chalk_1.default.red(newCount + ' new error' + (newCount > 1 ? 's' : ''))}`));
+        }
+        else {
+            console.log(padLine(`  TypeCheck:   ${chalk_1.default.red('✗')} ${chalk_1.default.red(newCount + ' new')}, ${chalk_1.default.yellow(existingCount + ' existing')}`));
+        }
+    }
+    // Show lint check results
+    if (report.lintCheck?.enabled) {
+        const blockerCount = report.lintCheck.blockerCountTotal || 0;
+        const warningCount = report.lintCheck.warningCountTotal || 0;
+        if (blockerCount === 0 && warningCount === 0) {
+            const eslintSkipped = report.lintCheck.tools.eslint?.skipped ?? true;
+            const pylintSkipped = report.lintCheck.tools.pylint?.skipped ?? true;
+            if (eslintSkipped && pylintSkipped) {
+                console.log(padLine(`  LintCheck:   ${chalk_1.default.gray('ℹ')} ${chalk_1.default.gray('Skipped (no targets)')}`));
+            }
+            else {
+                console.log(padLine(`  LintCheck:   ${chalk_1.default.green('✓')} ${chalk_1.default.green('No issues')}`));
+            }
+        }
+        else if (blockerCount > 0) {
+            console.log(padLine(`  LintCheck:   ${chalk_1.default.red('✗')} ${chalk_1.default.red(blockerCount + ' blocker' + (blockerCount > 1 ? 's' : ''))}`));
+        }
+        else {
+            const newCount = report.lintCheck.newWarningCountTotal ?? report.lintCheck.warningCountTotal ?? 0;
+            const existWarnCount = (report.lintCheck.tools.eslint?.existingWarnings?.length || 0) + (report.lintCheck.tools.pylint?.existingWarnings?.length || 0);
+            const existBlockCount = (report.lintCheck.tools.eslint?.existingBlockers?.length || 0) + (report.lintCheck.tools.pylint?.existingBlockers?.length || 0);
+            const parts = [];
+            if (newCount > 0)
+                parts.push(chalk_1.default.yellow(newCount + ' new'));
+            if (existWarnCount > 0)
+                parts.push(chalk_1.default.gray(existWarnCount + ' existing'));
+            if (existBlockCount > 0)
+                parts.push(chalk_1.default.gray(existBlockCount + ' sev-2'));
+            const icon = newCount > 0 ? chalk_1.default.yellow('⚠') : chalk_1.default.gray('⚠');
+            console.log(padLine(`  LintCheck:   ${icon} ${parts.join(', ')}`));
+        }
+    }
+    // Show visual regression line (always shown)
+    if (report.visual) {
+        switch (report.visual.status) {
+            case 'pass':
+                console.log(padLine(`  Visual:      ${chalk_1.default.green('✓')} ${chalk_1.default.green('No diffs')}`));
+                break;
+            case 'warn': {
+                const { diffs, added, removed } = report.visual.comparison;
+                const parts = [];
+                if (diffs > 0)
+                    parts.push(`${diffs} changed`);
+                if (added > 0)
+                    parts.push(`${added} added`);
+                if (removed > 0)
+                    parts.push(`${removed} removed`);
+                const summary = parts.join(', ') || 'diffs detected';
+                console.log(padLine(`  Visual:      ${chalk_1.default.yellow('⚠')} ${chalk_1.default.yellow(summary)}`));
+                break;
+            }
+            case 'baseline_created':
+                console.log(padLine(`  Visual:      ${chalk_1.default.gray('○')} ${chalk_1.default.gray('Baseline created')}`));
+                break;
+            case 'error':
+                console.log(padLine(`  Visual:      ${chalk_1.default.yellow('⚠')} ${chalk_1.default.yellow('Did not run (error)')}`));
+                break;
+        }
+    }
+    else if (hasVisualV0Warnings) {
+        const changeCount = report.visualRegression.changes.length;
+        console.log(padLine(`  Visual:      ${chalk_1.default.yellow(changeCount)} changes (warnings)`));
+    }
+    else {
+        console.log(padLine(`  Visual:      ${chalk_1.default.gray('○')} ${chalk_1.default.gray('Not configured')}`));
+    }
+    // Show accessibility warnings count
+    if (hasAccessibilityWarnings) {
+        const violationCount = report.accessibility.violations.length;
+        console.log(padLine(`  A11y:        ${chalk_1.default.yellow(violationCount)} violations (warnings)`));
+    }
+    // Show edit history summary
+    if (report.editHistory && report.editHistory.totalEdits > 0) {
+        console.log(chalk_1.default.bold(divider('├')));
+        console.log(padLine(`  Session:     ${chalk_1.default.white(report.editHistory.sessionDate)}`));
+        console.log(padLine(`  Edits:       ${chalk_1.default.white(report.editHistory.totalEdits)} tracked`));
+    }
+    console.log(chalk_1.default.bold(divider('├')));
+    if (report.passed && hasAnyWarnings) {
+        const statusMsg = '       ⚠ PROOF COMPLETE (with warnings)';
+        console.log(chalk_1.default.bold.yellow(`│${statusMsg.padEnd(BOX_INNER_WIDTH)}│`));
+        console.log(chalk_1.default.bold(`│${' '.repeat(BOX_INNER_WIDTH)}│`));
+        const warningParts = [];
+        if (hasVisualWarnings)
+            warningParts.push('Visual');
+        if (hasAccessibilityWarnings)
+            warningParts.push('A11y');
+        if (hasExistingTypeErrors)
+            warningParts.push('Types');
+        if (hasNewLintWarnings)
+            warningParts.push('Lint');
+        const warningLabel = '  ' + warningParts.join(', ') + ' warnings';
+        console.log(chalk_1.default.bold(`│${warningLabel.padEnd(BOX_INNER_WIDTH)}│`));
+    }
+    else if (report.passed) {
+        const statusMsg = '         ✓ PROOF COMPLETE';
+        console.log(chalk_1.default.bold.green(`│${statusMsg.padEnd(BOX_INNER_WIDTH)}│`));
+    }
+    else {
+        const statusMsg = '         ✗ PROOF INCOMPLETE';
+        console.log(chalk_1.default.bold.red(`│${statusMsg.padEnd(BOX_INNER_WIDTH)}│`));
+        console.log(chalk_1.default.bold(`│${' '.repeat(BOX_INNER_WIDTH)}│`));
+        const hint = '  AI: Review failures and fix code';
+        console.log(chalk_1.default.bold(`│${hint.padEnd(BOX_INNER_WIDTH)}│`));
+    }
+    console.log(chalk_1.default.bold(divider('├')));
+    console.log(padLine(`  View: ${chalk_1.default.cyan('invariant dashboard')}`));
+    console.log(padLine(`  Path: ${chalk_1.default.gray(relPath)}`));
+    console.log(chalk_1.default.bold(divider('└')));
+    console.log();
+    // Show visual regression warnings (informational, doesn't block) — v0 only
+    if (hasVisualV0Warnings) {
+        console.log(chalk_1.default.bold.yellow('Visual Changes (warnings):\n'));
+        for (const change of report.visualRegression?.changes ?? []) {
+            console.log(chalk_1.default.yellow(`  ⚠ ${change.test}`));
+            console.log(chalk_1.default.gray(`    Screenshot: ${change.screenshot}`));
+            console.log();
+        }
+        console.log(chalk_1.default.gray('  Note: Visual changes are warnings only. Review in dashboard.\n'));
+    }
+    // Show accessibility warnings (informational, doesn't block)
+    if (hasAccessibilityWarnings && (report.accessibility?.violations?.length ?? 0) > 0) {
+        console.log(chalk_1.default.bold.yellow('Accessibility Violations (warnings):\n'));
+        for (const violation of report.accessibility.violations) {
+            const impactColor = violation.impact === 'critical' ? chalk_1.default.red :
+                violation.impact === 'serious' ? chalk_1.default.yellow :
+                    chalk_1.default.gray;
+            console.log(chalk_1.default.yellow(`  ⚠ ${violation.id}`));
+            console.log(chalk_1.default.gray(`    ${violation.description}`));
+            console.log(impactColor(`    Impact: ${violation.impact} (${violation.nodes} element${violation.nodes > 1 ? 's' : ''})`));
+            if (violation.helpUrl) {
+                console.log(chalk_1.default.cyan(`    Help: ${violation.helpUrl}`));
+            }
+            console.log();
+        }
+        console.log(chalk_1.default.gray('  Note: Accessibility issues are warnings only. Review in dashboard.\n'));
+    }
+    // Show NEW type errors (blockers - in changed files)
+    if (report.typeCheck?.enabled && (report.typeCheck.newErrorCount || 0) > 0) {
+        const newErrors = report.typeCheck.newErrors || [];
+        console.log(chalk_1.default.bold.red('TypeScript Errors (in changed files — must fix):\n'));
+        for (const error of newErrors.slice(0, 10)) {
+            console.log(chalk_1.default.red(`  ✗ ${error.code}: ${error.message}`));
+            console.log(chalk_1.default.gray(`    ${error.file}:${error.line}:${error.column}`));
+            console.log();
+        }
+        if (newErrors.length > 10) {
+            console.log(chalk_1.default.gray(`  ... and ${newErrors.length - 10} more new errors\n`));
+        }
+        console.log(chalk_1.default.red('  Fix these errors to complete the proof.\n'));
+    }
+    // Show EXISTING type errors (warnings - in unchanged files)
+    if (report.typeCheck?.enabled && (report.typeCheck.existingErrorCount || 0) > 0) {
+        const existingErrors = report.typeCheck.existingErrors || [];
+        console.log(chalk_1.default.bold.yellow('TypeScript Errors (existing — warnings):\n'));
+        console.log(chalk_1.default.yellow('  These errors are in files you did NOT change. They won\'t block the proof.'));
+        console.log(chalk_1.default.yellow('  Blocking rule: only errors in edited files prevent proof.\n'));
+        for (const error of existingErrors.slice(0, 5)) {
+            console.log(chalk_1.default.yellow(`  ⚠ ${error.code}: ${error.message}`));
+            console.log(chalk_1.default.gray(`    ${error.file}:${error.line}:${error.column}`));
+            console.log();
+        }
+        if (existingErrors.length > 5) {
+            console.log(chalk_1.default.gray(`  ... and ${existingErrors.length - 5} more existing errors\n`));
+        }
+    }
+    // Show lint blockers (in changed files - must fix)
+    if (report.lintCheck?.enabled && (report.lintCheck.blockerCountTotal || 0) > 0) {
+        const allBlockers = [
+            ...(report.lintCheck.tools.eslint?.blockers || []),
+            ...(report.lintCheck.tools.pylint?.blockers || []),
+        ];
+        console.log(chalk_1.default.bold.red('Lint Errors (blockers):\n'));
+        console.log(chalk_1.default.red('  These errors are in files you changed. They must be fixed.'));
+        console.log(chalk_1.default.red('  Classification: ESLint "problem" type / Pylint E/F category.'));
+        console.log(chalk_1.default.gray('  Note: Lint runs only on edited files.\n'));
+        for (const error of allBlockers.slice(0, 10)) {
+            const location = error.isFileLevelError
+                ? ' (file-level error)'
+                : `:${error.line}:${error.column}`;
+            console.log(chalk_1.default.red(`  ✗ [${error.tool}] ${error.ruleId}: ${error.message}`));
+            console.log(chalk_1.default.gray(`    ${error.file}${location}`));
+            console.log();
+        }
+        if (allBlockers.length > 10) {
+            console.log(chalk_1.default.gray(`  ... and ${allBlockers.length - 10} more blockers\n`));
+        }
+    }
+    // Show lint warnings — split into new, existing, and existing blockers
+    if (report.lintCheck?.enabled && (report.lintCheck.warningCountTotal || 0) > 0) {
+        // Collect warnings using new fields, falling back to old `warnings` for old reports
+        const allNewWarnings = [
+            ...(report.lintCheck.tools.eslint?.newWarnings ?? report.lintCheck.tools.eslint?.warnings ?? []),
+            ...(report.lintCheck.tools.pylint?.newWarnings ?? report.lintCheck.tools.pylint?.warnings ?? []),
+        ];
+        const allExistingWarnings = [
+            ...(report.lintCheck.tools.eslint?.existingWarnings ?? []),
+            ...(report.lintCheck.tools.pylint?.existingWarnings ?? []),
+        ];
+        const allExistingBlockers = [
+            ...(report.lintCheck.tools.eslint?.existingBlockers ?? []),
+            ...(report.lintCheck.tools.pylint?.existingBlockers ?? []),
+        ];
+        // New lint warnings (yellow)
+        if (allNewWarnings.length > 0) {
+            console.log(chalk_1.default.bold.yellow(`Lint Warnings — New (${allNewWarnings.length}):\n`));
+            for (const error of allNewWarnings.slice(0, 5)) {
+                const location = error.isFileLevelError ? ' (file-level)' : `:${error.line}:${error.column}`;
+                console.log(chalk_1.default.yellow(`  ⚠ [${error.tool}] ${error.ruleId}: ${error.message}`));
+                console.log(chalk_1.default.gray(`    ${error.file}${location}`));
+                console.log();
+            }
+            if (allNewWarnings.length > 5) {
+                console.log(chalk_1.default.gray(`  ... and ${allNewWarnings.length - 5} more new warnings\n`));
+            }
+        }
+        // Existing lint warnings (gray/dimmed)
+        if (allExistingWarnings.length > 0) {
+            console.log(chalk_1.default.gray(`Lint Warnings — Existing (${allExistingWarnings.length}):\n`));
+            console.log(chalk_1.default.gray('  These warnings are on lines you did not change.\n'));
+            for (const error of allExistingWarnings.slice(0, 5)) {
+                const location = error.isFileLevelError ? ' (file-level)' : `:${error.line}:${error.column}`;
+                console.log(chalk_1.default.gray(`  ⚠ [${error.tool}] ${error.ruleId}: ${error.message}`));
+                console.log(chalk_1.default.gray(`    ${error.file}${location}`));
+                console.log();
+            }
+            if (allExistingWarnings.length > 5) {
+                console.log(chalk_1.default.gray(`  ... and ${allExistingWarnings.length - 5} more existing warnings\n`));
+            }
+        }
+        // Existing blockers (yellow, with severity note)
+        if (allExistingBlockers.length > 0) {
+            console.log(chalk_1.default.yellow(`Lint Issues — Existing Severity-2 (${allExistingBlockers.length}):\n`));
+            console.log(chalk_1.default.yellow('  These are error-level rules on lines you did not change. They don\'t block the proof.\n'));
+            for (const error of allExistingBlockers.slice(0, 5)) {
+                const location = error.isFileLevelError ? ' (file-level)' : `:${error.line}:${error.column}`;
+                console.log(chalk_1.default.yellow(`  ⚠ [${error.tool}] ${error.ruleId}: ${error.message}`));
+                console.log(chalk_1.default.gray(`    ${error.file}${location}`));
+                console.log();
+            }
+            if (allExistingBlockers.length > 5) {
+                console.log(chalk_1.default.gray(`  ... and ${allExistingBlockers.length - 5} more existing severity-2 issues\n`));
+            }
+        }
+    }
+    // If failed, show failure details for AI to read
+    if (!report.passed && report.failures.length > 0) {
+        console.log(chalk_1.default.bold.red('Failures:\n'));
+        for (const failure of report.failures) {
+            console.log(chalk_1.default.red(`  ✗ ${failure.test}`));
+            console.log(chalk_1.default.gray(`    ${failure.error.slice(0, 200)}...`));
+            console.log();
+        }
+    }
+}
+//# sourceMappingURL=run.js.map