@yasserkhanorg/e2e-agents 0.5.16 → 0.6.0

package/dist/agent/runner.js

@@ -1,898 +0,0 @@
-"use strict";
-// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
-// See LICENSE.txt for license information.
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.runImpact = runImpact;
-exports.runGap = runGap;
-const fs_1 = require("fs");
-const path_1 = require("path");
-const analysis_js_1 = require("./analysis.js");
-const blast_radius_js_1 = require("./blast_radius.js");
-const framework_js_1 = require("./framework.js");
-const git_js_1 = require("./git.js");
-const report_js_1 = require("./report.js");
-const flags_js_1 = require("./flags.js");
-const selectors_js_1 = require("./selectors.js");
-const tests_js_1 = require("./tests.js");
-const generator_js_1 = require("./generator.js");
-const flow_catalog_js_1 = require("./flow_catalog.js");
-const flow_mapping_js_1 = require("./flow_mapping.js");
-const pipeline_js_1 = require("./pipeline.js");
-const gap_suggestions_js_1 = require("./gap_suggestions.js");
-const dependency_graph_js_1 = require("./dependency_graph.js");
-const traceability_js_1 = require("./traceability.js");
-const utils_js_1 = require("./utils.js");
-const ai_mapping_js_1 = require("./ai_mapping.js");
-const ai_flow_analysis_js_1 = require("./ai_flow_analysis.js");
-const PRIORITY_RANK = {
-    P0: 0,
-    P1: 1,
-    P2: 2,
-};
-function ensureAppRoot(path) {
-    if (!(0, fs_1.existsSync)(path)) {
-        throw new Error(`App path does not exist: ${path}`);
-    }
-}
-function computeGaps(flows, coverageMap, coverage) {
-    const coverageByFlowId = new Map((coverage || []).map((c) => [c.flowId, c]));
-    return flows
-        .filter((flow) => {
-        if (flow.priority !== 'P0' && flow.priority !== 'P1') {
-            return false;
-        }
-        const coveredBy = coverageMap.get(flow.id) || [];
-        if (coveredBy.length === 0) {
-            return true; // no tests at all
-        }
-        // Flows with 3+ mapped tests are considered comprehensively covered — the AI
-        // maps 3 tests only when each has specific behavioral evidence for the flow.
-        // missingScenarios from the AI are informational for such flows, not blocking.
-        if (coveredBy.length >= 3) {
-            return false;
-        }
-        // For flows with 1-3 tests, flag as a gap if AI identified missing scenarios.
-        const flowCoverage = coverageByFlowId.get(flow.id);
-        return (flowCoverage?.missingScenarios || []).length > 0;
-    })
-        .map((flow) => {
-        const coveredBy = coverageMap.get(flow.id) || [];
-        const flowCoverage = coverageByFlowId.get(flow.id);
-        return {
-            ...flow,
-            existingTests: coveredBy.length > 0 ? coveredBy : undefined,
-            missingScenarios: flowCoverage?.missingScenarios?.length ? flowCoverage.missingScenarios : undefined,
-        };
-    });
-}
-function normalizeChangedFiles(appRoot, files) {
-    const normalizedRoot = appRoot.replace(/\\/g, '/').replace(/\/+$/, '');
-    const baseName = normalizedRoot.split('/').pop() || '';
-    return files
-        .map((file) => file.replace(/\\/g, '/'))
-        .map((file) => {
-        if (baseName && file.startsWith(`${baseName}/`)) {
-            return file.slice(baseName.length + 1);
-        }
-        return file;
-    });
-}
-function sortFlows(flows) {
-    const priorityRank = { P0: 0, P1: 1, P2: 2 };
-    return [...flows].sort((a, b) => {
-        const rankDiff = (priorityRank[a.priority] ?? 3) - (priorityRank[b.priority] ?? 3);
-        if (rankDiff !== 0) {
-            return rankDiff;
-        }
-        return b.score - a.score;
-    });
-}
-function applyPriorityThresholds(flows, config) {
-    return flows.map((flow) => {
-        const priority = flow.score >= config.risk.p0Threshold
-            ? 'P0'
-            : flow.score >= config.risk.p1Threshold
-                ? 'P1'
-                : 'P2';
-        const boundedPriority = flow.priorityFloor && PRIORITY_RANK[flow.priorityFloor] < PRIORITY_RANK[priority]
-            ? flow.priorityFloor
-            : priority;
-        return { ...flow, priority: boundedPriority };
-    });
-}
-function buildRecommendedTestsWithFlags(flows, testsByFlow) {
-    const testNotes = new Map();
-    for (const flow of flows) {
-        if (flow.priority !== 'P0' && flow.priority !== 'P1') {
-            continue;
-        }
-        const tests = testsByFlow.get(flow.id) || [];
-        const flagSummary = (0, flags_js_1.formatFlags)(flow.flags || []);
-        for (const test of tests) {
-            const normalizedTest = (0, utils_js_1.normalizePath)(test)
-                .replace(/^\.\//, '')
-                .replace(/^e2e-tests\/playwright\//, '');
-            if (!testNotes.has(normalizedTest)) {
-                testNotes.set(normalizedTest, new Set());
-            }
-            if (flagSummary !== 'none') {
-                testNotes.get(normalizedTest)?.add(flagSummary);
-            }
-        }
-    }
-    return Array.from(testNotes.entries())
-        .map(([test, notes]) => {
-        if (notes.size === 0) {
-            return test;
-        }
-        return `${test} (flags: ${Array.from(notes).join(', ')})`;
-    })
-        .sort();
-}
-function buildRecommendedTestsFromCoverage(flows, coverage) {
-    const flowMap = new Map();
-    for (const flow of flows) {
-        flowMap.set(flow.id, flow);
-    }
-    const testNotes = new Map();
-    for (const entry of coverage) {
-        if (entry.priority !== 'P0' && entry.priority !== 'P1') {
-            continue;
-        }
-        const flow = flowMap.get(entry.flowId);
-        const flagSummary = (0, flags_js_1.formatFlags)(flow?.flags || []);
-        for (const test of entry.coveredBy) {
-            const normalizedTest = (0, utils_js_1.normalizePath)(test)
-                .replace(/^\.\//, '')
-                .replace(/^e2e-tests\/playwright\//, '');
-            if (!testNotes.has(normalizedTest)) {
-                testNotes.set(normalizedTest, new Set());
-            }
-            if (flagSummary !== 'none') {
-                testNotes.get(normalizedTest)?.add(flagSummary);
-            }
-        }
-    }
-    return Array.from(testNotes.entries())
-        .map(([test, notes]) => {
-        if (notes.size === 0) {
-            return test;
-        }
-        return `${test} (flags: ${Array.from(notes).join(', ')})`;
-    })
-        .sort();
-}
-function uniquePaths(paths) {
-    return Array.from(new Set(paths.map((value) => value.replace(/\\/g, '/')).filter(Boolean)));
-}
-function mergeCoverageWithHeuristicFallback(traceability, heuristic) {
-    const byFlow = new Map();
-    for (const entry of traceability) {
-        byFlow.set(entry.flowId, entry);
-    }
-    for (const entry of heuristic) {
-        const existing = byFlow.get(entry.flowId);
-        if (!existing) {
-            byFlow.set(entry.flowId, entry);
-            continue;
-        }
-        if (existing.coveredBy.length === 0 && entry.coveredBy.length > 0) {
-            byFlow.set(entry.flowId, entry);
-        }
-    }
-    return Array.from(byFlow.values());
-}
-function buildMattermostFailClosedWarning(reason) {
-    return `${reason} Mattermost strict mode will emit uncovered flows as must-add-tests without heuristic fallback.`;
-}
-function applyMattermostEvidencePolicy(config, state) {
-    if (config.profile !== 'mattermost') {
-        return {
-            coverage: state.coverage,
-            recommendedTests: state.recommendedTests,
-            testMappingSource: state.testMappingSource,
-        };
-    }
-    if (state.testMappingSource === 'heuristic') {
-        throw new Error('Mattermost profile requires AI or catalog evidence for test selection. Heuristic-only mapping is not allowed.');
-    }
-    if (state.failClosedTargeting) {
-        return {
-            coverage: state.coverage,
-            recommendedTests: state.recommendedTests,
-            testMappingSource: state.testMappingSource,
-        };
-    }
-    if (state.testMappingSource !== 'catalog' && state.testMappingSource !== 'ai' && !state.traceabilityStats?.manifestFound) {
-        throw new Error('Mattermost profile requires traceability evidence or AI mapping. Generate or refresh traceability manifest, or enable impact.aiMapping in config.');
-    }
-    const traceabilityCoverageRatio = state.traceabilityStats?.coverageRatio ?? 0;
-    if (state.testMappingSource === 'traceability' && traceabilityCoverageRatio < 0.6) {
-        throw new Error(`Mattermost profile requires stronger traceability coverage. Current ratio is ${traceabilityCoverageRatio.toFixed(2)}; AI mapping is required to close evidence gaps.`);
-    }
-    const output = {
-        coverage: state.coverage,
-        recommendedTests: state.recommendedTests,
-        testMappingSource: state.testMappingSource,
-    };
-    if (state.testMappingSource === 'ai') {
-        const traceabilityWarningPrefix = 'Traceability manifest not found or invalid:';
-        for (let i = state.warnings.length - 1; i >= 0; i -= 1) {
-            if (state.warnings[i].startsWith(traceabilityWarningPrefix)) {
-                state.warnings.splice(i, 1);
-            }
-        }
-    }
-    return output;
-}
-function classifyImpactModelConfidence(flowMapping, testMapping, dependencyGraph, traceability, warnings) {
-    let score = 0;
-    if (flowMapping === 'catalog') {
-        score += 2;
-    }
-    else if (flowMapping === 'ai') {
-        score += 2;
-    }
-    if (testMapping === 'catalog') {
-        score += 2;
-    }
-    else if (testMapping === 'traceability') {
-        score += 3;
-    }
-    else if (testMapping === 'ai') {
-        score += 2;
-    }
-    if (traceability) {
-        if (!traceability.manifestFound) {
-            score -= 1;
-        }
-        else if (traceability.coverageRatio >= 0.7) {
-            score += 1;
-        }
-        else if (traceability.coverageRatio < 0.4) {
-            score -= 1;
-        }
-    }
-    if (dependencyGraph && dependencyGraph.expandedFiles.length > 0) {
-        score += 1;
-    }
-    if (dependencyGraph && dependencyGraph.truncated) {
-        score -= 1;
-    }
-    if (warnings.length > 0) {
-        score -= 1;
-    }
-    if (score >= 5) {
-        return 'high';
-    }
-    if (score >= 3) {
-        return 'medium';
-    }
-    return 'low';
-}
-function createRunId(mode) {
-    const ciRunId = process.env.GITHUB_RUN_ID;
-    const entropy = Math.random().toString(36).slice(2, 8);
-    const ts = Date.now().toString(36);
-    if (ciRunId) {
-        return `${mode}-gh-${ciRunId}-${ts}-${entropy}`;
-    }
-    return `${mode}-local-${ts}-${entropy}`;
-}
-async function runImpact(_config, _options) {
-    ensureAppRoot(_config.path);
-    if (_config.testsRoot) {
-        ensureAppRoot(_config.testsRoot);
-    }
-    const deadline = Date.now() + _config.timeLimitMinutes * 60 * 1000;
-    const runStartedAt = new Date().toISOString();
-    const runStartedTs = Date.now();
-    const runId = createRunId('impact');
-    const warnings = [];
-    const testsRoot = _config.testsRoot || _config.path;
-    const frameworkDetection = (0, framework_js_1.detectFramework)(testsRoot, _config.framework);
-    const testPatterns = (0, framework_js_1.resolveTestPatterns)(testsRoot, frameworkDetection, _config.testDiscovery.patterns);
-    if (frameworkDetection.framework === 'unknown' && testPatterns.patterns.length === 0) {
-        throw new Error('No framework config found. Provide testDiscovery.patterns in config or --patterns.');
-    }
-    const gitResult = (0, git_js_1.getChangedFiles)(_config.path, _config.git.since, {
-        includeUncommitted: _config.git.includeUncommitted,
-    });
-    const changedFiles = normalizeChangedFiles(_config.path, gitResult.files);
-    if (gitResult.error) {
-        warnings.push(`Git diff failed: ${gitResult.error}`);
-    }
-    if (changedFiles.length === 0 && !_config.impact.allowFallback) {
-        throw new Error('No changed files detected. Provide --since or use gap mode (or --allow-fallback).');
-    }
-    const changedAppFiles = changedFiles.filter((file) => !(0, analysis_js_1.isTestFilePath)(file));
-    let analysisTargets = [...changedAppFiles];
-    if (analysisTargets.length === 0 && _config.impact.allowFallback) {
-        warnings.push('No changed files detected. Falling back to repository scan for screens.');
-        analysisTargets = (0, analysis_js_1.scanRepositoryFlows)(_config.path, 250, _config.flowDiscovery.patterns, _config.flowDiscovery.exclude);
-    }
-    let dependencyGraph;
-    if (analysisTargets.length > 0 && _config.impact.dependencyGraph.enabled) {
-        dependencyGraph = (0, dependency_graph_js_1.expandByDependencyGraph)(_config.path, analysisTargets, _config.impact.dependencyGraph);
-        warnings.push(...dependencyGraph.warnings);
-        if (dependencyGraph.expandedFiles.length > 0) {
-            analysisTargets = uniquePaths([...analysisTargets, ...dependencyGraph.expandedFiles]);
-        }
-    }
-    const analysis = (0, analysis_js_1.analyzeFiles)(_config.path, analysisTargets, _config);
-    warnings.push(...analysis.warnings);
-    if (Date.now() > deadline) {
-        warnings.push('Time limit exceeded after impact analysis. Skipping coverage and selector steps.');
-    }
-    let coverage = [];
-    let gaps = [];
-    let dataTestIds = [];
-    let flows = [];
-    let flowCatalogSource;
-    let recommendedTests = [];
-    let testsByFlow;
-    let testSuggestions = [];
-    const catalog = (0, flow_catalog_js_1.loadFlowCatalog)(_config);
-    let flowMappingSource = catalog ? 'catalog' : 'heuristic';
-    let testMappingSource = 'heuristic';
-    let traceabilityStats;
-    let mattermostFailClosedTargeting = false;
-    if (catalog) {
-        flowCatalogSource = catalog.source;
-        const mapping = (0, flow_mapping_js_1.mapChangesToCatalogFlows)(catalog, analysisTargets, 'impact', _config);
-        flows = mapping.flows;
-        testsByFlow = mapping.testsByFlow;
-        warnings.push(...mapping.warnings);
-        if (_config.profile === 'mattermost' && changedAppFiles.length > 0 && flows.length === 0) {
-            throw new Error('Mattermost profile catalog mapping returned no impacted flows. Refresh traceability or AI flow mapping before target selection.');
-        }
-    }
-    else {
-        flows = analysis.flows;
-        if (changedAppFiles.length === 0) {
-            // No app files changed (e.g. only CI config or e2e files changed).
-            // Treat as zero app impact without calling AI — the gate should pass cleanly.
-            flows = [];
-            flowMappingSource = 'ai';
-            warnings.push('No app files changed; skipping AI flow analysis.');
-        }
-        else if (_config.impact.aiFlow.enabled) {
-            const aiFlow = await (0, ai_flow_analysis_js_1.mapAIFlowsFromFiles)(_config.path, testsRoot, _config.impact.aiFlow, analysis.files, changedAppFiles);
-            warnings.push(...aiFlow.warnings);
-            if (aiFlow.used) {
-                flows = aiFlow.flows;
-                flowMappingSource = 'ai';
-            }
-            else if (aiFlow.ran) {
-                // AI ran successfully but found no user-facing flows — treat as zero impact.
-                flows = [];
-                flowMappingSource = 'ai';
-            }
-            else if (_config.impact.aiFlow.strict || _config.profile === 'mattermost') {
-                throw new Error('AI flow analysis is required but unavailable. Check Anthropic/LLM provider configuration.');
-            }
-        }
-    }
-    if (_config.profile === 'mattermost' && flowMappingSource === 'heuristic') {
-        throw new Error('Mattermost profile requires AI or catalog flow mapping; heuristic flow mapping is disabled.');
-    }
-    flows = (0, blast_radius_js_1.applyBlastRadius)(flows, analysis.files, _config);
-    if (flowMappingSource === 'heuristic') {
-        flows = applyPriorityThresholds(flows, _config);
-    }
-    if (Date.now() <= deadline) {
-        if (catalog && testsByFlow) {
-            coverage = (0, tests_js_1.mapCatalogTestsToFlows)(flows, testsRoot, testsByFlow);
-            testMappingSource = 'catalog';
-            const coverageMap = new Map();
-            for (const entry of coverage) {
-                coverageMap.set(entry.flowId, entry.coveredBy);
-            }
-            gaps = computeGaps(flows, coverageMap);
-            recommendedTests = buildRecommendedTestsFromCoverage(flows, coverage);
-        }
-        else {
-            const traceability = (0, traceability_js_1.mapTraceabilityToFlows)(testsRoot, _config.impact.traceability, flows);
-            warnings.push(...traceability.warnings);
-            traceabilityStats = traceability.stats;
-            if (traceability.stats.manifestFound && traceability.stats.matchedFlows > 0) {
-                coverage = traceability.coverage;
-                testMappingSource = 'traceability';
-                if (traceability.stats.coverageRatio < 0.8) {
-                    const tests = (0, tests_js_1.discoverTests)(testsRoot, testPatterns.patterns);
-                    if (_config.impact.aiMapping.enabled) {
-                        const aiMapping = await (0, ai_mapping_js_1.mapAITestsToFlows)(_config.path, testsRoot, _config.impact.aiMapping, flows, tests);
-                        warnings.push(...aiMapping.warnings);
-                        if (aiMapping.used) {
-                            coverage = mergeCoverageWithHeuristicFallback(coverage, aiMapping.coverage);
-                            testMappingSource = 'ai';
-                        }
-                        else if (_config.profile === 'mattermost') {
-                            warnings.push(buildMattermostFailClosedWarning('Mattermost profile requires AI mapping when traceability coverage is incomplete, but AI mapping did not produce target tests.'));
-                            testMappingSource = 'ai';
-                            mattermostFailClosedTargeting = true;
-                        }
-                        else {
-                            const heuristicCoverage = (0, tests_js_1.mapTestsToFlows)(flows, tests);
-                            coverage = mergeCoverageWithHeuristicFallback(coverage, heuristicCoverage);
-                            warnings.push('Applied heuristic fallback for flows not covered by traceability mapping.');
-                        }
-                    }
-                    else if (_config.profile === 'mattermost') {
-                        warnings.push(buildMattermostFailClosedWarning('Mattermost profile requires AI mapping when traceability coverage is incomplete, but AI mapping is disabled.'));
-                        mattermostFailClosedTargeting = true;
-                    }
-                    else {
-                        const tests = (0, tests_js_1.discoverTests)(testsRoot, testPatterns.patterns);
-                        const heuristicCoverage = (0, tests_js_1.mapTestsToFlows)(flows, tests);
-                        coverage = mergeCoverageWithHeuristicFallback(coverage, heuristicCoverage);
-                        warnings.push('Applied heuristic fallback for flows not covered by traceability mapping.');
-                    }
-                }
-            }
-            else {
-                const tests = (0, tests_js_1.discoverTests)(testsRoot, testPatterns.patterns);
-                if (_config.impact.aiMapping.enabled) {
-                    const aiMapping = await (0, ai_mapping_js_1.mapAITestsToFlows)(_config.path, testsRoot, _config.impact.aiMapping, flows, tests);
-                    warnings.push(...aiMapping.warnings);
-                    if (aiMapping.used) {
-                        coverage = aiMapping.coverage;
-                        testMappingSource = 'ai';
-                    }
-                    else if (_config.profile === 'mattermost') {
-                        warnings.push(buildMattermostFailClosedWarning('Mattermost profile requires AI mapping because traceability evidence did not produce target tests, but AI mapping returned no valid matches.'));
-                        testMappingSource = 'ai';
-                        mattermostFailClosedTargeting = true;
-                    }
-                    else {
-                        coverage = (0, tests_js_1.mapTestsToFlows)(flows, tests);
-                    }
-                }
-                else if (_config.profile === 'mattermost') {
-                    warnings.push(buildMattermostFailClosedWarning('Mattermost profile requires traceability evidence or AI mapping to produce target tests, but AI mapping is disabled.'));
-                    testMappingSource = 'traceability';
-                    mattermostFailClosedTargeting = true;
-                }
-                else {
-                    coverage = (0, tests_js_1.mapTestsToFlows)(flows, tests);
-                }
-            }
-            const coverageMap = new Map();
-            for (const entry of coverage) {
-                coverageMap.set(entry.flowId, entry.coveredBy);
-            }
-            gaps = computeGaps(flows, coverageMap);
-            recommendedTests = buildRecommendedTestsFromCoverage(flows, coverage);
-        }
-    }
-    const mattermostAdjusted = applyMattermostEvidencePolicy(_config, {
-        warnings,
-        flows,
-        coverage,
-        recommendedTests,
-        testMappingSource,
-        traceabilityStats,
-        failClosedTargeting: mattermostFailClosedTargeting,
-    });
-    coverage = mattermostAdjusted.coverage;
-    recommendedTests = mattermostAdjusted.recommendedTests;
-    testMappingSource = mattermostAdjusted.testMappingSource;
-    if (Date.now() <= deadline) {
-        const coverageMap = new Map();
-        for (const entry of coverage) {
-            coverageMap.set(entry.flowId, entry.coveredBy);
-        }
-        // Pass the full coverage array so partial gaps (tests exist but missing scenarios) are included.
-        gaps = computeGaps(flows, coverageMap, coverage);
-    }
-    if (Date.now() <= deadline) {
-        testSuggestions = (0, gap_suggestions_js_1.buildGapTestSuggestions)(testsRoot, gaps, frameworkDetection.framework, testPatterns.patterns);
-    }
-    if (Date.now() <= deadline) {
-        dataTestIds = analysis.files
-            .filter((file) => file.isUI && file.content)
-            .flatMap((file) => (0, selectors_js_1.findDataTestIdSuggestions)(file.relativePath, file.content, file.flowId));
-    }
-    if (_config.specPDF) {
-        warnings.push('Spec PDF provided but parsing is not implemented in v1.');
-    }
-    const applied = _options.apply && Date.now() <= deadline
-        ? applyChanges(_config, analysis.files, dataTestIds, gaps, frameworkDetection.framework, testPatterns.patterns)
-        : undefined;
-    let pipelineSummary;
-    if (_config.pipeline.enabled && frameworkDetection.framework === 'playwright' && gaps.length > 0) {
-        pipelineSummary = (0, pipeline_js_1.runPlaywrightPipeline)(testsRoot, gaps, _config.pipeline);
-        if (pipelineSummary.warnings.length > 0) {
-            warnings.push(...pipelineSummary.warnings);
-        }
-    }
-    const reportRoot = testsRoot;
-    const report = (0, report_js_1.writeReport)(reportRoot, _config, {
-        mode: 'impact',
-        runMetadata: {
-            runId,
-            startedAt: runStartedAt,
-            completedAt: new Date().toISOString(),
-            durationMs: Date.now() - runStartedTs,
-            sinceRef: _config.git.since,
-            appPath: _config.path,
-            testsRoot,
-        },
-        changedFiles,
-        flows: sortFlows(flows),
-        coverage,
-        gaps,
-        dataTestIds,
-        framework: frameworkDetection.framework,
-        testPatterns: testPatterns.patterns,
-        specPDF: _config.specPDF,
-        warnings,
-        flowCatalog: flowCatalogSource,
-        recommendedTests,
-        impactModel: {
-            schemaVersion: '1.0.0',
-            flowMapping: flowMappingSource,
-            testMapping: testMappingSource,
-            confidenceClass: classifyImpactModelConfidence(flowMappingSource, testMappingSource, dependencyGraph, traceabilityStats, warnings),
-            traceability: traceabilityStats,
-            dependencyGraph: dependencyGraph
-                ? {
-                    source: dependencyGraph.source,
-                    enabled: _config.impact.dependencyGraph.enabled,
-                    seedFiles: dependencyGraph.seedFiles.length,
-                    expandedFiles: dependencyGraph.expandedFiles.length,
-                    analyzedFiles: dependencyGraph.analyzedFiles,
-                    analyzedEdges: dependencyGraph.analyzedEdges,
-                    maxDepth: dependencyGraph.maxDepth,
-                    truncated: dependencyGraph.truncated,
-                }
-                : undefined,
-            subsystemRisk: analysis.subsystemRisk.enabled ? analysis.subsystemRisk : undefined,
-        },
-        testSuggestions,
-        pipeline: pipelineSummary,
-        applied,
-    });
-    // eslint-disable-next-line no-console
-    console.log(`Impact report: ${report.markdownPath}`);
-    // eslint-disable-next-line no-console
-    console.log(`Impact data: ${report.jsonPath}`);
-}
-async function runGap(_config, _options) {
-    ensureAppRoot(_config.path);
-    if (_config.testsRoot) {
-        ensureAppRoot(_config.testsRoot);
-    }
-    const deadline = Date.now() + _config.timeLimitMinutes * 60 * 1000;
-    const runStartedAt = new Date().toISOString();
-    const runStartedTs = Date.now();
-    const runId = createRunId('gap');
-    const warnings = [];
-    const testsRoot = _config.testsRoot || _config.path;
-    const frameworkDetection = (0, framework_js_1.detectFramework)(testsRoot, _config.framework);
-    const testPatterns = (0, framework_js_1.resolveTestPatterns)(testsRoot, frameworkDetection, _config.testDiscovery.patterns);
-    if (frameworkDetection.framework === 'unknown' && testPatterns.patterns.length === 0) {
-        throw new Error('No framework config found. Provide testDiscovery.patterns in config or --patterns.');
-    }
-    const gitResult = (0, git_js_1.getChangedFiles)(_config.path, _config.git.since, {
-        includeUncommitted: _config.git.includeUncommitted,
-    });
-    const changedFiles = normalizeChangedFiles(_config.path, gitResult.files);
-    if (gitResult.error) {
-        warnings.push(`Git diff failed: ${gitResult.error}`);
-    }
-    const changedAppFiles = changedFiles.filter((file) => !(0, analysis_js_1.isTestFilePath)(file));
-    let analysisTargets = [...changedAppFiles];
-    if (analysisTargets.length === 0) {
-        analysisTargets = (0, analysis_js_1.scanRepositoryFlows)(_config.path, 250, _config.flowDiscovery.patterns, _config.flowDiscovery.exclude);
-    }
-    if (analysisTargets.length === 0) {
-        warnings.push('No flow candidates found. Ensure pages/screens exist or provide changed files.');
-    }
-    let dependencyGraph;
-    if (analysisTargets.length > 0 && _config.impact.dependencyGraph.enabled) {
-        dependencyGraph = (0, dependency_graph_js_1.expandByDependencyGraph)(_config.path, analysisTargets, _config.impact.dependencyGraph);
-        warnings.push(...dependencyGraph.warnings);
-        if (dependencyGraph.expandedFiles.length > 0) {
-            analysisTargets = uniquePaths([...analysisTargets, ...dependencyGraph.expandedFiles]);
-        }
-    }
-    const analysis = (0, analysis_js_1.analyzeFiles)(_config.path, analysisTargets, _config);
-    warnings.push(...analysis.warnings);
-    if (Date.now() > deadline) {
-        warnings.push('Time limit exceeded after gap analysis. Skipping coverage and selector steps.');
-    }
-    let coverage = [];
-    let gaps = [];
-    let dataTestIds = [];
-    let flows = [];
-    let flowCatalogSource;
-    let recommendedTests = [];
-    let testsByFlow;
-    let testSuggestions = [];
-    const catalog = (0, flow_catalog_js_1.loadFlowCatalog)(_config);
-    let flowMappingSource = catalog ? 'catalog' : 'heuristic';
-    let testMappingSource = 'heuristic';
-    let traceabilityStats;
-    let mattermostFailClosedTargeting = false;
-    if (catalog) {
-        flowCatalogSource = catalog.source;
-        const catalogMode = changedAppFiles.length > 0 ? 'impact' : 'gap';
-        let mapping = (0, flow_mapping_js_1.mapChangesToCatalogFlows)(catalog, analysisTargets, catalogMode, _config);
-        if (catalogMode === 'impact' && mapping.flows.length === 0 && _config.impact.allowFallback) {
-            const fallbackMapping = (0, flow_mapping_js_1.mapChangesToCatalogFlows)(catalog, analysisTargets, 'gap', _config);
-            mapping = {
-                flows: fallbackMapping.flows,
-                testsByFlow: fallbackMapping.testsByFlow,
-                warnings: [
-                    ...mapping.warnings,
-                    ...fallbackMapping.warnings,
-                    'No catalog flow matched changed files; applied full-catalog fallback because allowFallback=true.',
-                ],
-            };
-        }
-        flows = mapping.flows;
-        testsByFlow = mapping.testsByFlow;
-        warnings.push(...mapping.warnings);
-        if (_config.profile === 'mattermost' && changedAppFiles.length > 0 && flows.length === 0) {
-            throw new Error('Mattermost profile catalog mapping returned no impacted flows. Refresh traceability or AI flow mapping before target selection.');
-        }
-    }
-    else {
-        flows = analysis.flows;
-        if (changedAppFiles.length === 0) {
-            // No app files changed (e.g. only CI config or e2e files changed).
-            // Treat as zero app impact without calling AI — the gate should pass cleanly.
-            flows = [];
-            flowMappingSource = 'ai';
-            warnings.push('No app files changed; skipping AI flow analysis.');
-        }
-        else if (_config.impact.aiFlow.enabled) {
-            const aiFlow = await (0, ai_flow_analysis_js_1.mapAIFlowsFromFiles)(_config.path, testsRoot, _config.impact.aiFlow, analysis.files, changedAppFiles);
-            warnings.push(...aiFlow.warnings);
-            if (aiFlow.used) {
-                flows = aiFlow.flows;
-                flowMappingSource = 'ai';
-            }
-            else if (aiFlow.ran) {
-                // AI ran successfully but found no user-facing flows — treat as zero impact.
-                flows = [];
-                flowMappingSource = 'ai';
-            }
-            else if (_config.impact.aiFlow.strict || _config.profile === 'mattermost') {
-                throw new Error('AI flow analysis is required but unavailable. Check Anthropic/LLM provider configuration.');
-            }
-        }
-    }
-    if (_config.profile === 'mattermost' && flowMappingSource === 'heuristic') {
-        throw new Error('Mattermost profile requires AI or catalog flow mapping; heuristic flow mapping is disabled.');
-    }
-    flows = (0, blast_radius_js_1.applyBlastRadius)(flows, analysis.files, _config);
-    if (flowMappingSource === 'heuristic') {
-        flows = applyPriorityThresholds(flows, _config);
-    }
-    if (Date.now() <= deadline) {
-        if (catalog && testsByFlow) {
-            coverage = (0, tests_js_1.mapCatalogTestsToFlows)(flows, testsRoot, testsByFlow);
-            testMappingSource = 'catalog';
-            const coverageMap = new Map();
-            for (const entry of coverage) {
-                coverageMap.set(entry.flowId, entry.coveredBy);
-            }
-            gaps = computeGaps(flows, coverageMap);
-            recommendedTests = buildRecommendedTestsFromCoverage(flows, coverage);
-        }
-        else {
-            const traceability = (0, traceability_js_1.mapTraceabilityToFlows)(testsRoot, _config.impact.traceability, flows);
-            warnings.push(...traceability.warnings);
-            traceabilityStats = traceability.stats;
-            if (traceability.stats.manifestFound && traceability.stats.matchedFlows > 0) {
-                coverage = traceability.coverage;
-                testMappingSource = 'traceability';
-                if (traceability.stats.coverageRatio < 0.8) {
-                    const tests = (0, tests_js_1.discoverTests)(testsRoot, testPatterns.patterns);
-                    if (_config.impact.aiMapping.enabled) {
-                        const aiMapping = await (0, ai_mapping_js_1.mapAITestsToFlows)(_config.path, testsRoot, _config.impact.aiMapping, flows, tests);
-                        warnings.push(...aiMapping.warnings);
-                        if (aiMapping.used) {
-                            coverage = mergeCoverageWithHeuristicFallback(coverage, aiMapping.coverage);
-                            testMappingSource = 'ai';
-                        }
-                        else if (_config.profile === 'mattermost') {
-                            warnings.push(buildMattermostFailClosedWarning('Mattermost profile requires AI mapping when traceability coverage is incomplete, but AI mapping did not produce target tests.'));
-                            testMappingSource = 'ai';
-                            mattermostFailClosedTargeting = true;
-                        }
-                        else {
-                            const heuristicCoverage = (0, tests_js_1.mapTestsToFlows)(flows, tests);
-                            coverage = mergeCoverageWithHeuristicFallback(coverage, heuristicCoverage);
-                            warnings.push('Applied heuristic fallback for flows not covered by traceability mapping.');
-                        }
-                    }
-                    else if (_config.profile === 'mattermost') {
-                        warnings.push(buildMattermostFailClosedWarning('Mattermost profile requires AI mapping when traceability coverage is incomplete, but AI mapping is disabled.'));
-                        mattermostFailClosedTargeting = true;
-                    }
-                    else {
-                        const tests = (0, tests_js_1.discoverTests)(testsRoot, testPatterns.patterns);
-                        const heuristicCoverage = (0, tests_js_1.mapTestsToFlows)(flows, tests);
-                        coverage = mergeCoverageWithHeuristicFallback(coverage, heuristicCoverage);
-                        warnings.push('Applied heuristic fallback for flows not covered by traceability mapping.');
-                    }
-                }
-            }
-            else {
-                const tests = (0, tests_js_1.discoverTests)(testsRoot, testPatterns.patterns);
-                if (_config.impact.aiMapping.enabled) {
-                    const aiMapping = await (0, ai_mapping_js_1.mapAITestsToFlows)(_config.path, testsRoot, _config.impact.aiMapping, flows, tests);
-                    warnings.push(...aiMapping.warnings);
-                    if (aiMapping.used) {
-                        coverage = aiMapping.coverage;
-                        testMappingSource = 'ai';
-                    }
-                    else if (_config.profile === 'mattermost') {
-                        warnings.push(buildMattermostFailClosedWarning('Mattermost profile requires AI mapping because traceability evidence did not produce target tests, but AI mapping returned no valid matches.'));
-                        testMappingSource = 'ai';
-                        mattermostFailClosedTargeting = true;
-                    }
-                    else {
-                        coverage = (0, tests_js_1.mapTestsToFlows)(flows, tests);
-                    }
-                }
-                else if (_config.profile === 'mattermost') {
-                    warnings.push(buildMattermostFailClosedWarning('Mattermost profile requires traceability evidence or AI mapping to produce target tests, but AI mapping is disabled.'));
-                    testMappingSource = 'traceability';
-                    mattermostFailClosedTargeting = true;
-                }
-                else {
-                    coverage = (0, tests_js_1.mapTestsToFlows)(flows, tests);
-                }
-            }
-            const coverageMap = new Map();
-            for (const entry of coverage) {
-                coverageMap.set(entry.flowId, entry.coveredBy);
-            }
-            gaps = computeGaps(flows, coverageMap);
-            recommendedTests = buildRecommendedTestsFromCoverage(flows, coverage);
-        }
-    }
-    const mattermostAdjusted = applyMattermostEvidencePolicy(_config, {
-        warnings,
-        flows,
-        coverage,
-        recommendedTests,
-        testMappingSource,
-        traceabilityStats,
-        failClosedTargeting: mattermostFailClosedTargeting,
-    });
-    coverage = mattermostAdjusted.coverage;
-    recommendedTests = mattermostAdjusted.recommendedTests;
-    testMappingSource = mattermostAdjusted.testMappingSource;
-    if (Date.now() <= deadline) {
-        const coverageMap = new Map();
-        for (const entry of coverage) {
-            coverageMap.set(entry.flowId, entry.coveredBy);
-        }
-        // Pass the full coverage array so partial gaps (tests exist but missing scenarios) are included.
-        gaps = computeGaps(flows, coverageMap, coverage);
-    }
-    if (Date.now() <= deadline) {
-        testSuggestions = (0, gap_suggestions_js_1.buildGapTestSuggestions)(testsRoot, gaps, frameworkDetection.framework, testPatterns.patterns);
-    }
-    if (Date.now() <= deadline) {
-        dataTestIds = analysis.files
-            .filter((file) => file.isUI && file.content)
-            .flatMap((file) => (0, selectors_js_1.findDataTestIdSuggestions)(file.relativePath, file.content, file.flowId));
-    }
-    if (_config.specPDF) {
-        warnings.push('Spec PDF provided but parsing is not implemented in v1.');
-    }
-    const applied = _options.apply && Date.now() <= deadline
-        ? applyChanges(_config, analysis.files, dataTestIds, gaps, frameworkDetection.framework, testPatterns.patterns)
-        : undefined;
-    let pipelineSummary;
-    if (_config.pipeline.enabled && frameworkDetection.framework === 'playwright' && gaps.length > 0) {
-        pipelineSummary = (0, pipeline_js_1.runPlaywrightPipeline)(testsRoot, gaps, _config.pipeline);
-        if (pipelineSummary.warnings.length > 0) {
-            warnings.push(...pipelineSummary.warnings);
-        }
-    }
-    const reportRoot = testsRoot;
-    const report = (0, report_js_1.writeReport)(reportRoot, _config, {
-        mode: 'gap',
-        runMetadata: {
-            runId,
-            startedAt: runStartedAt,
-            completedAt: new Date().toISOString(),
-            durationMs: Date.now() - runStartedTs,
-            sinceRef: _config.git.since,
-            appPath: _config.path,
-            testsRoot,
-        },
-        changedFiles,
-        flows: sortFlows(flows),
-        coverage,
-        gaps,
-        dataTestIds,
-        framework: frameworkDetection.framework,
-        testPatterns: testPatterns.patterns,
-        specPDF: _config.specPDF,
-        warnings,
-        flowCatalog: flowCatalogSource,
-        recommendedTests,
-        impactModel: {
-            schemaVersion: '1.0.0',
-            flowMapping: flowMappingSource,
-            testMapping: testMappingSource,
-            confidenceClass: classifyImpactModelConfidence(flowMappingSource, testMappingSource, dependencyGraph, traceabilityStats, warnings),
-            traceability: traceabilityStats,
-            dependencyGraph: dependencyGraph
-                ? {
-                    source: dependencyGraph.source,
-                    enabled: _config.impact.dependencyGraph.enabled,
-                    seedFiles: dependencyGraph.seedFiles.length,
-                    expandedFiles: dependencyGraph.expandedFiles.length,
-                    analyzedFiles: dependencyGraph.analyzedFiles,
-                    analyzedEdges: dependencyGraph.analyzedEdges,
-                    maxDepth: dependencyGraph.maxDepth,
-                    truncated: dependencyGraph.truncated,
-                }
-                : undefined,
-            subsystemRisk: analysis.subsystemRisk.enabled ? analysis.subsystemRisk : undefined,
-        },
-        testSuggestions,
-        pipeline: pipelineSummary,
-        applied,
-    });
-    // eslint-disable-next-line no-console
-    console.log(`Gap report: ${report.markdownPath}`);
-    // eslint-disable-next-line no-console
-    console.log(`Gap data: ${report.jsonPath}`);
-}
-function applyChanges(config, files, dataTestIds, gaps, framework, testPatterns) {
-    const patchedFiles = [];
-    const suggestionsByFile = new Map();
-    for (const suggestion of dataTestIds) {
-        const bucket = suggestionsByFile.get(suggestion.file) || [];
-        bucket.push(suggestion);
-        suggestionsByFile.set(suggestion.file, bucket);
-    }
-    if (config.selectors.patchOnApply) {
-        for (const file of files) {
-            const suggestions = suggestionsByFile.get(file.relativePath);
-            if (!suggestions || !file.content) {
-                continue;
-            }
-            const updated = (0, selectors_js_1.applyDataTestIdSuggestions)(file.content, suggestions);
-            if (updated !== file.content) {
-                const fullPath = (0, path_1.join)(config.path, file.relativePath);
-                (0, fs_1.writeFileSync)(fullPath, updated, 'utf-8');
-                patchedFiles.push(file.relativePath);
-            }
-        }
-    }
-    const fileToFlow = new Map();
-    for (const file of files) {
-        fileToFlow.set(file.relativePath, file.flowId);
-    }
-    const testIdsByFlow = new Map();
-    for (const suggestion of dataTestIds) {
-        const flowId = fileToFlow.get(suggestion.file);
-        if (!flowId) {
-            continue;
-        }
-        const bucket = testIdsByFlow.get(flowId) || [];
-        bucket.push(suggestion.testId);
-        testIdsByFlow.set(flowId, bucket);
-    }
-    let generatedTests = [];
-    let skippedTests = [];
-    if (!config.pipeline.enabled) {
-        const frameworkType = framework === 'playwright' || framework === 'cypress' || framework === 'selenium' ? framework : 'playwright';
-        const testsRoot = config.testsRoot || config.path;
-        const generated = (0, generator_js_1.generateTests)(testsRoot, gaps, frameworkType, testPatterns, testIdsByFlow);
-        generatedTests = generated.filter((entry) => entry.created).map((entry) => entry.path);
-        skippedTests = generated.filter((entry) => !entry.created).map((entry) => entry.path);
-    }
-    return { patchedFiles, generatedTests, skippedTests };
-}