@empline/preflight 1.0.20

package/dist/checks/coverage-gap-analysis.js

@@ -0,0 +1,779 @@
+#!/usr/bin/env tsx
+"use strict";
+/**
+ * Missing Test Coverage Preflight
+ *
+ * Scans the 'app' directory for pages and attempts to find corresponding
+ * E2E tests in the 'tests/e2e' directory.
+ *
+ * Algorithm:
+ * 1. Find all `page.tsx` files.
+ * 2. Generate "expected" test names based on the route path.
+ *    - app/store/shipping/page.tsx -> store-shipping.spec.ts, shipping.spec.ts
+ * 3. Search 'tests/e2e' for matching files.
+ * 4. Report pages with no likely test coverage.
+ */
+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.tags = exports.description = exports.blocking = exports.category = exports.name = exports.id = void 0;
+const child_process_1 = require("child_process");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const console_chars_1 = require("../utils/console-chars");
+const file_cache_1 = require("../shared/file-cache");
+const universal_progress_reporter_1 = require("./system/universal-progress-reporter");
+// Check metadata
+exports.id = "misc/coverage-gap-analysis";
+exports.name = "Coverage Gap Analysis";
+exports.category = "misc";
+exports.blocking = false;
+exports.description = "Missing Test Coverage Preflight";
+exports.tags = ["misc"];
+function getModeFromArgsOrEnv() {
+    const rawEnv = (process.env.PREFLIGHT_COVERAGE_GAP_MODE || "").toLowerCase();
+    const argv = process.argv.slice(2);
+    const modeArg = argv.find((a) => a.startsWith("--mode="));
+    const rawArg = modeArg ? modeArg.split("=")[1] : "";
+    const raw = (rawArg || rawEnv || "block").toLowerCase();
+    return raw === "warn" ? "warn" : "block";
+}
+function isCriticalRoute(route) {
+    // Fully automatic heuristic: treat auth/checkout/seller/admin/account as critical.
+    // This avoids requiring a human-maintained manifest while still ensuring key workflows
+    // aren’t “covered” only by smoke/quality/perf suites.
+    const r = normalizeRoute(route);
+    // Non-critical admin routes (low-usage utility pages)
+    const nonCriticalAdminRoutes = [
+        "/admin/images",
+        "/admin/newsletter",
+        "/admin/cleanup",
+        "/admin/logs",
+        "/admin/system-status",
+    ];
+    if (nonCriticalAdminRoutes.includes(r)) {
+        return false;
+    }
+    return (r === "/login" ||
+        r === "/register" ||
+        r === "/checkout" ||
+        r === "/cart" ||
+        r.startsWith("/account") ||
+        r.startsWith("/admin") ||
+        r.startsWith("/seller") ||
+        r.startsWith("/auth"));
+}
+const IGNORED_ROUTES = [
+    "app/page.tsx", // Landing page often tested generally
+    "app/layout.tsx",
+    "app/not-found.tsx",
+    "app/error.tsx",
+    "app/global-error.tsx",
+    "app/loading.tsx",
+    "app/api/**/*", // API routes handled separately
+    "app/sellers/page.tsx", // Legacy redirect to /store/dashboard
+];
+// CACHED FILE LISTS - Scan once, use everywhere
+let _cachedPageFiles = null;
+async function getPageFiles() {
+    if (!_cachedPageFiles) {
+        _cachedPageFiles = await file_cache_1.fileCache.getPageFiles();
+    }
+    return _cachedPageFiles;
+}
+let _cachedE2ESpecFiles = null;
+async function getE2ESpecFiles() {
+    if (!_cachedE2ESpecFiles) {
+        _cachedE2ESpecFiles = await file_cache_1.fileCache.getE2ESpecFiles();
+    }
+    return _cachedE2ESpecFiles;
+}
+async function main() {
+    const reporter = (0, universal_progress_reporter_1.createUniversalProgressReporter)(path.basename(__filename, ".ts"));
+    const mode = getModeFromArgsOrEnv();
+    console.log(`\n${console_chars_1.emoji.search}  MISSING REGRESSION TEST COVERAGE ANALYZER`);
+    console.log((0, console_chars_1.createDivider)(60, "heavy"));
+    console.log(`Mode: ${mode} (set PREFLIGHT_COVERAGE_GAP_MODE=warn to avoid blocking)`);
+    // 1. Find all Pages
+    const pages = await getPageFiles();
+    console.log(`Found ${pages.length} pages in the application.`);
+    // 2. Find all Tests
+    const tests = await getE2ESpecFiles();
+    // Build a cheap route-index from test contents so we can detect coverage
+    // even when filenames don't match (and for dynamic routes that require
+    // sample IDs/slugs).
+    const { routeCoverage, testSignals } = await indexRoutesReferencedInTests(tests);
+    const referencedRoutes = new Set(routeCoverage.keys());
+    // Normalize test filenames for easier matching
+    const testFiles = tests.map((t) => {
+        const name = path.basename(t, ".spec.ts");
+        return {
+            fullPath: t,
+            name: name,
+            normalizedName: name.replace(/-/g, "").toLowerCase(),
+        };
+    });
+    const missingCoverage = [];
+    const qualityGaps = [];
+    const dynamicPages = [];
+    const dynamicCovered = [];
+    const dynamicUncovered = [];
+    const errors = [];
+    const warnings = [];
+    const weakCoverage = [];
+    // 3. Match Pages to Tests
+    const generatedTestPath = "tests/e2e/generated/route-coverage.spec.ts";
+    let coveredRoutes = [];
+    if (fs.existsSync(generatedTestPath)) {
+        const content = fs.readFileSync(generatedTestPath, "utf-8");
+        // Extract routes from const ROUTES = [ ... ]
+        const match = content.match(/const ROUTES = \[\s*([\s\S]*?)\];/);
+        if (match) {
+            coveredRoutes = match[1]
+                .split(",")
+                .map((s) => s.trim().replace(/['"]/g, ""))
+                .filter((s) => s.length > 0);
+        }
+    }
+    for (const page of pages) {
+        // Normalize separators to forward slashes for consistency
+        const normalizedPagePath = page.split(path.sep).join("/");
+        // e.g., app/store/shipping/page.tsx
+        const dir = path.dirname(normalizedPagePath); // app/store/shipping
+        const routeParts = dir.split("/").slice(1); // ['store', 'shipping']
+        // Convert to route path for checking against generated tests
+        // app/store/shipping -> /store/shipping
+        // app/(marketing)/about -> /about
+        let routePath = "/" + routeParts.join("/");
+        routePath = routePath.replace(/\/\([^)]+\)/g, ""); // Remove (groups)
+        if (routePath === "/app")
+            routePath = "/"; // edge case if root page
+        const normalizedRoutePath = normalizeRoute(routePath);
+        const generatedCoversThisRoute = coveredRoutes.includes(routePath);
+        const isDynamicRoute = routePath.includes("[");
+        if (isDynamicRoute) {
+            dynamicPages.push(page);
+        }
+        // Strategy 1: Exact Match (store-shipping.spec.ts)
+        // For dynamic routes: app/product/[slug] -> product-slug
+        const cleanRouteParts = routeParts.map((p) => p.replace(/[\[\]]/g, ""));
+        const hypenatedName = cleanRouteParts.join("-");
+        const exactMatch = testFiles.find((t) => {
+            // Clean test name of common suffixes for matching
+            // e.g. saved-searches.account -> saved-searches
+            const cleanName = t.name.replace(/\.(account|seller|admin|e2e|smoke|visual)$/, "");
+            return cleanName === hypenatedName;
+        });
+        if (exactMatch) {
+            const res = await checkDeepCoverage(page, exactMatch.fullPath);
+            if (res.actionGap || res.fieldGap) {
+                qualityGaps.push(...res.details);
+            }
+            continue;
+        }
+        // Strategy 3: Normalized Fuzz (storeshipping.spec.ts)
+        const normalized = cleanRouteParts.join("").toLowerCase();
+        const fuzzyMatch = testFiles.find((t) => t.normalizedName === normalized);
+        if (fuzzyMatch) {
+            const res = await checkDeepCoverage(page, fuzzyMatch.fullPath);
+            if (res.actionGap || res.fieldGap) {
+                qualityGaps.push(...res.details);
+            }
+            continue;
+        }
+        // Check if covered by generated smoke tests
+        // Strategy 0: Direct route string coverage (content match)
+        // If tests literally navigate to this exact route, consider it covered.
+        if (!isDynamicRoute && referencedRoutes.has(normalizedRoutePath)) {
+            const testsCovering = Array.from(routeCoverage.get(normalizedRoutePath) ?? []);
+            const analysis = analyzeRouteCoverageStrength(testsCovering, testSignals);
+            if (analysis.isWeak) {
+                weakCoverage.push({
+                    route: normalizedRoutePath,
+                    tests: testsCovering,
+                    reason: analysis.reason,
+                });
+            }
+            continue;
+        }
+        // e.g. app/admin/users -> tests/e2e/admin/users.spec.ts
+        // This is partially covered by Exact Match if they use folders in tests,
+        // but often tests are flat files with hyphens.
+        // Fallback: generated smoke test covers this route, but it's weak by design.
+        if (generatedCoversThisRoute) {
+            weakCoverage.push({
+                route: normalizedRoutePath,
+                tests: [generatedTestPath],
+                reason: "generated-smoke-only",
+            });
+            continue;
+        }
+        missingCoverage.push({ page, route: routePath });
+    }
+    if (missingCoverage.length === 0) {
+        console.log(`${console_chars_1.emoji.success} Incredible! All pages appear to have associated E2E tests.`);
+    }
+    else {
+        console.log(`\n${console_chars_1.emoji.warning}  Potential Missing Coverage found for ${missingCoverage.length} pages:\n`);
+        // Group by top-level section
+        const grouped = {};
+        missingCoverage.forEach(({ page: p }) => {
+            const topLevel = p.split("/")[1] || "root";
+            if (!grouped[topLevel])
+                grouped[topLevel] = [];
+            grouped[topLevel].push(p);
+        });
+        for (const [section, files] of Object.entries(grouped)) {
+            console.log(`  📂 ${section.toUpperCase()} (${files.length})`);
+            files.slice(0, 5).forEach((f) => console.log(`     - ${f}`));
+            if (files.length > 5)
+                console.log(`     - ... and ${files.length - 5} more`);
+            console.log("");
+        }
+        console.log("${emoji.hint} Tip: Naming your spec files to match the route path (e.g., 'store-shipping.spec.ts' for 'app/store/shipping') helps automatic detection.");
+    }
+    // Dynamic route reporting (these are often the real gaps)
+    if (dynamicPages.length > 0) {
+        console.log((0, console_chars_1.createDivider)(60, "heavy"));
+        console.log("🧩 Dynamic Route Coverage (Routes with [param])");
+        const coveredCount = dynamicCovered.length;
+        const uncoveredCount = dynamicUncovered.length;
+        console.log(`Found ${dynamicPages.length} dynamic pages. Covered-by-example: ${coveredCount}. Missing example coverage: ${uncoveredCount}.`);
+        if (uncoveredCount > 0) {
+            console.log(`\n${console_chars_1.emoji.warning}  Dynamic pages need explicit example-route tests. Sample missing pages:`);
+            dynamicUncovered.slice(0, 15).forEach(({ page: p, route }) => {
+                console.log(`     - ${p}  (expect tests to hit an example for: ${route})`);
+            });
+            if (uncoveredCount > 15) {
+                console.log(`     - ... and ${uncoveredCount - 15} more`);
+            }
+        }
+        else {
+            console.log(`${console_chars_1.emoji.success} All dynamic pages appear to have at least one concrete example URL exercised in tests.`);
+        }
+    }
+    // 6. Email Template Coverage
+    const templateFile = "lib/seed-data/email-templates-v2.ts";
+    if (fs.existsSync(templateFile)) {
+        console.log((0, console_chars_1.createDivider)(60, "heavy"));
+        console.log("📧 Email System Coverage");
+        const tplContent = fs.readFileSync(templateFile, "utf-8");
+        const tplRegex = /templateType:\s*"([^"]+)"/g;
+        const templates = [];
+        let match;
+        while ((match = tplRegex.exec(tplContent)) !== null) {
+            templates.push(match[1]);
+        }
+        const uncoveredTemplates = [];
+        // We check if any test references the template string.
+        // This is a loose check: it ensures we at least expect it/mock it/trigger it.
+        for (const tpl of templates) {
+            let isCovered = false;
+            for (const t of tests) {
+                const content = fs.readFileSync(t, "utf-8"); // OS cache makes this cheap enough
+                // Relaxed check: just look for the template ID string (e.g. in comments)
+                if (content.includes(tpl)) {
+                    isCovered = true;
+                    break;
+                }
+            }
+            if (!isCovered)
+                uncoveredTemplates.push(tpl);
+        }
+        if (uncoveredTemplates.length > 0) {
+            console.log(`\n${console_chars_1.emoji.warning}  Missing E2E verification for ${uncoveredTemplates.length} email templates:`);
+            uncoveredTemplates.forEach((t) => console.log(`     - ${t}`));
+            errors.push(`Missing E2E coverage for ${uncoveredTemplates.length} email templates.`);
+        }
+        else {
+            console.log(`${console_chars_1.emoji.success} All ${templates.length} email templates are referenced in E2E tests.`);
+        }
+    }
+    // 7. API Route Coverage
+    console.log((0, console_chars_1.createDivider)(60, "heavy"));
+    console.log("🔌 API Route Coverage (app/api/**/route.ts)");
+    const { glob } = await Promise.resolve().then(() => __importStar(require("glob")));
+    const apiRouteFiles = await glob("app/api/**/route.ts", { cwd: process.cwd(), absolute: false });
+    const missingApiCoverage = [];
+    for (const apiFile of apiRouteFiles) {
+        // app/api/auth/register/route.ts -> /api/auth/register
+        const routePath = "/" +
+            path
+                .dirname(apiFile)
+                .split(path.sep)
+                .join("/")
+                .replace(/^app\//, "");
+        // Check if referenced in tests
+        // 1. Exact reference in route index
+        if (referencedRoutes.has(routePath)) {
+            continue;
+        }
+        // 2. Dynamic route match? /api/listings/[id]/route.ts
+        // We reuse logic from dynamic pages? Or is api stricter?
+        let isCovered = false;
+        if (routePath.includes("[")) {
+            isCovered = isDynamicRouteCoveredByExample(referencedRoutes, routePath);
+        }
+        if (!isCovered) {
+            missingApiCoverage.push(routePath);
+        }
+    }
+    if (missingApiCoverage.length > 0) {
+        console.log(`\n${console_chars_1.emoji.warning}  Missing E2E coverage for ${missingApiCoverage.length} API routes:`);
+        missingApiCoverage.slice(0, 15).forEach((r) => console.log(`     - ${r}`));
+        if (missingApiCoverage.length > 15) {
+            console.log(`     - ... and ${missingApiCoverage.length - 15} more`);
+        }
+        // We treat this as a warning for now, unless strict mode involves API?
+        // User requested "every action found", let's make it an error if feasible.
+        // For safety, let's start as warning to avoid blocking existing builds too hard immediately.
+        // But listing it in errors array triggers failure if mode=block.
+        if (mode === "block") {
+            // Optional: decide if API gaps block content.
+            // Given user instruction, let's consider it critical.
+            errors.push(`Missing E2E coverage for ${missingApiCoverage.length} API routes.`);
+        }
+        else {
+            warnings.push(`Missing E2E coverage for ${missingApiCoverage.length} API routes.`);
+        }
+    }
+    else {
+        console.log(`${console_chars_1.emoji.success} All ${apiRouteFiles.length} API routes appear to be referenced in tests.`);
+    }
+    // Weak coverage reporting (routes are referenced, but only by low-signal suites)
+    // This catches cases where a route is "covered" by a visual/seo/perf check but lacks
+    // a true regression spec with meaningful assertions.
+    const uniqueWeak = dedupeWeakCoverage(weakCoverage);
+    if (uniqueWeak.length > 0) {
+        console.log((0, console_chars_1.createDivider)(60, "heavy"));
+        console.log("🧯 Weak Coverage (Low-Signal Only)");
+        console.log(`Found ${uniqueWeak.length} routes that are only exercised by low-signal tests (suite type or shallow assertions).`);
+        uniqueWeak.slice(0, 20).forEach((item) => {
+            const shortTests = item.tests
+                .map((t) => t.split(path.sep).join("/"))
+                .map((t) => t.replace(/^.*?tests\/e2e\//, "tests/e2e/"))
+                .slice(0, 3)
+                .join(", ");
+            const reason = item.reason ? ` [${item.reason}]` : "";
+            console.log(`     - ${item.route}${reason}  (e.g. ${shortTests}${item.tests.length > 3 ? ", ..." : ""})`);
+        });
+        if (uniqueWeak.length > 20) {
+            console.log(`     - ... and ${uniqueWeak.length - 20} more`);
+        }
+        console.log("\nWEAK_ROUTE\tREASON\tEXAMPLE_TEST");
+        uniqueWeak.forEach((item) => {
+            const example = item.tests[0] ? item.tests[0].split(path.sep).join("/") : "";
+            console.log(`WEAK_ROUTE\t${item.route}\t${item.reason || ""}\t${example}`);
+        });
+    }
+    // Exit behavior (contract)
+    // - Missing page coverage should always fail in block mode.
+    // - Missing dynamic example coverage should always fail in block mode.
+    // - Weak coverage is tolerated for non-critical routes, but must not be the
+    //   only coverage signal for critical routes.
+    const criticalWeak = uniqueWeak.filter((w) => isCriticalRoute(w.route));
+    // errors array already declared at top scope
+    // warnings array already declared at top scope
+    if (missingCoverage.length > 0) {
+        errors.push(`Missing likely E2E coverage for ${missingCoverage.length} page(s).`);
+    }
+    if (dynamicUncovered.length > 0) {
+        errors.push(`Dynamic pages missing example-route coverage: ${dynamicUncovered.length}.`);
+    }
+    if (criticalWeak.length > 0) {
+        errors.push(`Critical routes with weak-only coverage: ${criticalWeak.length}.`);
+    }
+    else if (uniqueWeak.length > 0) {
+        warnings.push(`Weak-only coverage detected for ${uniqueWeak.length} route(s) (non-critical).`);
+    }
+    if (qualityGaps.length > 0) {
+        console.log((0, console_chars_1.createDivider)(60, "heavy"));
+        console.log(`${console_chars_1.emoji.warning}  Quality Gaps Detected (Deep Coverage)`);
+        qualityGaps.forEach((g) => console.log(`  ${g}`));
+        errors.push(`Found ${qualityGaps.length} quality gaps (unverified fields/actions).`);
+    }
+    if (warnings.length > 0) {
+        console.log((0, console_chars_1.createDivider)(60, "heavy"));
+        console.log(`${console_chars_1.emoji.warning}  Coverage Warnings`);
+        warnings.forEach((w) => console.log(`- ${w}`));
+    }
+    if (errors.length > 0) {
+        console.log((0, console_chars_1.createDivider)(60, "heavy"));
+        console.log(`${console_chars_1.emoji.error} Coverage Contract Failed (${errors.length})`);
+        errors.forEach((e) => console.log(`- ${e}`));
+        if (criticalWeak.length > 0) {
+            console.log("\nCritical weak routes (sample):");
+            criticalWeak.slice(0, 15).forEach((w) => {
+                console.log(`  - ${w.route} [${w.reason}]`);
+            });
+            if (criticalWeak.length > 15) {
+                console.log(`  - ... and ${criticalWeak.length - 15} more`);
+            }
+        }
+        if (mode === "block") {
+            process.exit(1);
+        }
+        console.log("\nMode=warn: not blocking build.");
+        process.exit(0);
+    }
+    console.log((0, console_chars_1.createDivider)(60, "heavy"));
+    console.log(`${console_chars_1.emoji.success} Coverage Contract Passed`);
+    process.exit(0);
+}
+function normalizeRoute(route) {
+    if (!route)
+        return route;
+    const withoutQuery = route.split("?")[0];
+    const trimmed = withoutQuery.trim();
+    if (!trimmed.startsWith("/"))
+        return trimmed;
+    // Remove trailing slash except root
+    if (trimmed.length > 1 && trimmed.endsWith("/")) {
+        return trimmed.slice(0, -1);
+    }
+    return trimmed;
+}
+function dynamicRouteToRegex(dynamicRoute) {
+    const normalized = normalizeRoute(dynamicRoute);
+    const segments = normalized.split("/").filter(Boolean);
+    const patternSegments = segments.map((seg) => {
+        if (seg.startsWith("[") && seg.endsWith("]")) {
+            // Catch-all: [...slug]
+            if (seg.startsWith("[...")) {
+                return ".+";
+            }
+            // Standard dynamic: [slug]
+            return "[^/]+";
+        }
+        // Escape regex specials in static segments
+        return seg.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    });
+    const pattern = `^/${patternSegments.join("/")}(?:/)?$`;
+    return new RegExp(pattern, "i");
+}
+function isDynamicRouteCoveredByExample(referencedRoutes, dynamicRoute) {
+    const routeRegex = dynamicRouteToRegex(dynamicRoute);
+    for (const route of referencedRoutes) {
+        if (routeRegex.test(route)) {
+            return true;
+        }
+    }
+    return false;
+}
+async function indexRoutesReferencedInTests(testPaths) {
+    const routes = new Map();
+    const testSignals = new Map();
+    for (const testPath of testPaths) {
+        if (!fs.existsSync(testPath))
+            continue;
+        const content = fs.readFileSync(testPath, "utf-8");
+        testSignals.set(testPath, analyzeTestSignal(content));
+        // Common patterns:
+        // - goto(page, "/path")
+        // - page.goto("/path")
+        // - request.get("/path") (less common, but still indicates a route)
+        const patterns = [
+            /\bgoto\s*\(\s*[^,]+,\s*(["'`])(\/[^"'`\s]*)\1/g,
+            /\bpage\.goto\s*\(\s*(["'`])(\/[^"'`\s]*)\1/g,
+            /\brequest\.(?:get|post|put|patch|delete)\s*\(\s*(["'`])(\/[^"'`\s]*)\1/g,
+            // Also count asserted navigations, which often happen after clicks.
+            /\btoHaveURL\s*\(\s*(["'`])(\/[^"'`\s]*)\1/g,
+            // Regex literals like: toHaveURL(/\/admin\/templates\/new/)
+            /\btoHaveURL\s*\(\s*\/(\\\/[^/]+(?:\\\/[^/]+)*)\/[gimsuy]*\s*\)/g,
+        ];
+        for (const re of patterns) {
+            let match;
+            while ((match = re.exec(content)) !== null) {
+                const raw = match[2] || match[1];
+                const routeCandidate = raw?.startsWith("\\/") ? raw.replace(/\\\//g, "/") : raw;
+                const route = normalizeRoute(routeCandidate);
+                if (!route || !route.startsWith("/"))
+                    continue;
+                // Ignore API endpoints; this preflight is about page routing.
+                // ENABLED for API Gap Analysis
+                // if (route.startsWith("/api/")) continue;
+                if (!routes.has(route)) {
+                    routes.set(route, new Set());
+                }
+                routes.get(route).add(testPath);
+            }
+        }
+        // Route arrays (common in route coverage specs):
+        // const ADMIN_ROUTES = ["/admin/dashboard", ...]
+        // const ROUTES = ["/about", ...]
+        const routesArrayMatch = content.match(/const\s+\w*ROUTES\w*\s*=\s*\[([\s\S]*?)\];/);
+        if (routesArrayMatch?.[1]) {
+            const arrayBody = routesArrayMatch[1];
+            const literalRouteRe = /(["'`])(\/[^"'`\s]*)\1/g;
+            let match;
+            while ((match = literalRouteRe.exec(arrayBody)) !== null) {
+                const route = normalizeRoute(match[2]);
+                if (!route || !route.startsWith("/"))
+                    continue;
+                // ENABLED for API Gap Analysis
+                // if (route.startsWith("/api/")) continue;
+                if (!routes.has(route)) {
+                    routes.set(route, new Set());
+                }
+                routes.get(route).add(testPath);
+            }
+        }
+        // Route list / object route extraction:
+        // Many route coverage specs store paths in arrays or objects and then
+        // call page.goto(variable). The patterns above won't see those.
+        // This intentionally errs on the side of inclusion for strings that look
+        // like page routes, while ignoring /api/*.
+        // ENABLED: Removed (?!api\/) to capture API routes with this regex as well
+        const routeLiteralRegex = /(["'`])(\/(?!_next\/)[^"'`\s]*)\1/g;
+        let lit;
+        while ((lit = routeLiteralRegex.exec(content)) !== null) {
+            const route = normalizeRoute(lit[2]);
+            if (!route || !route.startsWith("/"))
+                continue;
+            // We now want to include API routes for analysis
+            // if (route.startsWith("/api/")) continue;
+            if (!routes.has(route)) {
+                routes.set(route, new Set());
+            }
+            routes.get(route).add(testPath);
+        }
+    }
+    return { routeCoverage: routes, testSignals };
+}
+function isWeakCoverageOnlyBySuite(testPaths) {
+    if (testPaths.length === 0)
+        return false;
+    // Treat these as low-signal: they usually assert status/title or do broad checks.
+    const weakPrefixes = [
+        "tests/e2e/visual/",
+        "tests/e2e/quality/",
+        "tests/e2e/performance/",
+        "tests/e2e/smoke/",
+    ];
+    return testPaths.every((p) => {
+        const normalized = p.split(path.sep).join("/");
+        return weakPrefixes.some((prefix) => normalized.includes(prefix));
+    });
+}
+function analyzeRouteCoverageStrength(testPaths, testSignals) {
+    if (testPaths.length === 0)
+        return { isWeak: false, reason: "" };
+    const weakBySuite = isWeakCoverageOnlyBySuite(testPaths);
+    if (weakBySuite) {
+        return { isWeak: true, reason: "suite-only" };
+    }
+    // If all tests that hit this route have only shallow assertions,
+    // treat it as weak even if they live in a "regression" folder.
+    const weakByAssertions = testPaths.every((p) => {
+        const signal = testSignals.get(p);
+        return signal?.isLowSignalByAssertions ?? true;
+    });
+    if (weakByAssertions) {
+        return { isWeak: true, reason: "assertions-only" };
+    }
+    return { isWeak: false, reason: "" };
+}
+function dedupeWeakCoverage(items) {
+    const map = new Map();
+    for (const item of items) {
+        const key = normalizeRoute(item.route);
+        if (!map.has(key)) {
+            map.set(key, { tests: new Set(), reasons: new Set() });
+        }
+        for (const testPath of item.tests) {
+            map.get(key).tests.add(testPath);
+        }
+        if (item.reason) {
+            map.get(key).reasons.add(item.reason);
+        }
+    }
+    return Array.from(map.entries())
+        .map(([route, value]) => ({
+        route,
+        tests: Array.from(value.tests).sort(),
+        reason: Array.from(value.reasons).sort().join("|"),
+    }))
+        .sort((a, b) => a.route.localeCompare(b.route));
+}
+function analyzeTestSignal(content) {
+    // Very lightweight heuristic:
+    // - Reward interactions and role-based assertions (usually meaningful regression checks)
+    // - Penalize purely superficial assertions (title/url/body/status)
+    const interactions = (content.match(/\.(click|fill|type|press|check|uncheck|selectOption|setInputFiles)\s*\(/g) || []).length;
+    const roleAssertions = (content.match(/getByRole\s*\(/g) || []).length;
+    const textAssertions = (content.match(/to(Have|Contain)(Text|Title)\s*\(/g) || []).length;
+    const visibilityAssertions = (content.match(/to(BeVisible|BeHidden)\s*\(/g) || []).length;
+    const bodyOnlyVisibility = (content.match(/locator\(\s*["']body["']\s*\)\s*\)\.toBeVisible\s*\(/g) || []).length;
+    const urlOnly = (content.match(/toHaveURL\s*\(/g) || []).length;
+    const titleOnly = (content.match(/toHaveTitle\s*\(/g) || []).length;
+    const statusChecks = (content.match(/status\(\)\)\s*\.?toBeLessThan\s*\(|status\(\)\)\s*\.?toBe\s*\(/g) || []).length;
+    const meaningful = roleAssertions + visibilityAssertions + interactions;
+    const superficial = bodyOnlyVisibility + urlOnly + titleOnly + statusChecks;
+    const score = Math.max(0, meaningful * 2 + textAssertions - superficial);
+    // Threshold chosen to avoid false positives: a file that does one real interaction
+    // + one role assertion will usually clear this.
+    const isLowSignalByAssertions = score < 3;
+    return { score, isLowSignalByAssertions };
+}
+async function checkDeepCoverage(sourcePath, testPath) {
+    const result = { actionGap: false, fieldGap: false, details: [] };
+    if (!fs.existsSync(sourcePath) || !fs.existsSync(testPath)) {
+        return result;
+    }
+    const sourceContent = fs.readFileSync(sourcePath, "utf-8");
+    const testContent = fs.readFileSync(testPath, "utf-8");
+    // 1. FIELD COVERAGE
+    const labelRegex = /label="([^"]+)"/g;
+    const labels = [];
+    let match;
+    while ((match = labelRegex.exec(sourceContent)) !== null) {
+        labels.push(match[1]);
+    }
+    const uncheckedLabels = labels.filter((label) => !testContent.includes(label));
+    if (uncheckedLabels.length > 0) {
+        result.fieldGap = true;
+        result.details.push(`${console_chars_1.emoji.warning} Unverified Fields in ${path.basename(sourcePath)}: ${uncheckedLabels.map((l) => `"${l}"`).join(", ")}`);
+    }
+    // 2. ACTION COVERAGE
+    const potentialActions = {
+        buttons: (sourceContent.match(/<Button/g) || []).length,
+        iconButtons: (sourceContent.match(/<IconButton/g) || []).length,
+        clicks: (sourceContent.match(/onClick=/g) || []).length,
+        submits: (sourceContent.match(/onSubmit=/g) || []).length,
+    };
+    const totalActionables = potentialActions.buttons +
+        potentialActions.iconButtons +
+        potentialActions.clicks +
+        potentialActions.submits;
+    const testInteractions = (testContent.match(/\.(click|fill|type|press|check|uncheck|selectOption|setInputFiles)\s*\(/g) ||
+        []).length;
+    // DEBUG LOG
+    // console.log(`[DeepCheck] ${path.basename(sourcePath)} vs ${path.basename(testPath)}: Actions=${totalActionables}, Interactions=${testInteractions}`);
+    if (totalActionables > 0) {
+        // STRICTER CHECK: If there are actionables, we expect at least some interactions.
+        // If we have > 5 actionables, ensure we have at least 20% coverage.
+        const isZeroCoverage = testInteractions === 0;
+        const isLowCoverage = totalActionables > 5 && testInteractions < totalActionables * 0.2;
+        if (isZeroCoverage || isLowCoverage) {
+            result.actionGap = true;
+            const severity = isZeroCoverage ? "ZERO" : "LOW";
+            result.details.push(`${console_chars_1.emoji.warning} Action Gap (${severity}) in ${path.basename(testPath)}: Page has ${totalActionables} interactive elements, but test has only ${testInteractions} interactions.`);
+        }
+    }
+    return result;
+}
+/**
+ * Analyzes Playwright traces to identify "Hot" interaction zones.
+ */
+async function generateTraceHeatmap() {
+    const artifactsDir = path.join(process.cwd(), "test-results", "artifacts");
+    if (!fs.existsSync(artifactsDir)) {
+        console.log("No test artifacts found. Run tests with traces enabled to see heatmap.");
+        return;
+    }
+    // Find all trace.zip files
+    // Use glob to find them recursively
+    const { glob } = await Promise.resolve().then(() => __importStar(require("glob"))); // Use dynamic import if needed or reuse existing
+    const traces = await glob("**/*.zip", { cwd: artifactsDir, absolute: true });
+    if (traces.length === 0) {
+        console.log("No trace.zip files found in artifacts.");
+        return;
+    }
+    console.log(`Analyzing ${traces.length} traces...`);
+    const interactionCounts = {};
+    const tempDir = path.join(process.cwd(), "temp-trace-analysis");
+    try {
+        for (const tracePath of traces) {
+            // Clean/Create temp dir
+            if (fs.existsSync(tempDir))
+                fs.rmSync(tempDir, { recursive: true, force: true });
+            fs.mkdirSync(tempDir);
+            // Unzip (Windows PowerShell fallback)
+            try {
+                (0, child_process_1.execSync)(`powershell -command "Expand-Archive -Path '${tracePath}' -DestinationPath '${tempDir}' -Force"`, { stdio: "ignore" });
+            }
+            catch {
+                continue; // Skip if unzip fails
+            }
+            // Find trace.trace
+            const extractedFiles = await glob("**/*.trace", { cwd: tempDir, absolute: true });
+            for (const traceFile of extractedFiles) {
+                try {
+                    const content = fs.readFileSync(traceFile, "utf-8");
+                    const json = JSON.parse(content);
+                    // Look for actions in the trace model
+                    // Structure: { actions: [ ... ], events: [ ... ] }
+                    // Actions usually have: { metadata: { method: 'click', params: { selector: ... } } }
+                    // Or newer format?
+                    const events = json.events || [];
+                    // Simple heuristic: look for 'apiName' (e.g. 'click', 'fill') and 'params.selector'
+                    for (const event of events) {
+                        if (event.type === "action" && event.metadata) {
+                            const method = event.metadata.method;
+                            const selector = event.metadata.params?.selector;
+                            if (method && selector) {
+                                const key = `[${method}] ${selector}`;
+                                interactionCounts[key] = (interactionCounts[key] || 0) + 1;
+                            }
+                        }
+                    }
+                }
+                catch {
+                    // ignore parse errors
+                }
+            }
+        }
+        // Report
+        const sorted = Object.entries(interactionCounts).sort((a, b) => b[1] - a[1]);
+        if (sorted.length > 0) {
+            console.log("\nTop Interactions (Heatmap):");
+            sorted.slice(0, 10).forEach(([key, count]) => {
+                console.log(`  ${console_chars_1.emoji.fire} ${count}x  ${key}`);
+            });
+            console.log(`\n(Total unique interactions: ${sorted.length})`);
+        }
+        else {
+            console.log("No interactions found in traces.");
+        }
+    }
+    catch (err) {
+        console.error("Heatmap analysis failed:", err);
+    }
+    finally {
+        if (fs.existsSync(tempDir))
+            fs.rmSync(tempDir, { recursive: true, force: true });
+    }
+}
+main().catch(console.error);
+//# sourceMappingURL=coverage-gap-analysis.js.map