@empline/preflight 1.1.0

package/dist/runner.js

@@ -0,0 +1,728 @@
+"use strict";
+/**
+ * Preflight Runner
+ *
+ * Orchestrates the execution of preflight checks:
+ * 1. Loads app configuration (preflight.config.ts)
+ * 2. Discovers and loads core checks from this package
+ * 3. Discovers and loads app-specific checks from scripts/active/preflights/
+ * 4. Filters checks based on configuration
+ * 5. Executes checks with configured concurrency
+ * 6. Reports results
+ *
+ * Usage:
+ *   npx preflight                     # Run all checks
+ *   npx preflight security            # Run security category
+ *   npx preflight --quick             # Quick mode (critical only)
+ *   npx preflight --parallel          # Run in parallel
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runPreflights = runPreflights;
+exports.main = main;
+const path = __importStar(require("node:path"));
+const fs = __importStar(require("node:fs"));
+const node_child_process_1 = require("node:child_process");
+const glob_1 = require("glob");
+const types_1 = require("./core/types");
+const config_1 = require("./core/config");
+const categories_1 = require("./core/categories");
+const plugin_loader_1 = require("./utils/plugin-loader");
+const concurrency_config_1 = require("./shared/concurrency-config");
+const console_chars_1 = require("./utils/console-chars");
+const file_cache_1 = require("./shared/file-cache");
+const in_process_runner_1 = require("./shared/in-process-runner");
+const incremental_cache_1 = require("./shared/incremental-cache");
+/**
+ * Parse metadata from a compiled check file without executing it
+ * This avoids triggering immediate execution for files without require.main guards
+ */
+function parseCheckMetadata(filePath) {
+    try {
+        const content = fs.readFileSync(filePath, "utf-8");
+        // Parse exported metadata from CommonJS compiled output
+        // Patterns like: exports.id = "category/name";
+        const extractExport = (key) => {
+            const patterns = [
+                new RegExp(`exports\\.${key}\\s*=\\s*["']([^"']+)["']`),
+                new RegExp(`module\\.exports\\.${key}\\s*=\\s*["']([^"']+)["']`),
+            ];
+            for (const pattern of patterns) {
+                const match = content.match(pattern);
+                if (match)
+                    return match[1];
+            }
+            return undefined;
+        };
+        const extractBoolExport = (key) => {
+            const patterns = [
+                new RegExp(`exports\\.${key}\\s*=\\s*(true|false)`),
+                new RegExp(`module\\.exports\\.${key}\\s*=\\s*(true|false)`),
+            ];
+            for (const pattern of patterns) {
+                const match = content.match(pattern);
+                if (match)
+                    return match[1] === "true";
+            }
+            return undefined;
+        };
+        const extractArrayExport = (key) => {
+            // Match patterns like: exports.requires = ["tailwindcss", "next"];
+            const patterns = [
+                new RegExp(`exports\\.${key}\\s*=\\s*\\[([^\\]]*?)\\]`),
+                new RegExp(`module\\.exports\\.${key}\\s*=\\s*\\[([^\\]]*?)\\]`),
+            ];
+            for (const pattern of patterns) {
+                const match = content.match(pattern);
+                if (match) {
+                    const arrayContent = match[1].trim();
+                    if (!arrayContent)
+                        return [];
+                    // Extract strings from the array content
+                    const strings = arrayContent.match(/["']([^"']+)["']/g);
+                    if (strings) {
+                        return strings.map(s => s.replace(/["']/g, ""));
+                    }
+                    return [];
+                }
+            }
+            return undefined;
+        };
+        const id = extractExport("id");
+        const name = extractExport("name");
+        if (!id || !name)
+            return null;
+        return {
+            id,
+            name,
+            category: extractExport("category"),
+            blocking: extractBoolExport("blocking"),
+            description: extractExport("description"),
+            ciOnly: extractBoolExport("ciOnly"),
+            requires: extractArrayExport("requires"),
+        };
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Load installed dependencies from app's package.json
+ * Returns a Set of all dependency names (dependencies + devDependencies)
+ */
+function loadAppDependencies(appRoot) {
+    const deps = new Set();
+    try {
+        const pkgPath = path.join(appRoot, "package.json");
+        if (fs.existsSync(pkgPath)) {
+            const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+            // Add all dependencies
+            if (pkg.dependencies) {
+                Object.keys(pkg.dependencies).forEach(dep => deps.add(dep));
+            }
+            if (pkg.devDependencies) {
+                Object.keys(pkg.devDependencies).forEach(dep => deps.add(dep));
+            }
+            if (pkg.peerDependencies) {
+                Object.keys(pkg.peerDependencies).forEach(dep => deps.add(dep));
+            }
+        }
+    }
+    catch {
+        // Ignore errors loading package.json
+    }
+    return deps;
+}
+/**
+ * Check if all required packages are installed
+ */
+function meetsRequirements(requires, installedDeps) {
+    if (!requires || requires.length === 0) {
+        return true; // No requirements = universal check
+    }
+    return requires.every(pkg => installedDeps.has(pkg));
+}
+/**
+ * Core checks bundled with this package
+ */
+async function discoverCoreChecks(checksRoot) {
+    const checksDir = path.join(checksRoot, "checks");
+    // Only look for .js files - the package is compiled
+    const files = await (0, glob_1.glob)("**/*.js", {
+        cwd: checksDir,
+        ignore: ["**/*.test.js", "**/*.spec.js"],
+        nodir: true,
+    });
+    const plugins = [];
+    for (const file of files) {
+        const filePath = path.join(checksDir, file);
+        // Parse metadata from file content without executing it
+        const metadata = parseCheckMetadata(filePath);
+        if (metadata && metadata.id && metadata.name) {
+            plugins.push({
+                id: metadata.id,
+                name: metadata.name,
+                path: filePath,
+                blocking: metadata.blocking ?? false,
+                description: metadata.description || "",
+                category: metadata.category || path.dirname(file).split(path.sep)[0] || "general",
+                tags: metadata.tags,
+                ciOnly: metadata.ciOnly,
+                requires: metadata.requires,
+                run: undefined, // Will be run as subprocess
+                source: "core",
+                filePath,
+            });
+        }
+    }
+    return plugins;
+}
+/**
+ * Run a check as a subprocess
+ */
+async function runCheckAsSubprocess(filePath, timeout) {
+    return new Promise((resolve) => {
+        // For TypeScript files, use tsx; for JS files, use node
+        const isTS = filePath.endsWith(".ts");
+        // Use process.execPath for node to avoid shell issues
+        const nodePath = process.execPath;
+        let cmd;
+        let args;
+        if (isTS) {
+            // For TypeScript, try to run with tsx through npx
+            // On Windows, we need to handle this carefully
+            if (process.platform === "win32") {
+                cmd = "cmd.exe";
+                args = ["/c", "npx", "tsx", filePath];
+            }
+            else {
+                cmd = "npx";
+                args = ["tsx", filePath];
+            }
+        }
+        else {
+            cmd = nodePath;
+            args = [filePath];
+        }
+        const child = (0, node_child_process_1.spawn)(cmd, args, {
+            stdio: ["ignore", "pipe", "pipe"],
+            timeout,
+            cwd: process.cwd(),
+            env: process.env,
+        });
+        let output = "";
+        child.stdout?.on("data", (data) => {
+            output += data.toString();
+        });
+        child.stderr?.on("data", (data) => {
+            output += data.toString();
+        });
+        child.on("close", (code) => {
+            resolve({ exitCode: code ?? 0, output });
+        });
+        child.on("error", (err) => {
+            resolve({ exitCode: 1, output: err.message });
+        });
+    });
+}
+/**
+ * Run a single check and capture results
+ * Priority: 1) In-process execution, 2) Subprocess fallback
+ */
+async function runCheck(plugin, config, useIncremental = false) {
+    const startTime = Date.now();
+    // If the check has a run() function already loaded, use it
+    if (plugin.run) {
+        try {
+            const result = await Promise.race([
+                plugin.run(),
+                new Promise((_, reject) => setTimeout(() => reject(new Error("Timeout")), config.defaultTimeout)),
+            ]);
+            const durationSec = (Date.now() - startTime) / 1000;
+            // Store in incremental cache
+            if (useIncremental) {
+                incremental_cache_1.incrementalCache.store(plugin.id, plugin.filePath, [], result.passed, Date.now() - startTime);
+            }
+            return {
+                name: plugin.name,
+                group: plugin.blocking ? "blocking" : "non-blocking",
+                blocking: plugin.blocking,
+                pathOrCmd: plugin.filePath,
+                kind: result.passed ? "passed" : "failed",
+                durationSec,
+                findings: result.findings,
+            };
+        }
+        catch (error) {
+            const durationSec = (Date.now() - startTime) / 1000;
+            const isTimeout = error instanceof Error && error.message === "Timeout";
+            // Store failure in cache (so we re-run it next time)
+            if (useIncremental) {
+                incremental_cache_1.incrementalCache.store(plugin.id, plugin.filePath, [], false, // failed
+                Date.now() - startTime);
+            }
+            return {
+                name: plugin.name,
+                group: plugin.blocking ? "blocking" : "non-blocking",
+                blocking: plugin.blocking,
+                pathOrCmd: plugin.filePath,
+                kind: "failed",
+                durationSec,
+                timedOut: isTimeout,
+                outputSnippet: error instanceof Error ? error.message : String(error),
+            };
+        }
+    }
+    // Try in-process execution first (faster, no subprocess overhead)
+    if ((0, in_process_runner_1.canRunInProcess)(plugin.filePath)) {
+        try {
+            const result = await (0, in_process_runner_1.runCheckInProcess)(plugin.filePath, config.defaultTimeout);
+            if (result !== null) {
+                const durationSec = (Date.now() - startTime) / 1000;
+                // Store in incremental cache
+                if (useIncremental) {
+                    incremental_cache_1.incrementalCache.store(plugin.id, plugin.filePath, [], // Source files tracked separately if needed
+                    result.passed, Date.now() - startTime);
+                }
+                return {
+                    name: plugin.name,
+                    group: plugin.blocking ? "blocking" : "non-blocking",
+                    blocking: plugin.blocking,
+                    pathOrCmd: plugin.filePath,
+                    kind: result.passed ? "passed" : "failed",
+                    durationSec,
+                    findings: result.findings,
+                };
+            }
+        }
+        catch {
+            // In-process failed, fall through to subprocess
+        }
+    }
+    // Fall back to subprocess execution
+    try {
+        const { exitCode, output } = await runCheckAsSubprocess(plugin.filePath, config.defaultTimeout);
+        const durationSec = (Date.now() - startTime) / 1000;
+        const passed = exitCode === 0;
+        // Store in incremental cache
+        if (useIncremental) {
+            incremental_cache_1.incrementalCache.store(plugin.id, plugin.filePath, [], passed, Date.now() - startTime);
+        }
+        return {
+            name: plugin.name,
+            group: plugin.blocking ? "blocking" : "non-blocking",
+            blocking: plugin.blocking,
+            pathOrCmd: plugin.filePath,
+            kind: passed ? "passed" : "failed",
+            durationSec,
+            outputSnippet: exitCode !== 0 ? output.slice(-500) : undefined,
+        };
+    }
+    catch (error) {
+        const durationSec = (Date.now() - startTime) / 1000;
+        return {
+            name: plugin.name,
+            group: plugin.blocking ? "blocking" : "non-blocking",
+            blocking: plugin.blocking,
+            pathOrCmd: plugin.filePath,
+            kind: "failed",
+            durationSec,
+            outputSnippet: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
+/**
+ * Main runner function
+ */
+async function runPreflights(options = {}) {
+    const startTime = new Date();
+    const envInfo = (0, types_1.getEnvironmentInfo)();
+    const outputMode = options.outputMode || "human";
+    // Create logging wrapper that respects output mode
+    const log = outputMode === "human"
+        ? console.log.bind(console)
+        : () => { };
+    // Load app configuration
+    const appConfig = await (0, config_1.loadAppConfig)();
+    log(`\n${console_chars_1.emoji.rocket} Preflight Runner`);
+    log((0, console_chars_1.createDivider)(60, "heavy"));
+    log(`${console_chars_1.emoji.folder} App: ${appConfig.appName}`);
+    log(`${console_chars_1.emoji.gear} Config: ${appConfig.configPath || "default"}`);
+    // Determine categories to run
+    let categoriesToRun = options.categories || appConfig.categories;
+    if (options.quick) {
+        categoriesToRun = categories_1.QUICK_CATEGORIES;
+        log(`${console_chars_1.emoji.lightning} Quick mode: ${categories_1.QUICK_CATEGORIES.join(", ")}`);
+    }
+    // Get concurrency config (parallel by default, use --sequential to opt-out)
+    const concurrencyConfig = (0, concurrency_config_1.getConcurrencyConfig)();
+    if (options.sequential) {
+        concurrencyConfig.parallel = false;
+        concurrencyConfig.maxConcurrency = 1;
+    }
+    else if (options.parallel) {
+        // Explicit --parallel flag bumps concurrency to max
+        concurrencyConfig.parallel = true;
+        concurrencyConfig.maxConcurrency = Math.min(8, require("os").cpus().length);
+    }
+    if (outputMode === "human") {
+        (0, concurrency_config_1.logConcurrencyConfig)(concurrencyConfig, options.verbose);
+    }
+    // Load incremental cache if enabled
+    const useIncremental = options.incremental ?? false;
+    if (useIncremental) {
+        incremental_cache_1.incrementalCache.load();
+        if (options.verbose) {
+            const stats = incremental_cache_1.incrementalCache.getStats();
+            log(`${console_chars_1.emoji.lightning} Incremental mode: ${stats.validEntries} cached results`);
+        }
+    }
+    // Warm up the file cache to reduce redundant filesystem operations
+    // This pre-populates common file patterns used by multiple checks
+    if (options.verbose) {
+        log(`${console_chars_1.emoji.lightning} Warming up file cache...`);
+    }
+    await file_cache_1.fileCache.warmup();
+    // Discover checks
+    log(`\n${console_chars_1.emoji.search} Discovering checks...`);
+    // __dirname is the dist folder when running compiled, so checks are in __dirname/checks
+    const coreChecks = await discoverCoreChecks(__dirname);
+    const appChecks = await (0, plugin_loader_1.loadAppPlugins)(appConfig);
+    const allChecks = [...coreChecks, ...appChecks];
+    // Load app dependencies for requirements checking
+    const installedDeps = loadAppDependencies(appConfig.appRoot);
+    // Also add appName so checks can require specific apps (e.g., requires: ["trading-card-system"])
+    if (appConfig.appName) {
+        installedDeps.add(appConfig.appName);
+    }
+    const summary = (0, plugin_loader_1.getPluginSummary)(allChecks);
+    log(`${console_chars_1.emoji.package} Found ${summary.total} checks (${summary.bySource.core} core, ${summary.bySource.app} app-specific)`);
+    // Filter checks
+    const categoryFilter = (0, categories_1.buildFilterFromCategories)(categoriesToRun);
+    let skippedDueToRequirements = 0;
+    const checksToRun = allChecks.filter((check) => {
+        // Skip CI-only checks when not in CI
+        if (check.ciOnly && appConfig.respectCiOnly && !envInfo.isCIOrVercel) {
+            return false;
+        }
+        // Skip checks whose requirements aren't met
+        if (!meetsRequirements(check.requires, installedDeps)) {
+            skippedDueToRequirements++;
+            return false;
+        }
+        // Apply category filter
+        if (categoryFilter && !categoryFilter.test(check.name)) {
+            return false;
+        }
+        // Apply config-based filtering
+        return (0, config_1.shouldRunCheck)(check.id, check.category, appConfig);
+    });
+    log(`${console_chars_1.emoji.target} Running ${checksToRun.length} checks`);
+    if (skippedDueToRequirements > 0 && options.verbose) {
+        log(`${console_chars_1.emoji.skip} Skipped ${skippedDueToRequirements} checks (missing required packages)`);
+    }
+    log((0, console_chars_1.createDivider)(60));
+    // Pre-warm module cache for in-process execution (load modules ahead of time)
+    const jsChecks = checksToRun.filter(c => c.filePath.endsWith(".js")).map(c => c.filePath);
+    if (jsChecks.length > 0 && options.verbose) {
+        log(`${console_chars_1.emoji.lightning} Pre-warming ${jsChecks.length} check modules...`);
+    }
+    await (0, in_process_runner_1.prewarmModuleCache)(jsChecks);
+    // Run checks
+    const records = [];
+    let failedBlocking = false;
+    let skippedFromCache = 0;
+    if (concurrencyConfig.parallel) {
+        // Parallel execution in batches
+        for (let i = 0; i < checksToRun.length; i += concurrencyConfig.maxConcurrency) {
+            const batch = checksToRun.slice(i, i + concurrencyConfig.maxConcurrency);
+            const batchResults = await Promise.all(batch.map(async (check) => {
+                // Check incremental cache
+                if (useIncremental && incremental_cache_1.incrementalCache.canSkip(check.id, check.filePath, [])) {
+                    skippedFromCache++;
+                    const record = {
+                        name: check.name,
+                        group: check.blocking ? "blocking" : "non-blocking",
+                        blocking: check.blocking,
+                        pathOrCmd: check.filePath,
+                        kind: "passed",
+                        durationSec: 0.001,
+                    };
+                    if (options.verbose && outputMode === "human") {
+                        log(`${console_chars_1.emoji.skip} ${check.name} (cached)`);
+                    }
+                    return record;
+                }
+                const record = await runCheck(check, appConfig, useIncremental);
+                if (outputMode === "human") {
+                    printCheckResult(record, options.verbose);
+                }
+                return record;
+            }));
+            records.push(...batchResults);
+            if (batchResults.some((r) => r.blocking && r.kind === "failed")) {
+                failedBlocking = true;
+            }
+        }
+    }
+    else {
+        // Sequential execution
+        for (const check of checksToRun) {
+            // Check incremental cache
+            if (useIncremental && incremental_cache_1.incrementalCache.canSkip(check.id, check.filePath, [])) {
+                skippedFromCache++;
+                const record = {
+                    name: check.name,
+                    group: check.blocking ? "blocking" : "non-blocking",
+                    blocking: check.blocking,
+                    pathOrCmd: check.filePath,
+                    kind: "passed",
+                    durationSec: 0.001,
+                };
+                records.push(record);
+                if (options.verbose && outputMode === "human") {
+                    log(`${console_chars_1.emoji.skip} ${check.name} (cached)`);
+                }
+                continue;
+            }
+            const record = await runCheck(check, appConfig, useIncremental);
+            records.push(record);
+            if (outputMode === "human") {
+                printCheckResult(record, options.verbose);
+            }
+            if (record.blocking && record.kind === "failed") {
+                failedBlocking = true;
+                if (options.failFast) {
+                    log(`\n${console_chars_1.emoji.stop} Stopping early (fail-fast mode)`);
+                    break;
+                }
+            }
+        }
+    }
+    // Save incremental cache
+    if (useIncremental) {
+        const storedCount = incremental_cache_1.incrementalCache.getStoredCount();
+        incremental_cache_1.incrementalCache.save();
+        if (options.verbose && outputMode === "human") {
+            log(`${console_chars_1.emoji.lightning} Cache: ${storedCount} entries stored, ${skippedFromCache} skipped from cache`);
+        }
+        else if (skippedFromCache > 0 && outputMode === "human") {
+            log(`${console_chars_1.emoji.lightning} Skipped ${skippedFromCache} checks from cache`);
+        }
+    }
+    // Generate report
+    const endTime = new Date();
+    const report = {
+        createdAtIso: startTime.toISOString(),
+        endedAtIso: endTime.toISOString(),
+        durationSec: (endTime.getTime() - startTime.getTime()) / 1000,
+        records,
+        summary: {
+            total: records.length,
+            passed: records.filter((r) => r.kind === "passed").length,
+            failed: records.filter((r) => r.kind === "failed").length,
+            warnings: records.filter((r) => r.kind === "warning").length,
+            skipped: records.filter((r) => r.kind === "skipped").length,
+        },
+    };
+    // Output results based on mode
+    if (outputMode === "human") {
+        printSummary(report, failedBlocking);
+    }
+    else if (outputMode === "json") {
+        console.log(JSON.stringify(report, null, 2));
+        if (failedBlocking) {
+            process.exitCode = 1;
+        }
+    }
+    else if (outputMode === "ai") {
+        printAiOutput(report, failedBlocking);
+    }
+    return report;
+}
+/**
+ * Print result for a single check
+ */
+function printCheckResult(record, verbose) {
+    const icon = record.kind === "passed"
+        ? console_chars_1.emoji.success
+        : record.kind === "failed"
+            ? console_chars_1.emoji.error
+            : record.kind === "warning"
+                ? console_chars_1.emoji.warning
+                : console_chars_1.emoji.skip;
+    const duration = record.durationSec.toFixed(2);
+    const blockingTag = record.blocking ? " [BLOCKING]" : "";
+    console.log(`${icon} ${record.name} (${duration}s)${blockingTag}`);
+    if (verbose && record.findings && record.findings.length > 0) {
+        for (const finding of record.findings.slice(0, 5)) {
+            const location = finding.file
+                ? ` ${finding.file}${finding.startLine ? `:${finding.startLine}` : ""}`
+                : "";
+            console.log(`   ${finding.level === "error" ? console_chars_1.emoji.error : console_chars_1.emoji.warning} ${finding.message}${location}`);
+        }
+        if (record.findings.length > 5) {
+            console.log(`   ...and ${record.findings.length - 5} more`);
+        }
+    }
+}
+/**
+ * Print final summary
+ */
+function printSummary(report, failedBlocking) {
+    console.log(`\n${console_chars_1.emoji.chart} SUMMARY`);
+    console.log((0, console_chars_1.createDivider)(60, "heavy"));
+    console.log(`${console_chars_1.emoji.clock} Duration: ${report.durationSec.toFixed(2)}s`);
+    console.log(`${console_chars_1.emoji.success} Passed: ${report.summary.passed}`);
+    if (report.summary.failed > 0) {
+        console.log(`${console_chars_1.emoji.error} Failed: ${report.summary.failed}`);
+    }
+    if (report.summary.warnings > 0) {
+        console.log(`${console_chars_1.emoji.warning} Warnings: ${report.summary.warnings}`);
+    }
+    if (report.summary.skipped > 0) {
+        console.log(`${console_chars_1.emoji.skip} Skipped: ${report.summary.skipped}`);
+    }
+    console.log((0, console_chars_1.createDivider)(60));
+    if (failedBlocking) {
+        console.log(`\n${console_chars_1.emoji.stop} BLOCKING FAILURES DETECTED - Deployment blocked`);
+        process.exitCode = 1;
+    }
+    else if (report.summary.failed > 0) {
+        console.log(`\n${console_chars_1.emoji.warning} Non-blocking failures detected`);
+    }
+    else {
+        console.log(`\n${console_chars_1.emoji.party} All checks passed!`);
+    }
+}
+function printAiOutput(report, failedBlocking) {
+    const failures = report.records
+        .filter((r) => r.kind === "failed" || r.kind === "warning")
+        .map((r) => ({
+        check: r.name,
+        id: r.pathOrCmd.split("/").pop()?.replace(/\.(js|ts)$/, "") || r.name,
+        blocking: r.blocking,
+        findings: (r.findings || []).map((f) => ({
+            message: f.message,
+            ...(f.file && { file: f.file }),
+            ...(f.startLine && { line: f.startLine }),
+            ...(f.startColumn && { column: f.startColumn }),
+            ...(f.code && { code: f.code }),
+            ...(f.suggestion && { suggestion: f.suggestion }),
+            ...(f.ruleId && { ruleId: f.ruleId }),
+        })),
+    }));
+    const aiOutput = {
+        passed: !failedBlocking,
+        duration: report.durationSec,
+        summary: {
+            total: report.summary.total,
+            passed: report.summary.passed,
+            failed: report.summary.failed,
+            warnings: report.summary.warnings,
+        },
+        failures,
+        aiInstructions: `To fix these issues:
+1. Read each finding's file at the specified line number
+2. Apply the suggestion if provided, or fix based on the message
+3. Re-run: npx preflight --ai
+4. For specific category: npx preflight <category> --ai
+5. For verbose human output: npx preflight --verbose`,
+    };
+    console.log(JSON.stringify(aiOutput, null, 2));
+    if (failedBlocking) {
+        process.exitCode = 1;
+    }
+}
+/**
+ * CLI entry point
+ */
+async function main() {
+    const args = (0, concurrency_config_1.parsePreflightArgs)();
+    if (args.help) {
+        console.log(`
+Usage: preflight [categories...] [options]
+
+Categories:
+  security, typescript, runtime, database, ui, quality,
+  performance, testing, organization, business, hardened, framework
+
+Options:
+  --quick, -q       Run only critical checks (typescript, runtime, security, hardened)
+  --sequential, -s  Run checks sequentially (default: parallel)
+  --parallel, -p    Explicitly request parallel execution (already default)
+  --incremental, -i Skip unchanged checks (caches results by file hash)
+  --verbose, -v     Show detailed output
+  --fail-fast       Stop on first blocking failure
+  --json            Output full JSON report (for CI/programmatic use)
+  --ai              Output AI-friendly JSON (for AI assistants debugging failures)
+  --help, -h        Show this help
+
+Environment Variables:
+  PREFLIGHT_CONCURRENCY=N  Set max concurrent checks (default: half of CPUs)
+  PREFLIGHT_SEQUENTIAL=1   Force sequential execution
+
+AI Assistant Usage:
+  When helping users debug preflight failures, run with --ai flag:
+    npx preflight --ai
+    npx preflight security --ai
+
+  The output includes:
+  - Structured findings with file paths and line numbers
+  - Actionable suggestions for each issue
+  - Instructions for fixing and re-running checks
+`);
+        (0, categories_1.printCategoryHelp)();
+        return;
+    }
+    const categories = args.subset ? [args.subset] : [];
+    try {
+        await runPreflights({
+            categories,
+            quick: process.argv.includes("--quick") || process.argv.includes("-q"),
+            parallel: args.parallel,
+            sequential: args.sequential,
+            incremental: process.argv.includes("--incremental") || process.argv.includes("-i"),
+            verbose: args.verbose,
+            failFast: process.argv.includes("--fail-fast"),
+            outputMode: args.outputMode,
+        });
+    }
+    catch (error) {
+        console.error(`${console_chars_1.emoji.error} Fatal error:`, error);
+        process.exit(1);
+    }
+}
+//# sourceMappingURL=runner.js.map