@yasserkhanorg/e2e-agents 0.3.2

package/dist/agent/runner.js

@@ -0,0 +1,576 @@
+"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 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) {
+    return flows.filter((flow) => {
+        if (flow.priority !== 'P0' && flow.priority !== 'P1') {
+            return false;
+        }
+        const coveredBy = coverageMap.get(flow.id) || [];
+        return coveredBy.length === 0;
+    });
+}
+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) {
+            if (!testNotes.has(test)) {
+                testNotes.set(test, new Set());
+            }
+            if (flagSummary !== 'none') {
+                testNotes.get(test)?.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) {
+            if (!testNotes.has(test)) {
+                testNotes.set(test, new Set());
+            }
+            if (flagSummary !== 'none') {
+                testNotes.get(test)?.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 classifyImpactModelConfidence(flowMapping, testMapping, dependencyGraph, traceability, warnings) {
+    let score = 0;
+    if (flowMapping === 'catalog') {
+        score += 2;
+    }
+    if (testMapping === 'catalog') {
+        score += 2;
+    }
+    else if (testMapping === 'traceability') {
+        score += 3;
+    }
+    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';
+}
+async function runImpact(_config, _options) {
+    ensureAppRoot(_config.path);
+    if (_config.testsRoot) {
+        ensureAppRoot(_config.testsRoot);
+    }
+    const deadline = Date.now() + _config.timeLimitMinutes * 60 * 1000;
+    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).');
+    }
+    let analysisTargets = changedFiles.filter((file) => !(0, analysis_js_1.isTestFilePath)(file));
+    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]);
+            warnings.push(`Dependency graph expanded impacted files by ${dependencyGraph.expandedFiles.length} (depth=${dependencyGraph.maxDepth}).`);
+        }
+    }
+    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);
+    const flowMappingSource = catalog ? 'catalog' : 'heuristic';
+    let testMappingSource = 'heuristic';
+    let traceabilityStats;
+    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);
+    }
+    else {
+        flows = analysis.flows;
+    }
+    flows = (0, blast_radius_js_1.applyBlastRadius)(flows, analysis.files, _config);
+    if (!catalog) {
+        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 = buildRecommendedTestsWithFlags(flows, testsByFlow);
+        }
+        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);
+                    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);
+                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);
+        }
+    }
+    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',
+        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 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}`);
+    }
+    let analysisTargets = changedFiles.filter((file) => !(0, analysis_js_1.isTestFilePath)(file));
+    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]);
+            warnings.push(`Dependency graph expanded impacted files by ${dependencyGraph.expandedFiles.length} (depth=${dependencyGraph.maxDepth}).`);
+        }
+    }
+    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);
+    const flowMappingSource = catalog ? 'catalog' : 'heuristic';
+    let testMappingSource = 'heuristic';
+    let traceabilityStats;
+    if (catalog) {
+        flowCatalogSource = catalog.source;
+        const mapping = (0, flow_mapping_js_1.mapChangesToCatalogFlows)(catalog, analysisTargets, 'gap', _config);
+        flows = mapping.flows;
+        testsByFlow = mapping.testsByFlow;
+        warnings.push(...mapping.warnings);
+    }
+    else {
+        flows = analysis.flows;
+    }
+    flows = (0, blast_radius_js_1.applyBlastRadius)(flows, analysis.files, _config);
+    if (!catalog) {
+        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 = buildRecommendedTestsWithFlags(flows, testsByFlow);
+        }
+        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);
+                    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);
+                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);
+        }
+    }
+    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',
+        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 };
+}

package/dist/agent/selectors.d.ts

@@ -0,0 +1,10 @@
+export interface DataTestIdSuggestion {
+    file: string;
+    line: number;
+    tag: string;
+    testId: string;
+    snippet: string;
+}
+export declare function findDataTestIdSuggestions(relativePath: string, content: string | null, flowId: string): DataTestIdSuggestion[];
+export declare function applyDataTestIdSuggestions(content: string, suggestions: DataTestIdSuggestion[]): string;
+//# sourceMappingURL=selectors.d.ts.map

package/dist/agent/selectors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"selectors.d.ts","sourceRoot":"","sources":["../../src/agent/selectors.ts"],"names":[],"mappings":"AAKA,MAAM,WAAW,oBAAoB;IACjC,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;CACnB;AAKD,wBAAgB,yBAAyB,CACrC,YAAY,EAAE,MAAM,EACpB,OAAO,EAAE,MAAM,GAAG,IAAI,EACtB,MAAM,EAAE,MAAM,GACf,oBAAoB,EAAE,CA8CxB;AAED,wBAAgB,0BAA0B,CAAC,OAAO,EAAE,MAAM,EAAE,WAAW,EAAE,oBAAoB,EAAE,GAAG,MAAM,CA6BvG"}

package/dist/agent/selectors.js

@@ -0,0 +1,75 @@
+"use strict";
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findDataTestIdSuggestions = findDataTestIdSuggestions;
+exports.applyDataTestIdSuggestions = applyDataTestIdSuggestions;
+const utils_js_1 = require("./utils.js");
+const INTERACTIVE_TAGS = ['button', 'input', 'select', 'textarea', 'form', 'a'];
+const INTERACTIVE_HINT = /(onClick|onSubmit|onChange|type=['"]submit['"]|role=['"]button['"])/;
+function findDataTestIdSuggestions(relativePath, content, flowId) {
+    if (!content) {
+        return [];
+    }
+    const suggestions = [];
+    const lines = content.split('\n');
+    let counter = 1;
+    for (let i = 0; i < lines.length; i += 1) {
+        const line = lines[i];
+        const trimmed = line.trim();
+        if (!trimmed.startsWith('<')) {
+            continue;
+        }
+        if (trimmed.includes('data-testid')) {
+            continue;
+        }
+        const tagMatch = trimmed.match(/^<([a-z][a-z0-9-]*)\b/);
+        if (!tagMatch) {
+            continue;
+        }
+        const tag = tagMatch[1];
+        if (!INTERACTIVE_TAGS.includes(tag)) {
+            continue;
+        }
+        if (!INTERACTIVE_HINT.test(trimmed)) {
+            continue;
+        }
+        const testId = `${flowId}-${tag}-${counter}`;
+        counter += 1;
+        suggestions.push({
+            file: (0, utils_js_1.normalizePath)(relativePath),
+            line: i + 1,
+            tag,
+            testId,
+            snippet: trimmed.slice(0, 200),
+        });
+    }
+    return suggestions;
+}
+function applyDataTestIdSuggestions(content, suggestions) {
+    if (suggestions.length === 0) {
+        return content;
+    }
+    const lines = content.split('\n');
+    const suggestionsByLine = new Map();
+    for (const suggestion of suggestions) {
+        const bucket = suggestionsByLine.get(suggestion.line) || [];
+        bucket.push(suggestion);
+        suggestionsByLine.set(suggestion.line, bucket);
+    }
+    for (const [lineNumber, lineSuggestions] of suggestionsByLine.entries()) {
+        const index = lineNumber - 1;
+        if (index < 0 || index >= lines.length) {
+            continue;
+        }
+        let line = lines[index];
+        for (const suggestion of lineSuggestions) {
+            const pattern = new RegExp(`<${suggestion.tag}(\\s|>)`);
+            if (pattern.test(line) && !line.includes('data-testid')) {
+                line = line.replace(pattern, `<${suggestion.tag} data-testid="${suggestion.testId}"$1`);
+            }
+        }
+        lines[index] = line;
+    }
+    return lines.join('\n');
+}