@empline/preflight 1.1.11 → 1.1.13

package/dist/checks/testing/playwright-feature-coverage-gaps.js

@@ -0,0 +1,1582 @@
+#!/usr/bin/env tsx
+"use strict";
+/**
+ * Playwright Feature Coverage Gap Detection Preflight (Proactive)
+ *
+ * PROACTIVELY discovers missing E2E test coverage by:
+ * 1. Scanning source code for features, API endpoints, UI components
+ * 2. Analyzing what Playwright tests actually exercise
+ * 3. Reporting gaps between implementation and test coverage
+ * 4. Tracking coverage trends over time
+ * 5. Generating test stubs for uncovered features
+ *
+ * This is NOT a checklist - it discovers gaps automatically.
+ *
+ * @blocking true
+ * @category testing
+ *
+ * Usage:
+ *   pnpm preflight:playwright-feature-gaps
+ *   pnpm preflight:playwright-feature-gaps --verbose
+ *   pnpm preflight:playwright-feature-gaps --report
+ *   pnpm preflight:playwright-feature-gaps --generate-stubs
+ *   pnpm preflight:playwright-feature-gaps --trend
+ */
+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;
+exports.run = run;
+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 universal_progress_reporter_1 = require("../system/universal-progress-reporter");
+// Check metadata
+exports.id = "testing/playwright-feature-coverage-gaps";
+exports.name = "Playwright Feature Coverage Gaps";
+exports.category = "testing";
+exports.blocking = true;
+exports.description = "Playwright Feature Coverage Gap Detection Preflight (Proactive)";
+exports.tags = ["testing"];
+const isVerbose = process.argv.includes("--verbose");
+const generateReport = process.argv.includes("--fix") || process.argv.includes("--report");
+const generateStubs = process.argv.includes("--generate-stubs");
+const showTrend = process.argv.includes("--trend");
+const warnOnly = process.argv.includes("--warn");
+const TREND_FILE = ".playwright-coverage-trend.json";
+// HELPER: Get recently modified files (last 30 days)
+function getRecentlyModifiedFiles() {
+    const recentFiles = new Set();
+    try {
+        const thirtyDaysAgo = new Date();
+        thirtyDaysAgo.setDate(thirtyDaysAgo.getDate() - 30);
+        const since = thirtyDaysAgo.toISOString().split("T")[0];
+        const output = (0, child_process_1.execSync)(`git log --since="${since}" --name-only --pretty=format: -- "*.ts" "*.tsx"`, { encoding: "utf-8", maxBuffer: 10 * 1024 * 1024 });
+        output
+            .split("\n")
+            .filter(Boolean)
+            .forEach((f) => recentFiles.add(f));
+    }
+    catch {
+        // Git not available or not a git repo
+    }
+    return recentFiles;
+}
+// TREND TRACKING
+function loadTrendHistory() {
+    try {
+        if (fs.existsSync(TREND_FILE)) {
+            return JSON.parse(fs.readFileSync(TREND_FILE, "utf-8"));
+        }
+    }
+    catch {
+        // Ignore parse errors
+    }
+    return { runs: [] };
+}
+function saveTrendData(totalFeatures, coveredFeatures, byCategory) {
+    const history = loadTrendHistory();
+    const categoryStats = {};
+    for (const [cat, stats] of Object.entries(byCategory)) {
+        categoryStats[cat] = {
+            ...stats,
+            percent: stats.total > 0 ? Math.round((stats.covered / stats.total) * 100) : 100,
+        };
+    }
+    const newEntry = {
+        timestamp: new Date().toISOString(),
+        totalFeatures,
+        coveredFeatures,
+        coveragePercent: totalFeatures > 0 ? Math.round((coveredFeatures / totalFeatures) * 100) : 100,
+        byCategory: categoryStats,
+    };
+    history.runs.push(newEntry);
+    // Keep last 100 runs
+    if (history.runs.length > 100) {
+        history.runs = history.runs.slice(-100);
+    }
+    fs.writeFileSync(TREND_FILE, JSON.stringify(history, null, 2));
+}
+function displayTrend() {
+    const history = loadTrendHistory();
+    if (history.runs.length === 0) {
+        console.log(`\n${console_chars_1.emoji.info} No trend data available yet. Run the preflight a few times to build history.`);
+        return;
+    }
+    console.log(`\n${console_chars_1.emoji.chart} COVERAGE TREND (last ${Math.min(history.runs.length, 10)} runs)`);
+    console.log((0, console_chars_1.createDivider)(60, "light"));
+    const recentRuns = history.runs.slice(-10);
+    for (const run of recentRuns) {
+        const date = new Date(run.timestamp).toLocaleDateString();
+        const bar = "█".repeat(Math.floor(run.coveragePercent / 5)) +
+            "░".repeat(20 - Math.floor(run.coveragePercent / 5));
+        console.log(`  ${date}  ${bar} ${run.coveragePercent}% (${run.coveredFeatures}/${run.totalFeatures})`);
+    }
+    // Show trend direction
+    if (recentRuns.length >= 2) {
+        const latest = recentRuns[recentRuns.length - 1];
+        const previous = recentRuns[recentRuns.length - 2];
+        const diff = latest.coveragePercent - previous.coveragePercent;
+        if (diff > 0) {
+            console.log(`\n  ${console_chars_1.emoji.success} Coverage improved by ${diff}% since last run`);
+        }
+        else if (diff < 0) {
+            console.log(`\n  ${console_chars_1.emoji.warning} Coverage decreased by ${Math.abs(diff)}% since last run`);
+        }
+        else {
+            console.log(`\n  ${console_chars_1.emoji.info} Coverage unchanged since last run`);
+        }
+    }
+    // Category breakdown for latest run
+    const latest = recentRuns[recentRuns.length - 1];
+    if (Object.keys(latest.byCategory).length > 0) {
+        console.log(`\n  ${console_chars_1.emoji.folder} By Category:`);
+        for (const [cat, stats] of Object.entries(latest.byCategory)) {
+            const catBar = "█".repeat(Math.floor(stats.percent / 10)) +
+                "░".repeat(10 - Math.floor(stats.percent / 10));
+            console.log(`     ${cat.padEnd(15)} ${catBar} ${stats.percent}%`);
+        }
+    }
+}
+// TEST STUB GENERATION
+function generateTestStub(gap) {
+    const { feature } = gap;
+    switch (feature.type) {
+        case "api-endpoint": {
+            const [method, endpoint] = feature.name.split(" ");
+            return `import { test, expect } from "@playwright/test";
+
+test.describe("${endpoint}", () => {
+  test("${method} request returns expected response", async ({ request }) => {
+    // TODO: Implement test for ${feature.name}
+    // Source: ${feature.sourcePath}
+    
+    const response = await request.${method.toLowerCase()}("${endpoint}", {
+      // Add request body/params as needed
+    });
+    
+    expect(response.ok()).toBeTruthy();
+    // Add more assertions based on expected response
+  });
+});
+`;
+        }
+        case "page-action": {
+            return `import { test, expect } from "@playwright/test";
+
+test.describe("${feature.name} action", () => {
+  test("executes successfully", async ({ page }) => {
+    // TODO: Implement test for server action: ${feature.name}
+    // Source: ${feature.sourcePath}${feature.line ? `:${feature.line}` : ""}
+    
+    // Navigate to page that uses this action
+    await page.goto("/path-to-page");
+    
+    // Trigger the action (e.g., form submission, button click)
+    // await page.getByRole("button", { name: "Submit" }).click();
+    
+    // Assert expected outcome
+    // await expect(page.getByText("Success")).toBeVisible();
+  });
+});
+`;
+        }
+        case "page":
+        case "ui-component": {
+            const routePath = feature.name.replace("Page: ", "");
+            return `import { test, expect } from "@playwright/test";
+
+test.describe("${routePath}", () => {
+  test("page loads successfully", async ({ page }) => {
+    // TODO: Implement test for ${feature.name}
+    // Source: ${feature.sourcePath}
+    
+    await page.goto("${routePath}");
+    
+    // Assert page loaded
+    await expect(page).toHaveURL(/${routePath.replace(/\//g, "\\/")}/);
+    
+    // Add more specific assertions
+  });
+
+  test("key interactions work", async ({ page }) => {
+    await page.goto("${routePath}");
+    
+    // TODO: Add interaction tests
+  });
+});
+`;
+        }
+        case "middleware": {
+            return `import { test, expect } from "@playwright/test";
+
+test.describe("Middleware: ${feature.context || feature.name}", () => {
+  test("redirects unauthenticated users", async ({ page }) => {
+    // TODO: Implement middleware test
+    // Source: ${feature.sourcePath}
+    
+    // Test unauthenticated access
+    await page.goto("/protected-route");
+    await expect(page).toHaveURL(/login/);
+  });
+
+  test("allows authenticated users", async ({ page }) => {
+    // TODO: Set up authenticated state
+    // await page.goto("/protected-route");
+    // await expect(page).toHaveURL("/protected-route");
+  });
+});
+`;
+        }
+        case "error-boundary": {
+            const isError = feature.context === "error";
+            return `import { test, expect } from "@playwright/test";
+
+test.describe("${feature.name}", () => {
+  test("${isError ? "error" : "not-found"} boundary renders correctly", async ({ page }) => {
+    // TODO: Implement error boundary test
+    // Source: ${feature.sourcePath}
+    
+    ${isError
+                ? `// Trigger an error condition
+    await page.route("**/api/**", (route) => route.abort());
+    await page.goto("/path-that-errors");
+    
+    // Assert error UI is shown
+    await expect(page.getByText(/error|something went wrong/i)).toBeVisible();`
+                : `// Navigate to non-existent route
+    await page.goto("/non-existent-page-12345");
+    
+    // Assert 404 UI is shown
+    await expect(page.getByText(/not found|404/i)).toBeVisible();`}
+  });
+});
+`;
+        }
+        case "file-upload": {
+            return `import { test, expect } from "@playwright/test";
+import path from "path";
+import { createUniversalProgressReporter } from "../system/universal-progress-reporter";
+
+test.describe("File upload: ${path.basename(feature.sourcePath)}", () => {
+  test("file upload works correctly", async ({ page }) => {
+    // TODO: Implement file upload test
+    // Source: ${feature.sourcePath}
+    
+    await page.goto("/path-with-upload");
+    
+    // Upload a file
+    const fileInput = page.locator('input[type="file"]');
+    await fileInput.setInputFiles(path.join(__dirname, "fixtures/test-file.png"));
+    
+    // Assert upload success
+    // await expect(page.getByText("Upload complete")).toBeVisible();
+  });
+});
+`;
+        }
+        case "modal-trigger": {
+            return `import { test, expect } from "@playwright/test";
+
+test.describe("Modal: ${path.basename(feature.sourcePath)}", () => {
+  test("modal opens and closes correctly", async ({ page }) => {
+    // TODO: Implement modal test
+    // Source: ${feature.sourcePath}
+    
+    await page.goto("/path-with-modal");
+    
+    // Open modal
+    await page.getByRole("button", { name: /open/i }).click();
+    await expect(page.getByRole("dialog")).toBeVisible();
+    
+    // Close modal
+    await page.getByRole("button", { name: /close|cancel/i }).click();
+    await expect(page.getByRole("dialog")).not.toBeVisible();
+  });
+});
+`;
+        }
+        default:
+            return `import { test, expect } from "@playwright/test";
+
+test.describe("${feature.name}", () => {
+  test("TODO: implement test", async ({ page }) => {
+    // TODO: Implement test for ${feature.type}: ${feature.name}
+    // Source: ${feature.sourcePath}
+    
+    // Add test implementation
+  });
+});
+`;
+    }
+}
+function writeTestStubs(gaps) {
+    const stubsDir = "tests/e2e/_generated-stubs";
+    if (!fs.existsSync(stubsDir)) {
+        fs.mkdirSync(stubsDir, { recursive: true });
+    }
+    let written = 0;
+    for (const gap of gaps) {
+        if (!gap.suggestedTestFile)
+            continue;
+        const stubPath = gap.suggestedTestFile.replace("tests/e2e/", `${stubsDir}/`);
+        const stubDir = path.dirname(stubPath);
+        if (!fs.existsSync(stubDir)) {
+            fs.mkdirSync(stubDir, { recursive: true });
+        }
+        // Don't overwrite existing stubs
+        if (fs.existsSync(stubPath))
+            continue;
+        const stub = generateTestStub(gap);
+        fs.writeFileSync(stubPath, stub);
+        written++;
+    }
+    return written;
+}
+// PHASE 1: DISCOVER FEATURES FROM SOURCE CODE
+async function discoverApiEndpoints(recentFiles) {
+    const { glob } = await Promise.resolve().then(() => __importStar(require("glob")));
+    const features = [];
+    const apiFiles = await glob("app/api/**/route.ts", { cwd: process.cwd() });
+    for (const file of apiFiles) {
+        const content = fs.readFileSync(file, "utf-8");
+        const routePath = "/" + path.dirname(file).replace(/\\/g, "/").replace("app/", "");
+        const hasDynamicSegment = routePath.includes("[");
+        const recentlyModified = recentFiles.has(file);
+        const methods = ["GET", "POST", "PUT", "PATCH", "DELETE"];
+        for (const method of methods) {
+            const methodRegex = new RegExp(`export\\s+(async\\s+)?function\\s+${method}\\b`, "i");
+            if (methodRegex.test(content)) {
+                const isCritical = routePath.includes("/store/") ||
+                    routePath.includes("/admin/") ||
+                    routePath.includes("/auth/") ||
+                    routePath.includes("/checkout/") ||
+                    routePath.includes("/orders/") ||
+                    routePath.includes("/payments/") ||
+                    method === "DELETE" ||
+                    method === "POST";
+                features.push({
+                    name: `${method} ${routePath}`,
+                    type: "api-endpoint",
+                    sourcePath: file,
+                    context: method,
+                    priority: isCritical ? "critical" : hasDynamicSegment ? "high" : "medium",
+                    recentlyModified,
+                });
+            }
+        }
+    }
+    return features;
+}
+async function discoverPageActions(recentFiles) {
+    const { glob } = await Promise.resolve().then(() => __importStar(require("glob")));
+    const features = [];
+    const actionFiles = await glob("app/**/actions.ts", { cwd: process.cwd() });
+    actionFiles.push(...(await glob("app/**/actions/*.ts", { cwd: process.cwd() })));
+    actionFiles.push(...(await glob("lib/actions/**/*.ts", { cwd: process.cwd() })));
+    for (const file of actionFiles) {
+        const content = fs.readFileSync(file, "utf-8");
+        const recentlyModified = recentFiles.has(file);
+        const actionRegex = /export\s+async\s+function\s+(\w+)/g;
+        let match;
+        while ((match = actionRegex.exec(content)) !== null) {
+            const lineNum = content.substring(0, match.index).split("\n").length;
+            const actionName = match[1].toLowerCase();
+            const isCritical = actionName.includes("delete") ||
+                actionName.includes("create") ||
+                actionName.includes("update") ||
+                actionName.includes("submit") ||
+                actionName.includes("approve") ||
+                actionName.includes("reject") ||
+                actionName.includes("payment") ||
+                actionName.includes("order");
+            features.push({
+                name: match[1],
+                type: "page-action",
+                sourcePath: file,
+                line: lineNum,
+                priority: isCritical ? "critical" : "medium",
+                recentlyModified,
+            });
+        }
+    }
+    return features;
+}
+async function discoverFormFields(recentFiles) {
+    const { glob } = await Promise.resolve().then(() => __importStar(require("glob")));
+    const features = [];
+    const componentFiles = await glob("{app,components}/**/*.tsx", { cwd: process.cwd() });
+    const formPatterns = [
+        { regex: /<TextField[^>]*name=["']([^"']+)["']/g, type: "text-field" },
+        { regex: /<Select[^>]*name=["']([^"']+)["']/g, type: "select" },
+        { regex: /<input[^>]*name=["']([^"']+)["']/g, type: "input" },
+        { regex: /register\(["']([^"']+)["']\)/g, type: "react-hook-form" },
+        { regex: /<FormField[^>]*name=["']([^"']+)["']/g, type: "form-field" },
+    ];
+    const criticalPaths = [
+        "app/store/",
+        "app/admin/",
+        "app/account/",
+        "app/(auth)/",
+        "components/forms/",
+        "components/seller/",
+    ];
+    for (const file of componentFiles) {
+        const normalizedPath = file.replace(/\\/g, "/");
+        const isCritical = criticalPaths.some((p) => normalizedPath.includes(p));
+        if (!isCritical)
+            continue;
+        const content = fs.readFileSync(file, "utf-8");
+        const recentlyModified = recentFiles.has(file);
+        for (const pattern of formPatterns) {
+            let match;
+            while ((match = pattern.regex.exec(content)) !== null) {
+                features.push({
+                    name: match[1],
+                    type: "form-field",
+                    sourcePath: file,
+                    context: pattern.type,
+                    recentlyModified,
+                });
+            }
+        }
+    }
+    return features;
+}
+async function discoverCriticalButtons(recentFiles) {
+    const { glob } = await Promise.resolve().then(() => __importStar(require("glob")));
+    const features = [];
+    const componentFiles = await glob("{app,components}/**/*.tsx", { cwd: process.cwd() });
+    const criticalPaths = ["app/store/", "app/admin/", "app/account/"];
+    for (const file of componentFiles) {
+        const normalizedPath = file.replace(/\\/g, "/");
+        const isCritical = criticalPaths.some((p) => normalizedPath.includes(p));
+        if (!isCritical)
+            continue;
+        const content = fs.readFileSync(file, "utf-8");
+        const recentlyModified = recentFiles.has(file);
+        const deleteActions = content.match(/onClick=\{[^}]*(?:delete|remove|handleDelete)/gi) || [];
+        for (const _action of deleteActions) {
+            features.push({
+                name: `Delete action in ${path.basename(file)}`,
+                type: "ui-component",
+                sourcePath: file,
+                context: "destructive-action",
+                priority: "critical",
+                recentlyModified,
+            });
+        }
+        const submitButtons = content.match(/<Button[^>]*type=["']submit["'][^>]*>/gi) || [];
+        for (const _btn of submitButtons) {
+            features.push({
+                name: `Form submit in ${path.basename(file)}`,
+                type: "ui-component",
+                sourcePath: file,
+                context: "form-submit",
+                priority: "high",
+                recentlyModified,
+            });
+        }
+    }
+    const seen = new Set();
+    return features.filter((f) => {
+        const key = `${f.sourcePath}:${f.context}`;
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+        return true;
+    });
+}
+// EXTENDED DISCOVERY: Middleware, Error Boundaries, Loading States, etc.
+async function discoverMiddleware(recentFiles) {
+    const { glob } = await Promise.resolve().then(() => __importStar(require("glob")));
+    const features = [];
+    const middlewareFiles = await glob("middleware.ts", { cwd: process.cwd() });
+    middlewareFiles.push(...(await glob("app/**/middleware.ts", { cwd: process.cwd() })));
+    for (const file of middlewareFiles) {
+        const content = fs.readFileSync(file, "utf-8");
+        const recentlyModified = recentFiles.has(file);
+        const matcherRegex = /matcher:\s*\[([^\]]+)\]/g;
+        let match;
+        while ((match = matcherRegex.exec(content)) !== null) {
+            const patterns = match[1].split(",").map((p) => p.trim().replace(/["']/g, ""));
+            for (const pattern of patterns) {
+                features.push({
+                    name: `Middleware: ${pattern}`,
+                    type: "middleware",
+                    sourcePath: file,
+                    context: pattern,
+                    priority: "high",
+                    recentlyModified,
+                });
+            }
+        }
+        if (content.includes("NextResponse.redirect") || content.includes("NextResponse.rewrite")) {
+            features.push({
+                name: `Middleware redirects in ${path.basename(file)}`,
+                type: "middleware",
+                sourcePath: file,
+                context: "redirect-logic",
+                priority: "high",
+                recentlyModified,
+            });
+        }
+        if (content.includes("getToken") || content.includes("auth(") || content.includes("session")) {
+            features.push({
+                name: `Auth middleware in ${path.basename(file)}`,
+                type: "middleware",
+                sourcePath: file,
+                context: "auth-check",
+                priority: "critical",
+                recentlyModified,
+            });
+        }
+    }
+    return features;
+}
+async function discoverErrorBoundaries(recentFiles) {
+    const { glob } = await Promise.resolve().then(() => __importStar(require("glob")));
+    const features = [];
+    const errorFiles = await glob("app/**/error.tsx", { cwd: process.cwd() });
+    const notFoundFiles = await glob("app/**/not-found.tsx", { cwd: process.cwd() });
+    for (const file of [...errorFiles, ...notFoundFiles]) {
+        const routePath = path.dirname(file).replace(/\\/g, "/").replace("app/", "/");
+        const isError = file.includes("error.tsx");
+        const recentlyModified = recentFiles.has(file);
+        features.push({
+            name: `${isError ? "Error" : "NotFound"} boundary: ${routePath}`,
+            type: "error-boundary",
+            sourcePath: file,
+            context: isError ? "error" : "not-found",
+            priority: "medium",
+            recentlyModified,
+        });
+    }
+    return features;
+}
+async function discoverLoadingStates(recentFiles) {
+    const { glob } = await Promise.resolve().then(() => __importStar(require("glob")));
+    const features = [];
+    const loadingFiles = await glob("app/**/loading.tsx", { cwd: process.cwd() });
+    for (const file of loadingFiles) {
+        const routePath = path.dirname(file).replace(/\\/g, "/").replace("app/", "/");
+        const recentlyModified = recentFiles.has(file);
+        features.push({
+            name: `Loading state: ${routePath}`,
+            type: "loading-state",
+            sourcePath: file,
+            priority: "low",
+            recentlyModified,
+        });
+    }
+    return features;
+}
+async function discoverDynamicRoutes(recentFiles) {
+    const { glob } = await Promise.resolve().then(() => __importStar(require("glob")));
+    const features = [];
+    const pageFiles = await glob("app/**/\\[*\\]/**/page.tsx", { cwd: process.cwd() });
+    pageFiles.push(...(await glob("app/**/\\[*\\]/page.tsx", { cwd: process.cwd() })));
+    for (const file of pageFiles) {
+        const routePath = path.dirname(file).replace(/\\/g, "/").replace("app/", "/");
+        const recentlyModified = recentFiles.has(file);
+        const segments = routePath.match(/\[([^\]]+)\]/g) || [];
+        features.push({
+            name: `Dynamic route: ${routePath}`,
+            type: "dynamic-route",
+            sourcePath: file,
+            context: segments.join(", "),
+            priority: "high",
+            recentlyModified,
+        });
+    }
+    return features;
+}
+async function discoverDataTestIds(recentFiles) {
+    const { glob } = await Promise.resolve().then(() => __importStar(require("glob")));
+    const features = [];
+    const componentFiles = await glob("{app,components}/**/*.tsx", { cwd: process.cwd() });
+    for (const file of componentFiles) {
+        const content = fs.readFileSync(file, "utf-8");
+        const recentlyModified = recentFiles.has(file);
+        const testIdRegex = /data-testid=["']([^"']+)["']/g;
+        let match;
+        while ((match = testIdRegex.exec(content)) !== null) {
+            features.push({
+                name: match[1],
+                type: "data-testid",
+                sourcePath: file,
+                priority: "medium",
+                recentlyModified,
+            });
+        }
+    }
+    return features;
+}
+async function discoverSideEffects(recentFiles) {
+    const { glob } = await Promise.resolve().then(() => __importStar(require("glob")));
+    const features = [];
+    const componentFiles = await glob("{app,components}/**/*.tsx", { cwd: process.cwd() });
+    const criticalPaths = ["app/store/", "app/admin/", "app/account/", "app/checkout/"];
+    for (const file of componentFiles) {
+        const normalizedPath = file.replace(/\\/g, "/");
+        const isCritical = criticalPaths.some((p) => normalizedPath.includes(p));
+        if (!isCritical)
+            continue;
+        const content = fs.readFileSync(file, "utf-8");
+        const recentlyModified = recentFiles.has(file);
+        const useEffectWithFetch = /useEffect\s*\(\s*(?:async\s*)?\(\)\s*=>\s*\{[^}]*(?:fetch|axios|api\.|\.get\(|\.post\()/gi;
+        if (useEffectWithFetch.test(content)) {
+            features.push({
+                name: `Side effect with API call in ${path.basename(file)}`,
+                type: "side-effect",
+                sourcePath: file,
+                context: "api-call",
+                priority: "high",
+                recentlyModified,
+            });
+        }
+    }
+    const seen = new Set();
+    return features.filter((f) => {
+        const key = `${f.sourcePath}:${f.type}`;
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+        return true;
+    });
+}
+async function discoverModalTriggers(recentFiles) {
+    const { glob } = await Promise.resolve().then(() => __importStar(require("glob")));
+    const features = [];
+    const componentFiles = await glob("{app,components}/**/*.tsx", { cwd: process.cwd() });
+    for (const file of componentFiles) {
+        const content = fs.readFileSync(file, "utf-8");
+        const recentlyModified = recentFiles.has(file);
+        const modalPatterns = [
+            /<Dialog[^>]*open=/gi,
+            /<Modal[^>]*open=/gi,
+            /setOpen\(true\)/gi,
+            /setIsOpen\(true\)/gi,
+            /setShowModal\(true\)/gi,
+            /openModal\(/gi,
+        ];
+        for (const pattern of modalPatterns) {
+            if (pattern.test(content)) {
+                features.push({
+                    name: `Modal/Dialog in ${path.basename(file)}`,
+                    type: "modal-trigger",
+                    sourcePath: file,
+                    priority: "medium",
+                    recentlyModified,
+                });
+                break;
+            }
+        }
+    }
+    return features;
+}
+async function discoverToastTriggers(recentFiles) {
+    const { glob } = await Promise.resolve().then(() => __importStar(require("glob")));
+    const features = [];
+    const componentFiles = await glob("{app,components}/**/*.tsx", { cwd: process.cwd() });
+    for (const file of componentFiles) {
+        const content = fs.readFileSync(file, "utf-8");
+        const recentlyModified = recentFiles.has(file);
+        const toastPatterns = [
+            /toast\(/gi,
+            /toast\.success\(/gi,
+            /toast\.error\(/gi,
+            /showNotification\(/gi,
+            /enqueueSnackbar\(/gi,
+            /addToast\(/gi,
+        ];
+        for (const pattern of toastPatterns) {
+            if (pattern.test(content)) {
+                features.push({
+                    name: `Toast/Notification in ${path.basename(file)}`,
+                    type: "toast-trigger",
+                    sourcePath: file,
+                    priority: "low",
+                    recentlyModified,
+                });
+                break;
+            }
+        }
+    }
+    return features;
+}
+async function discoverFileUploads(recentFiles) {
+    const { glob } = await Promise.resolve().then(() => __importStar(require("glob")));
+    const features = [];
+    const componentFiles = await glob("{app,components}/**/*.tsx", { cwd: process.cwd() });
+    for (const file of componentFiles) {
+        const content = fs.readFileSync(file, "utf-8");
+        const recentlyModified = recentFiles.has(file);
+        const uploadPatterns = [
+            /<input[^>]*type=["']file["']/gi,
+            /useDropzone/gi,
+            /FileUpload/gi,
+            /UploadButton/gi,
+            /setInputFiles/gi,
+            /FormData.*append.*file/gi,
+        ];
+        for (const pattern of uploadPatterns) {
+            if (pattern.test(content)) {
+                features.push({
+                    name: `File upload in ${path.basename(file)}`,
+                    type: "file-upload",
+                    sourcePath: file,
+                    priority: "high",
+                    recentlyModified,
+                });
+                break;
+            }
+        }
+    }
+    return features;
+}
+async function discoverWebSockets(recentFiles) {
+    const { glob } = await Promise.resolve().then(() => __importStar(require("glob")));
+    const features = [];
+    const files = await glob("{app,components,lib}/**/*.{ts,tsx}", { cwd: process.cwd() });
+    for (const file of files) {
+        const content = fs.readFileSync(file, "utf-8");
+        const recentlyModified = recentFiles.has(file);
+        const wsPatterns = [
+            /new WebSocket\(/gi,
+            /useWebSocket/gi,
+            /socket\.io/gi,
+            /pusher/gi,
+            /ably/gi,
+        ];
+        for (const pattern of wsPatterns) {
+            if (pattern.test(content)) {
+                features.push({
+                    name: `WebSocket in ${path.basename(file)}`,
+                    type: "websocket",
+                    sourcePath: file,
+                    priority: "high",
+                    recentlyModified,
+                });
+                break;
+            }
+        }
+    }
+    return features;
+}
+async function discoverStorageUsage(recentFiles) {
+    const { glob } = await Promise.resolve().then(() => __importStar(require("glob")));
+    const features = [];
+    const files = await glob("{app,components,lib}/**/*.{ts,tsx}", { cwd: process.cwd() });
+    for (const file of files) {
+        const content = fs.readFileSync(file, "utf-8");
+        const recentlyModified = recentFiles.has(file);
+        if (/localStorage\./gi.test(content)) {
+            features.push({
+                name: `localStorage in ${path.basename(file)}`,
+                type: "storage-usage",
+                sourcePath: file,
+                context: "localStorage",
+                priority: "medium",
+                recentlyModified,
+            });
+        }
+        if (/sessionStorage\./gi.test(content)) {
+            features.push({
+                name: `sessionStorage in ${path.basename(file)}`,
+                type: "storage-usage",
+                sourcePath: file,
+                context: "sessionStorage",
+                priority: "medium",
+                recentlyModified,
+            });
+        }
+    }
+    const seen = new Set();
+    return features.filter((f) => {
+        const key = `${f.sourcePath}:${f.context}`;
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+        return true;
+    });
+}
+// PHASE 2: ANALYZE WHAT TESTS ACTUALLY COVER
+async function analyzeTestCoverage() {
+    const { glob } = await Promise.resolve().then(() => __importStar(require("glob")));
+    const coverageMap = new Map();
+    const testFiles = await glob("tests/e2e/**/*.spec.ts", { cwd: process.cwd() });
+    for (const testFile of testFiles) {
+        const content = fs.readFileSync(testFile, "utf-8");
+        const coverage = {
+            testPath: testFile,
+            coveredEndpoints: new Set(),
+            coveredActions: new Set(),
+            coveredComponents: new Set(),
+            mockedApis: new Set(),
+            interactions: new Set(),
+            testIds: new Set(),
+            dynamicParams: new Set(),
+        };
+        // Extract API endpoints being tested or mocked
+        const apiPatterns = [
+            /page\.route\(["']\*\*([^"']+)["']/g,
+            /request\.(?:get|post|put|patch|delete)\(["']([^"']+)["']/g,
+            /fetch\(["']([^"']+)["']/g,
+            /goto\([^,]*,\s*["']([^"']+)["']/g,
+            /page\.goto\(["']([^"']+)["']/g,
+        ];
+        for (const pattern of apiPatterns) {
+            let match;
+            while ((match = pattern.exec(content)) !== null) {
+                const endpoint = match[1].replace(/\*\*/g, "").replace(/\*/g, "");
+                if (endpoint.includes("/api/")) {
+                    coverage.mockedApis.add(endpoint);
+                }
+                coverage.coveredEndpoints.add(endpoint);
+            }
+        }
+        // Extract UI interactions
+        const interactionPatterns = [
+            /\.click\(\)/g,
+            /\.fill\(["']([^"']+)["']/g,
+            /\.type\(["']([^"']+)["']/g,
+            /\.check\(\)/g,
+            /\.selectOption\(/g,
+            /\.setInputFiles\(/g,
+            /getByRole\(["']([^"']+)["']/g,
+            /getByLabel\(["']([^"']+)["']/g,
+            /getByText\(["']([^"']+)["']/g,
+            /getByTestId\(["']([^"']+)["']/g,
+        ];
+        for (const pattern of interactionPatterns) {
+            let match;
+            while ((match = pattern.exec(content)) !== null) {
+                coverage.interactions.add(match[1] || match[0]);
+            }
+        }
+        // Extract data-testid usage
+        const testIdPattern = /getByTestId\(["']([^"']+)["']\)/g;
+        let testIdMatch;
+        while ((testIdMatch = testIdPattern.exec(content)) !== null) {
+            coverage.testIds.add(testIdMatch[1]);
+        }
+        // Extract dynamic route params being tested
+        const dynamicParamPatterns = [
+            /\/\w+\/([a-f0-9-]{36})/gi, // UUIDs
+            /\/\w+\/(\d+)/g, // Numeric IDs
+            /params\.\w+/g, // params.id, params.slug
+        ];
+        for (const pattern of dynamicParamPatterns) {
+            let match;
+            while ((match = pattern.exec(content)) !== null) {
+                coverage.dynamicParams.add(match[1] || match[0]);
+            }
+        }
+        // Extract action names being tested
+        const actionMentions = content.match(/["'](\w+Action|handle\w+|on\w+|submit\w+)["']/gi) || [];
+        for (const action of actionMentions) {
+            coverage.coveredActions.add(action.replace(/["']/g, ""));
+        }
+        coverageMap.set(testFile, coverage);
+    }
+    return coverageMap;
+}
+function aggregateCoverage(coverageMap) {
+    const result = {
+        allEndpoints: new Set(),
+        allMockedApis: new Set(),
+        allInteractions: new Set(),
+        allActions: new Set(),
+        allTestIds: new Set(),
+        allDynamicParams: new Set(),
+        testFilesByRoute: new Map(),
+    };
+    for (const [testPath, coverage] of coverageMap) {
+        coverage.coveredEndpoints.forEach((e) => {
+            result.allEndpoints.add(e);
+            const existing = result.testFilesByRoute.get(e) || [];
+            existing.push(testPath);
+            result.testFilesByRoute.set(e, existing);
+        });
+        coverage.mockedApis.forEach((e) => result.allMockedApis.add(e));
+        coverage.interactions.forEach((i) => result.allInteractions.add(i.toLowerCase()));
+        coverage.coveredActions.forEach((a) => result.allActions.add(a.toLowerCase()));
+        coverage.testIds.forEach((t) => result.allTestIds.add(t));
+        coverage.dynamicParams.forEach((p) => result.allDynamicParams.add(p));
+    }
+    return result;
+}
+// STRUCTURAL GAP DETECTION: Match source files to test files
+async function findStructuralGaps(recentFiles) {
+    const { glob } = await Promise.resolve().then(() => __importStar(require("glob")));
+    const gaps = [];
+    const pageFiles = await glob("app/**/page.tsx", { cwd: process.cwd() });
+    const testFiles = await glob("tests/e2e/**/*.spec.ts", { cwd: process.cwd() });
+    // Build a map of test file coverage by route pattern
+    const testRoutePatterns = new Set();
+    const testFileContents = new Map();
+    for (const testFile of testFiles) {
+        const routePattern = testFile
+            .replace("tests/e2e/", "")
+            .replace(".spec.ts", "")
+            .replace(/\\/g, "/");
+        testRoutePatterns.add(routePattern);
+        testRoutePatterns.add(routePattern.replace(/-/g, "/"));
+        // Also read test file content to check for route references
+        try {
+            const content = fs.readFileSync(testFile, "utf-8");
+            testFileContents.set(testFile, content);
+        }
+        catch {
+            // Ignore read errors
+        }
+    }
+    // Build a set of all routes referenced in test files
+    const routesInTests = new Set();
+    for (const [_testFile, content] of testFileContents) {
+        // Extract goto URLs
+        const gotoMatches = content.matchAll(/goto\s*\(\s*["'`]([^"'`]+)["'`]/g);
+        for (const match of gotoMatches) {
+            const route = match[1].replace(/^\//, "").split("?")[0];
+            routesInTests.add(route);
+            // Also add parent routes
+            const parts = route.split("/");
+            for (let i = 1; i <= parts.length; i++) {
+                routesInTests.add(parts.slice(0, i).join("/"));
+            }
+        }
+        // Extract route patterns from comments and test descriptions
+        const routeComments = content.matchAll(/\/([a-z][a-z0-9-]*(?:\/[a-z][a-z0-9-]*)*)/gi);
+        for (const match of routeComments) {
+            routesInTests.add(match[1]);
+        }
+    }
+    for (const pageFile of pageFiles) {
+        const routePattern = path
+            .dirname(pageFile)
+            .replace(/\\/g, "/")
+            .replace("app/", "")
+            .replace(/\(.*?\)\//g, "") // Remove route groups like (auth)/
+            .replace(/\[.*?\]/g, "[param]"); // Normalize dynamic segments
+        // Check 1: Test file name matches route pattern
+        const hasTestFile = [...testRoutePatterns].some((testPattern) => {
+            return (testPattern.includes(routePattern) ||
+                routePattern.includes(testPattern) ||
+                testPattern.replace(/-/g, "").includes(routePattern.replace(/-/g, "")));
+        });
+        // Check 2: Route is referenced in any test file content
+        const routeWithoutParams = routePattern.replace(/\[param\]/g, "");
+        const hasRouteReference = [...routesInTests].some((testedRoute) => {
+            const normalizedTested = testedRoute.toLowerCase().replace(/[^a-z0-9]/g, "");
+            const normalizedRoute = routeWithoutParams.toLowerCase().replace(/[^a-z0-9]/g, "");
+            return (normalizedTested.includes(normalizedRoute) ||
+                normalizedRoute.includes(normalizedTested) ||
+                testedRoute.includes(routePattern.replace(/\[param\]/g, "")));
+        });
+        if (!hasTestFile && !hasRouteReference && !routePattern.includes("api/")) {
+            const isCritical = routePattern.includes("store/") ||
+                routePattern.includes("admin/") ||
+                routePattern.includes("checkout/") ||
+                routePattern.includes("account/");
+            const recentlyModified = recentFiles.has(pageFile);
+            gaps.push({
+                feature: {
+                    name: `Page: /${routePattern}`,
+                    type: "page",
+                    sourcePath: pageFile,
+                    priority: isCritical ? "critical" : "medium",
+                    recentlyModified,
+                },
+                severity: isCritical ? "error" : "warning",
+                reason: `No test file found matching route pattern: ${routePattern}${recentlyModified ? " (recently modified)" : ""}`,
+                suggestedTestFile: `tests/e2e/${routePattern.replace(/\[param\]/g, "dynamic")}.spec.ts`,
+            });
+        }
+    }
+    return gaps;
+}
+// PHASE 3: COMPARE AND FIND GAPS
+function findApiGaps(discoveredApis, testedEndpoints, mockedApis) {
+    const gaps = [];
+    for (const api of discoveredApis) {
+        const endpoint = api.name.split(" ")[1];
+        const _method = api.name.split(" ")[0];
+        const isTested = [...testedEndpoints, ...mockedApis].some((tested) => tested.includes(endpoint) || endpoint.includes(tested.replace(/\*/g, "")));
+        if (!isTested) {
+            gaps.push({
+                feature: api,
+                severity: api.priority === "critical" ? "error" : "warning",
+                reason: `API endpoint ${api.name} has no E2E test coverage${api.recentlyModified ? " (recently modified)" : ""}`,
+                suggestedTestFile: `tests/e2e/api/${endpoint.replace("/api/", "").replace(/\//g, "-")}.spec.ts`,
+            });
+        }
+    }
+    return gaps;
+}
+function findActionGaps(discoveredActions, testedActions, testedInteractions) {
+    const gaps = [];
+    for (const action of discoveredActions) {
+        const actionName = action.name.toLowerCase();
+        // Check if action name is directly referenced
+        const isDirectlyTested = [...testedActions].some((tested) => tested.includes(actionName) || actionName.includes(tested));
+        // Check if action functionality is tested through UI interactions
+        // Extract key words from action name (e.g., "updateProfileVisibility" -> ["update", "profile", "visibility"])
+        const actionWords = actionName
+            .replace(/([A-Z])/g, " $1")
+            .toLowerCase()
+            .split(/\s+/)
+            .filter((w) => w.length > 3); // Filter out short words like "get", "set"
+        const isFunctionallyTested = actionWords.some((word) => [...testedInteractions].some((interaction) => interaction.includes(word) || word.includes(interaction)));
+        // Also check if the action's source file path suggests a tested area
+        const sourcePath = action.sourcePath.toLowerCase().replace(/\\/g, "/");
+        const interactionsLower = [...testedInteractions].map((i) => i.toLowerCase());
+        const isInTestedArea = (sourcePath.includes("profile") &&
+            interactionsLower.some((i) => i.includes("profile") || i.includes("setting") || i.includes("visibility"))) ||
+            (sourcePath.includes("cart") &&
+                interactionsLower.some((i) => i.includes("cart") ||
+                    i.includes("quantity") ||
+                    i.includes("increase") ||
+                    i.includes("decrease"))) ||
+            (sourcePath.includes("collection") &&
+                interactionsLower.some((i) => i.includes("collection") || i.includes("quantity"))) ||
+            // Wishlist actions - check for wishlist-related interactions
+            (sourcePath.includes("wishlist") &&
+                interactionsLower.some((i) => i.includes("wishlist") ||
+                    i.includes("save") ||
+                    i.includes("heart") ||
+                    i.includes("favorite") ||
+                    i.includes("remove"))) ||
+            (actionName.includes("wishlist") &&
+                interactionsLower.some((i) => i.includes("wishlist") ||
+                    i.includes("save") ||
+                    i.includes("heart") ||
+                    i.includes("favorite"))) ||
+            // Social actions - check for social-related interactions
+            (sourcePath.includes("social") &&
+                interactionsLower.some((i) => i.includes("follow") ||
+                    i.includes("like") ||
+                    i.includes("feed") ||
+                    i.includes("social"))) ||
+            (actionName.includes("follow") &&
+                interactionsLower.some((i) => i.includes("follow") || i.includes("unfollow"))) ||
+            (actionName.includes("like") &&
+                interactionsLower.some((i) => i.includes("like") || i.includes("unlike") || i.includes("heart"))) ||
+            (actionName.includes("feed") &&
+                interactionsLower.some((i) => i.includes("feed") || i.includes("collection"))) ||
+            // Price history actions
+            (actionName.includes("pricehistory") &&
+                interactionsLower.some((i) => i.includes("price") ||
+                    i.includes("history") ||
+                    i.includes("trend") ||
+                    i.includes("chart"))) ||
+            (actionName.includes("price") &&
+                actionName.includes("history") &&
+                interactionsLower.some((i) => i.includes("price") || i.includes("drop"))) ||
+            // Public collections actions
+            (actionName.includes("publiccollection") &&
+                interactionsLower.some((i) => i.includes("collection") || i.includes("public") || i.includes("explore"))) ||
+            (actionName.includes("public") &&
+                actionName.includes("collection") &&
+                interactionsLower.some((i) => i.includes("collection") || i.includes("profile")));
+        if (!isDirectlyTested && !isFunctionallyTested && !isInTestedArea) {
+            gaps.push({
+                feature: action,
+                severity: action.priority === "critical" ? "error" : "warning",
+                reason: `Server action "${action.name}" has no E2E test coverage${action.recentlyModified ? " (recently modified)" : ""}`,
+                suggestedTestFile: `tests/e2e/actions/${action.name
+                    .replace(/([A-Z])/g, "-$1")
+                    .toLowerCase()
+                    .replace(/^-/, "")}.spec.ts`,
+            });
+        }
+    }
+    return gaps;
+}
+function findFormFieldGaps(discoveredFields, testedInteractions) {
+    const gaps = [];
+    const fieldsByFile = new Map();
+    for (const field of discoveredFields) {
+        const existing = fieldsByFile.get(field.sourcePath) || [];
+        existing.push(field);
+        fieldsByFile.set(field.sourcePath, existing);
+    }
+    for (const [file, fields] of fieldsByFile) {
+        const untestedFields = fields.filter((f) => {
+            const fieldName = f.name.toLowerCase();
+            return ![...testedInteractions].some((tested) => tested.includes(fieldName) || fieldName.includes(tested));
+        });
+        if (untestedFields.length > 0 && untestedFields.length >= fields.length * 0.5) {
+            const hasRecentlyModified = untestedFields.some((f) => f.recentlyModified);
+            gaps.push({
+                feature: {
+                    name: `${untestedFields.length} form fields`,
+                    type: "form-field",
+                    sourcePath: file,
+                    context: untestedFields
+                        .map((f) => f.name)
+                        .slice(0, 5)
+                        .join(", "),
+                    recentlyModified: hasRecentlyModified,
+                },
+                severity: "warning",
+                reason: `Form in ${path.basename(file)} has ${untestedFields.length}/${fields.length} untested fields${hasRecentlyModified ? " (recently modified)" : ""}`,
+            });
+        }
+    }
+    return gaps;
+}
+function findDestructiveActionGaps(discoveredButtons, testedInteractions) {
+    const gaps = [];
+    const destructiveActions = discoveredButtons.filter((b) => b.context === "destructive-action");
+    for (const action of destructiveActions) {
+        const _fileName = path.basename(action.sourcePath).toLowerCase();
+        const hasDeleteTest = [...testedInteractions].some((i) => i.includes("delete") || i.includes("remove") || i.includes("confirm"));
+        if (!hasDeleteTest) {
+            gaps.push({
+                feature: action,
+                severity: "error",
+                reason: `Destructive action in ${path.basename(action.sourcePath)} has no E2E test${action.recentlyModified ? " (recently modified)" : ""}`,
+                suggestedTestFile: `tests/e2e/destructive/${path.basename(action.sourcePath).replace(".tsx", "")}.spec.ts`,
+            });
+        }
+    }
+    return gaps;
+}
+function findMiddlewareGaps(discoveredMiddleware, testedEndpoints) {
+    const gaps = [];
+    for (const mw of discoveredMiddleware) {
+        // Check if middleware routes are tested
+        const hasTest = [...testedEndpoints].some((e) => {
+            if (mw.context && mw.context !== "auth-check" && mw.context !== "redirect-logic") {
+                return e.includes(mw.context.replace(/\*/g, ""));
+            }
+            return false;
+        });
+        if (!hasTest) {
+            if (mw.context === "auth-check") {
+                gaps.push({
+                    feature: mw,
+                    severity: "error",
+                    reason: `Auth middleware needs tests for authenticated/unauthenticated states`,
+                    suggestedTestFile: "tests/e2e/auth/middleware-auth.spec.ts",
+                });
+            }
+            else if (mw.context === "redirect-logic") {
+                gaps.push({
+                    feature: mw,
+                    severity: "warning",
+                    reason: `Middleware redirect logic should be tested`,
+                    suggestedTestFile: "tests/e2e/middleware/redirects.spec.ts",
+                });
+            }
+        }
+    }
+    return gaps;
+}
+function findErrorBoundaryGaps(discoveredBoundaries, testedEndpoints, testedInteractions) {
+    const gaps = [];
+    // Check if there's a dedicated error boundary test file
+    const hasErrorBoundaryTests = [...testedEndpoints].some((e) => e.includes("error") || e.includes("boundary") || e.includes("404") || e.includes("not-found"));
+    // Check if error-related interactions are tested
+    const hasErrorInteractions = [...testedInteractions].some((i) => i.includes("error") ||
+        i.includes("retry") ||
+        i.includes("reload") ||
+        i.includes("try again") ||
+        i.includes("failed"));
+    // If we have error boundary tests, consider all boundaries covered
+    if (hasErrorBoundaryTests || hasErrorInteractions) {
+        return gaps;
+    }
+    for (const boundary of discoveredBoundaries) {
+        const routePath = boundary.name
+            .replace("Error boundary: ", "")
+            .replace("NotFound boundary: ", "");
+        const hasErrorTest = [...testedEndpoints].some((e) => e.includes(routePath) &&
+            (e.includes("error") || e.includes("404") || e.includes("not-found")));
+        if (!hasErrorTest) {
+            gaps.push({
+                feature: boundary,
+                severity: "warning",
+                reason: `${boundary.context === "error" ? "Error" : "NotFound"} boundary at ${routePath} has no E2E test`,
+                suggestedTestFile: `tests/e2e/error-states/${routePath.replace(/\//g, "-").replace(/^-/, "")}-${boundary.context}.spec.ts`,
+            });
+        }
+    }
+    return gaps;
+}
+function findFileUploadGaps(discoveredUploads, testedInteractions) {
+    const gaps = [];
+    const hasUploadTest = [...testedInteractions].some((i) => i.includes("file") || i.includes("upload") || i.includes("setinputfiles"));
+    if (!hasUploadTest && discoveredUploads.length > 0) {
+        for (const upload of discoveredUploads) {
+            gaps.push({
+                feature: upload,
+                severity: "warning",
+                reason: `File upload in ${path.basename(upload.sourcePath)} has no E2E test`,
+                suggestedTestFile: `tests/e2e/uploads/${path.basename(upload.sourcePath).replace(".tsx", "")}.spec.ts`,
+            });
+        }
+    }
+    return gaps;
+}
+function findModalGaps(discoveredModals, testedInteractions) {
+    const gaps = [];
+    const hasModalTest = [...testedInteractions].some((i) => i.includes("dialog") || i.includes("modal") || i.includes("close") || i.includes("cancel"));
+    // Only flag critical path modals
+    const criticalModals = discoveredModals.filter((m) => {
+        const filePath = m.sourcePath.replace(/\\/g, "/");
+        return (filePath.includes("store/") || filePath.includes("admin/") || filePath.includes("checkout/"));
+    });
+    if (!hasModalTest && criticalModals.length > 0) {
+        // Group by file to reduce noise
+        const byFile = new Map();
+        for (const modal of criticalModals) {
+            if (!byFile.has(modal.sourcePath)) {
+                byFile.set(modal.sourcePath, modal);
+            }
+        }
+        for (const modal of byFile.values()) {
+            gaps.push({
+                feature: modal,
+                severity: "warning",
+                reason: `Modal in critical path ${path.basename(modal.sourcePath)} has no E2E test`,
+                suggestedTestFile: `tests/e2e/modals/${path.basename(modal.sourcePath).replace(".tsx", "")}.spec.ts`,
+            });
+        }
+    }
+    return gaps;
+}
+function findDataTestIdGaps(discoveredTestIds, usedTestIds) {
+    const gaps = [];
+    // Only check critical path test IDs
+    const criticalTestIds = discoveredTestIds.filter((t) => {
+        const filePath = t.sourcePath.replace(/\\/g, "/");
+        return (filePath.includes("store/") || filePath.includes("admin/") || filePath.includes("checkout/"));
+    });
+    for (const testId of criticalTestIds) {
+        if (!usedTestIds.has(testId.name)) {
+            gaps.push({
+                feature: testId,
+                severity: "warning",
+                reason: `data-testid="${testId.name}" defined but never used in tests`,
+            });
+        }
+    }
+    return gaps;
+}
+// MAIN EXECUTION
+async function run() {
+    const reporter = (0, universal_progress_reporter_1.createUniversalProgressReporter)(exports.name);
+    console.log(`\n${console_chars_1.emoji.testTube} PLAYWRIGHT FEATURE COVERAGE GAP DETECTION (Proactive)`);
+    console.log((0, console_chars_1.createDivider)(60, "heavy"));
+    // Show trend if requested
+    if (showTrend) {
+        displayTrend();
+        process.exit(0);
+    }
+    console.log(`${console_chars_1.emoji.info} Scanning source code to discover features...`);
+    // Get recently modified files for priority flagging
+    const recentFiles = getRecentlyModifiedFiles();
+    // Phase 1: Discover ALL features from source (core + extended)
+    const [apiEndpoints, pageActions, formFields, criticalButtons, middleware, errorBoundaries, loadingStates, dynamicRoutes, dataTestIds, sideEffects, modalTriggers, toastTriggers, fileUploads, webSockets, storageUsage,] = await Promise.all([
+        discoverApiEndpoints(recentFiles),
+        discoverPageActions(recentFiles),
+        discoverFormFields(recentFiles),
+        discoverCriticalButtons(recentFiles),
+        discoverMiddleware(recentFiles),
+        discoverErrorBoundaries(recentFiles),
+        discoverLoadingStates(recentFiles),
+        discoverDynamicRoutes(recentFiles),
+        discoverDataTestIds(recentFiles),
+        discoverSideEffects(recentFiles),
+        discoverModalTriggers(recentFiles),
+        discoverToastTriggers(recentFiles),
+        discoverFileUploads(recentFiles),
+        discoverWebSockets(recentFiles),
+        discoverStorageUsage(recentFiles),
+    ]);
+    // Structural gaps (page.tsx without matching test files)
+    const structuralGaps = await findStructuralGaps(recentFiles);
+    if (isVerbose) {
+        console.log(`\n${console_chars_1.emoji.search} Discovered:`);
+        console.log(`   ${console_chars_1.emoji.globe} ${apiEndpoints.length} API endpoints`);
+        console.log(`   ${console_chars_1.emoji.lightning} ${pageActions.length} server actions`);
+        console.log(`   ${console_chars_1.emoji.clipboard} ${formFields.length} form fields (critical paths)`);
+        console.log(`   ${console_chars_1.emoji.warning} ${criticalButtons.length} destructive actions`);
+        console.log(`   ${console_chars_1.emoji.lock} ${middleware.length} middleware rules`);
+        console.log(`   ${console_chars_1.emoji.error} ${errorBoundaries.length} error boundaries`);
+        console.log(`   ${console_chars_1.emoji.clock} ${loadingStates.length} loading states`);
+        console.log(`   ${console_chars_1.emoji.link} ${dynamicRoutes.length} dynamic routes`);
+        console.log(`   ${console_chars_1.emoji.target} ${dataTestIds.length} data-testid attributes`);
+        console.log(`   ${console_chars_1.emoji.refresh} ${sideEffects.length} side effects with API calls`);
+        console.log(`   ${console_chars_1.emoji.components} ${modalTriggers.length} modal/dialog triggers`);
+        console.log(`   ${console_chars_1.emoji.bell} ${toastTriggers.length} toast/notification triggers`);
+        console.log(`   ${console_chars_1.emoji.file} ${fileUploads.length} file upload components`);
+        console.log(`   ${console_chars_1.emoji.link} ${webSockets.length} WebSocket connections`);
+        console.log(`   ${console_chars_1.emoji.database} ${storageUsage.length} storage usage (local/session)`);
+        console.log(`   ${console_chars_1.emoji.folder} ${structuralGaps.length} pages without test files`);
+    }
+    // Phase 2: Analyze test coverage
+    console.log(`\n${console_chars_1.emoji.search} Analyzing Playwright test coverage...`);
+    const coverageMap = await analyzeTestCoverage();
+    const aggregated = aggregateCoverage(coverageMap);
+    if (isVerbose) {
+        console.log(`\n${console_chars_1.emoji.chart} Test coverage found:`);
+        console.log(`   ${console_chars_1.emoji.check} ${aggregated.allEndpoints.size} endpoints referenced`);
+        console.log(`   ${console_chars_1.emoji.check} ${aggregated.allMockedApis.size} APIs mocked`);
+        console.log(`   ${console_chars_1.emoji.check} ${aggregated.allInteractions.size} unique interactions`);
+        console.log(`   ${console_chars_1.emoji.check} ${aggregated.allActions.size} actions referenced`);
+        console.log(`   ${console_chars_1.emoji.check} ${aggregated.allTestIds.size} test IDs used`);
+    }
+    // Phase 3: Find ALL gaps
+    console.log(`\n${console_chars_1.emoji.magnifier} Comparing implementation vs tests...`);
+    const apiGaps = findApiGaps(apiEndpoints, aggregated.allEndpoints, aggregated.allMockedApis);
+    const actionGaps = findActionGaps(pageActions, aggregated.allActions, aggregated.allInteractions);
+    const formGaps = findFormFieldGaps(formFields, aggregated.allInteractions);
+    const destructiveGaps = findDestructiveActionGaps(criticalButtons, aggregated.allInteractions);
+    const middlewareGaps = findMiddlewareGaps(middleware, aggregated.allEndpoints);
+    const errorBoundaryGaps = findErrorBoundaryGaps(errorBoundaries, aggregated.allEndpoints, aggregated.allInteractions);
+    const fileUploadGaps = findFileUploadGaps(fileUploads, aggregated.allInteractions);
+    const modalGaps = findModalGaps(modalTriggers, aggregated.allInteractions);
+    const testIdGaps = findDataTestIdGaps(dataTestIds, aggregated.allTestIds);
+    const allGaps = [
+        ...apiGaps,
+        ...actionGaps,
+        ...formGaps,
+        ...destructiveGaps,
+        ...structuralGaps,
+        ...middlewareGaps,
+        ...errorBoundaryGaps,
+        ...fileUploadGaps,
+        ...modalGaps,
+        ...testIdGaps,
+    ];
+    const errors = allGaps.filter((g) => g.severity === "error");
+    const warnings = allGaps.filter((g) => g.severity === "warning");
+    // Calculate coverage stats for trend tracking
+    const totalFeatures = apiEndpoints.length +
+        pageActions.length +
+        criticalButtons.length +
+        middleware.length +
+        errorBoundaries.length +
+        fileUploads.length;
+    const coveredFeatures = totalFeatures -
+        (apiGaps.length +
+            actionGaps.length +
+            destructiveGaps.length +
+            middlewareGaps.length +
+            errorBoundaryGaps.length +
+            fileUploadGaps.length);
+    const byCategory = {
+        "api-endpoints": { total: apiEndpoints.length, covered: apiEndpoints.length - apiGaps.length },
+        "server-actions": {
+            total: pageActions.length,
+            covered: pageActions.length - actionGaps.length,
+        },
+        "destructive-actions": {
+            total: criticalButtons.length,
+            covered: criticalButtons.length - destructiveGaps.length,
+        },
+        middleware: { total: middleware.length, covered: middleware.length - middlewareGaps.length },
+        "error-boundaries": {
+            total: errorBoundaries.length,
+            covered: errorBoundaries.length - errorBoundaryGaps.length,
+        },
+        "file-uploads": {
+            total: fileUploads.length,
+            covered: fileUploads.length - fileUploadGaps.length,
+        },
+    };
+    // Save trend data
+    saveTrendData(totalFeatures, coveredFeatures, byCategory);
+    // Report results
+    console.log((0, console_chars_1.createDivider)(60, "light"));
+    if (allGaps.length === 0) {
+        console.log(`\n${console_chars_1.emoji.success} All discovered features have E2E test coverage!`);
+        process.exit(0);
+    }
+    // Group gaps by type for cleaner output
+    const gapsByType = new Map();
+    for (const gap of allGaps) {
+        const type = gap.feature.type;
+        const existing = gapsByType.get(type) || [];
+        existing.push(gap);
+        gapsByType.set(type, existing);
+    }
+    const typeLabels = {
+        "api-endpoint": "API Endpoints",
+        "page-action": "Server Actions",
+        "form-field": "Form Fields",
+        "ui-component": "UI Components",
+        "service-method": "Service Methods",
+        middleware: "Middleware",
+        "error-boundary": "Error Boundaries",
+        "loading-state": "Loading States",
+        "dynamic-route": "Dynamic Routes",
+        "data-testid": "Test IDs",
+        "side-effect": "Side Effects",
+        "modal-trigger": "Modals/Dialogs",
+        "toast-trigger": "Toasts/Notifications",
+        "file-upload": "File Uploads",
+        websocket: "WebSockets",
+        "storage-usage": "Storage Usage",
+        page: "Pages",
+    };
+    if (errors.length > 0) {
+        console.log(`\n${console_chars_1.emoji.error} CRITICAL GAPS (${errors.length}):\n`);
+        for (const [type, gaps] of gapsByType) {
+            const typeErrors = gaps.filter((g) => g.severity === "error");
+            if (typeErrors.length === 0)
+                continue;
+            console.log(`  ${console_chars_1.emoji.folder} ${typeLabels[type] || type}:`);
+            for (const gap of typeErrors.slice(0, 10)) {
+                console.log(`     ${console_chars_1.chars.cross} ${gap.feature.name}`);
+                if (isVerbose) {
+                    console.log(`        File: ${gap.feature.sourcePath}`);
+                    console.log(`        ${gap.reason}`);
+                    if (gap.suggestedTestFile) {
+                        console.log(`        Suggested: ${gap.suggestedTestFile}`);
+                    }
+                }
+            }
+            if (typeErrors.length > 10) {
+                console.log(`     ... and ${typeErrors.length - 10} more`);
+            }
+            console.log("");
+        }
+    }
+    if (warnings.length > 0 && isVerbose) {
+        console.log(`\n${console_chars_1.emoji.warning} WARNINGS (${warnings.length}):\n`);
+        for (const [type, gaps] of gapsByType) {
+            const typeWarnings = gaps.filter((g) => g.severity === "warning");
+            if (typeWarnings.length === 0)
+                continue;
+            console.log(`  ${console_chars_1.emoji.folder} ${typeLabels[type] || type}: ${typeWarnings.length} gaps`);
+            for (const gap of typeWarnings.slice(0, 5)) {
+                console.log(`     ${console_chars_1.emoji.warning} ${gap.feature.name}`);
+            }
+            if (typeWarnings.length > 5) {
+                console.log(`     ... and ${typeWarnings.length - 5} more`);
+            }
+            console.log("");
+        }
+    }
+    // Generate test stubs if requested
+    if (generateStubs) {
+        const gapsWithSuggestions = allGaps.filter((g) => g.suggestedTestFile);
+        const stubsWritten = writeTestStubs(gapsWithSuggestions);
+        console.log(`\n${console_chars_1.emoji.file} Generated ${stubsWritten} test stub(s) in tests/e2e/_generated-stubs/`);
+        console.log(`   Review and move stubs to appropriate locations, then implement tests.`);
+    }
+    // Generate report if requested
+    if (generateReport) {
+        const coveragePercent = totalFeatures > 0 ? Math.round((coveredFeatures / totalFeatures) * 100) : 100;
+        const reportLines = [
+            "# Playwright Coverage Gap Report (Auto-Discovered)",
+            "",
+            `Generated: ${new Date().toISOString()}`,
+            "",
+            "## Summary",
+            "",
+            `- **Total Features Discovered:** ${totalFeatures}`,
+            `- **Features with Coverage:** ${coveredFeatures}`,
+            `- **Coverage Percentage:** ${coveragePercent}%`,
+            "",
+            "### By Category",
+            "",
+            "| Category | Total | Covered | % |",
+            "|----------|-------|---------|---|",
+        ];
+        for (const [cat, stats] of Object.entries(byCategory)) {
+            const pct = stats.total > 0 ? Math.round((stats.covered / stats.total) * 100) : 100;
+            reportLines.push(`| ${cat} | ${stats.total} | ${stats.covered} | ${pct}% |`);
+        }
+        reportLines.push("");
+        reportLines.push(`- **Critical Gaps:** ${errors.length}`);
+        reportLines.push(`- **Warnings:** ${warnings.length}`);
+        reportLines.push("");
+        reportLines.push("## Critical Gaps");
+        reportLines.push("");
+        for (const gap of errors) {
+            reportLines.push(`### ${gap.feature.name}`);
+            reportLines.push(`- **Type:** ${gap.feature.type}`);
+            reportLines.push(`- **File:** \`${gap.feature.sourcePath}\``);
+            reportLines.push(`- **Issue:** ${gap.reason}`);
+            if (gap.suggestedTestFile) {
+                reportLines.push(`- **Suggested Test:** \`${gap.suggestedTestFile}\``);
+            }
+            reportLines.push("");
+        }
+        if (warnings.length > 0) {
+            reportLines.push("## Warnings");
+            reportLines.push("");
+            for (const gap of warnings.slice(0, 20)) {
+                reportLines.push(`- **${gap.feature.name}** (${gap.feature.type}): ${gap.reason}`);
+            }
+            if (warnings.length > 20) {
+                reportLines.push(`- ... and ${warnings.length - 20} more warnings`);
+            }
+        }
+        const reportPath = "reports/playwright-coverage-gaps.md";
+        const reportDir = path.dirname(reportPath);
+        if (!fs.existsSync(reportDir)) {
+            fs.mkdirSync(reportDir, { recursive: true });
+        }
+        fs.writeFileSync(reportPath, reportLines.join("\n"));
+        console.log(`\n${console_chars_1.emoji.file} Report written to: ${reportPath}`);
+    }
+    // Summary
+    console.log((0, console_chars_1.createDivider)(60, "heavy"));
+    const coveragePercent = totalFeatures > 0 ? Math.round((coveredFeatures / totalFeatures) * 100) : 100;
+    console.log(`\n${console_chars_1.emoji.chart} Coverage: ${coveragePercent}% (${coveredFeatures}/${totalFeatures} features)`);
+    if (errors.length > 0) {
+        if (warnOnly) {
+            console.log(`\n${console_chars_1.emoji.warning} ${errors.length} critical gap(s), ${warnings.length} warning(s) (--warn mode, not blocking)`);
+            console.log(`\nRun with --verbose for details, --report for markdown, --generate-stubs for test templates, --trend for history\n`);
+            process.exit(0);
+        }
+        console.log(`\n${console_chars_1.emoji.error} FAILED: ${errors.length} critical gap(s), ${warnings.length} warning(s)`);
+        console.log(`\nRun with --verbose for details, --report for markdown, --generate-stubs for test templates, --trend for history\n`);
+        process.exit(1);
+    }
+    console.log(`\n${console_chars_1.emoji.success} PASSED with ${warnings.length} warning(s)`);
+    process.exit(0);
+}
+// Allow direct execution
+if (require.main === module) {
+    run().catch(console.error);
+}
+//# sourceMappingURL=playwright-feature-coverage-gaps.js.map