@yasserkhanorg/e2e-agents 0.3.2

package/dist/esm/agent/runner.js

@@ -0,0 +1,572 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+import { existsSync, writeFileSync } from 'fs';
+import { join } from 'path';
+import { analyzeFiles, isTestFilePath, scanRepositoryFlows } from './analysis.js';
+import { applyBlastRadius } from './blast_radius.js';
+import { detectFramework, resolveTestPatterns } from './framework.js';
+import { getChangedFiles } from './git.js';
+import { writeReport } from './report.js';
+import { formatFlags } from './flags.js';
+import { applyDataTestIdSuggestions, findDataTestIdSuggestions } from './selectors.js';
+import { discoverTests, mapCatalogTestsToFlows, mapTestsToFlows } from './tests.js';
+import { generateTests } from './generator.js';
+import { loadFlowCatalog } from './flow_catalog.js';
+import { mapChangesToCatalogFlows } from './flow_mapping.js';
+import { runPlaywrightPipeline } from './pipeline.js';
+import { buildGapTestSuggestions } from './gap_suggestions.js';
+import { expandByDependencyGraph } from './dependency_graph.js';
+import { mapTraceabilityToFlows } from './traceability.js';
+const PRIORITY_RANK = {
+    P0: 0,
+    P1: 1,
+    P2: 2,
+};
+function ensureAppRoot(path) {
+    if (!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 = 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 = 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';
+}
+export 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 = detectFramework(testsRoot, _config.framework);
+    const testPatterns = 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 = 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) => !isTestFilePath(file));
+    if (analysisTargets.length === 0 && _config.impact.allowFallback) {
+        warnings.push('No changed files detected. Falling back to repository scan for screens.');
+        analysisTargets = scanRepositoryFlows(_config.path, 250, _config.flowDiscovery.patterns, _config.flowDiscovery.exclude);
+    }
+    let dependencyGraph;
+    if (analysisTargets.length > 0 && _config.impact.dependencyGraph.enabled) {
+        dependencyGraph = 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 = 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 = loadFlowCatalog(_config);
+    const flowMappingSource = catalog ? 'catalog' : 'heuristic';
+    let testMappingSource = 'heuristic';
+    let traceabilityStats;
+    if (catalog) {
+        flowCatalogSource = catalog.source;
+        const mapping = mapChangesToCatalogFlows(catalog, analysisTargets, 'impact', _config);
+        flows = mapping.flows;
+        testsByFlow = mapping.testsByFlow;
+        warnings.push(...mapping.warnings);
+    }
+    else {
+        flows = analysis.flows;
+    }
+    flows = applyBlastRadius(flows, analysis.files, _config);
+    if (!catalog) {
+        flows = applyPriorityThresholds(flows, _config);
+    }
+    if (Date.now() <= deadline) {
+        if (catalog && testsByFlow) {
+            coverage = 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 = 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 = discoverTests(testsRoot, testPatterns.patterns);
+                    const heuristicCoverage = mapTestsToFlows(flows, tests);
+                    coverage = mergeCoverageWithHeuristicFallback(coverage, heuristicCoverage);
+                    warnings.push('Applied heuristic fallback for flows not covered by traceability mapping.');
+                }
+            }
+            else {
+                const tests = discoverTests(testsRoot, testPatterns.patterns);
+                coverage = 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 = buildGapTestSuggestions(testsRoot, gaps, frameworkDetection.framework, testPatterns.patterns);
+    }
+    if (Date.now() <= deadline) {
+        dataTestIds = analysis.files
+            .filter((file) => file.isUI && file.content)
+            .flatMap((file) => 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 = runPlaywrightPipeline(testsRoot, gaps, _config.pipeline);
+        if (pipelineSummary.warnings.length > 0) {
+            warnings.push(...pipelineSummary.warnings);
+        }
+    }
+    const reportRoot = testsRoot;
+    const report = 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}`);
+}
+export 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 = detectFramework(testsRoot, _config.framework);
+    const testPatterns = 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 = 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) => !isTestFilePath(file));
+    if (analysisTargets.length === 0) {
+        analysisTargets = 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 = 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 = 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 = loadFlowCatalog(_config);
+    const flowMappingSource = catalog ? 'catalog' : 'heuristic';
+    let testMappingSource = 'heuristic';
+    let traceabilityStats;
+    if (catalog) {
+        flowCatalogSource = catalog.source;
+        const mapping = mapChangesToCatalogFlows(catalog, analysisTargets, 'gap', _config);
+        flows = mapping.flows;
+        testsByFlow = mapping.testsByFlow;
+        warnings.push(...mapping.warnings);
+    }
+    else {
+        flows = analysis.flows;
+    }
+    flows = applyBlastRadius(flows, analysis.files, _config);
+    if (!catalog) {
+        flows = applyPriorityThresholds(flows, _config);
+    }
+    if (Date.now() <= deadline) {
+        if (catalog && testsByFlow) {
+            coverage = 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 = 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 = discoverTests(testsRoot, testPatterns.patterns);
+                    const heuristicCoverage = mapTestsToFlows(flows, tests);
+                    coverage = mergeCoverageWithHeuristicFallback(coverage, heuristicCoverage);
+                    warnings.push('Applied heuristic fallback for flows not covered by traceability mapping.');
+                }
+            }
+            else {
+                const tests = discoverTests(testsRoot, testPatterns.patterns);
+                coverage = 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 = buildGapTestSuggestions(testsRoot, gaps, frameworkDetection.framework, testPatterns.patterns);
+    }
+    if (Date.now() <= deadline) {
+        dataTestIds = analysis.files
+            .filter((file) => file.isUI && file.content)
+            .flatMap((file) => 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 = runPlaywrightPipeline(testsRoot, gaps, _config.pipeline);
+        if (pipelineSummary.warnings.length > 0) {
+            warnings.push(...pipelineSummary.warnings);
+        }
+    }
+    const reportRoot = testsRoot;
+    const report = 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 = applyDataTestIdSuggestions(file.content, suggestions);
+            if (updated !== file.content) {
+                const fullPath = join(config.path, file.relativePath);
+                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 = 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/esm/agent/selectors.js

@@ -0,0 +1,71 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+import { normalizePath } from './utils.js';
+const INTERACTIVE_TAGS = ['button', 'input', 'select', 'textarea', 'form', 'a'];
+const INTERACTIVE_HINT = /(onClick|onSubmit|onChange|type=['"]submit['"]|role=['"]button['"])/;
+export 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: normalizePath(relativePath),
+            line: i + 1,
+            tag,
+            testId,
+            snippet: trimmed.slice(0, 200),
+        });
+    }
+    return suggestions;
+}
+export 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');
+}