@yasserkhanorg/e2e-agents 0.3.2

package/dist/esm/agent/traceability.js

@@ -0,0 +1,180 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+import { existsSync, readFileSync } from 'fs';
+import { isAbsolute, join } from 'path';
+import { normalizePath } from './utils.js';
+function ratio(numerator, denominator) {
+    if (denominator <= 0) {
+        return 0;
+    }
+    return Number((numerator / denominator).toFixed(4));
+}
+function resolveManifestPath(root, configuredPath) {
+    if (isAbsolute(configuredPath)) {
+        return configuredPath;
+    }
+    return join(root, configuredPath);
+}
+function safeReadManifest(path) {
+    if (!existsSync(path)) {
+        return null;
+    }
+    try {
+        return JSON.parse(readFileSync(path, 'utf-8'));
+    }
+    catch {
+        return null;
+    }
+}
+function normalizeFiles(files) {
+    if (!files) {
+        return [];
+    }
+    return files.map((file) => normalizePath(file)).filter(Boolean);
+}
+function normalizeTests(tests) {
+    if (!tests) {
+        return [];
+    }
+    return tests.map((test) => normalizePath(test)).filter(Boolean);
+}
+function buildFileToTestsMap(manifest) {
+    const fileToTests = new Map();
+    const setMapping = (file, test) => {
+        if (!file || !test) {
+            return;
+        }
+        const key = normalizePath(file);
+        const value = normalizePath(test);
+        if (!fileToTests.has(key)) {
+            fileToTests.set(key, new Set());
+        }
+        fileToTests.get(key)?.add(value);
+    };
+    if (manifest.tests) {
+        for (const entry of manifest.tests) {
+            const files = normalizeFiles(entry.touchedFiles);
+            for (const file of files) {
+                setMapping(file, entry.test);
+            }
+        }
+    }
+    if (manifest.fileToTests) {
+        for (const [file, tests] of Object.entries(manifest.fileToTests)) {
+            const normalizedTests = normalizeTests(tests);
+            for (const test of normalizedTests) {
+                setMapping(file, test);
+            }
+        }
+    }
+    if (manifest.mappings) {
+        for (const entry of manifest.mappings) {
+            const normalizedTests = normalizeTests(entry.tests);
+            for (const test of normalizedTests) {
+                setMapping(entry.file, test);
+            }
+        }
+    }
+    return fileToTests;
+}
+export function mapTraceabilityToFlows(appRoot, config, flows) {
+    const manifestPath = resolveManifestPath(appRoot, config.manifestPath);
+    const warnings = [];
+    const fallbackStats = {
+        source: 'manifest',
+        enabled: config.enabled,
+        manifestPath,
+        manifestFound: false,
+        manifestTests: 0,
+        manifestEdges: 0,
+        matchedFlows: 0,
+        totalFlows: flows.length,
+        matchedTests: 0,
+        coverageRatio: 0,
+    };
+    if (!config.enabled) {
+        return {
+            coverage: [],
+            warnings,
+            stats: fallbackStats,
+        };
+    }
+    const manifest = safeReadManifest(manifestPath);
+    if (!manifest) {
+        warnings.push(`Traceability manifest not found or invalid: ${manifestPath}`);
+        return {
+            coverage: [],
+            warnings,
+            stats: fallbackStats,
+        };
+    }
+    const fileToTests = buildFileToTestsMap(manifest);
+    let manifestEdges = 0;
+    for (const tests of fileToTests.values()) {
+        manifestEdges += tests.size;
+    }
+    const manifestTests = new Set();
+    const coverage = [];
+    const matchedTests = new Set();
+    let matchedFlows = 0;
+    for (const tests of fileToTests.values()) {
+        for (const test of tests) {
+            manifestTests.add(test);
+        }
+    }
+    for (const flow of flows) {
+        const signalCounts = new Map();
+        const files = flow.files.map((file) => normalizePath(file));
+        for (const file of files) {
+            const tests = fileToTests.get(file);
+            if (!tests) {
+                continue;
+            }
+            for (const test of tests) {
+                signalCounts.set(test, (signalCounts.get(test) || 0) + 1);
+            }
+        }
+        const coveredBy = Array.from(signalCounts.entries())
+            .filter(([, count]) => count >= Math.max(1, config.minSignalsPerTest))
+            .map(([test]) => test)
+            .sort();
+        const score = Array.from(signalCounts.values()).reduce((acc, value) => acc + value, 0);
+        if (coveredBy.length > 0) {
+            matchedFlows += 1;
+            for (const test of coveredBy) {
+                matchedTests.add(test);
+            }
+        }
+        coverage.push({
+            flowId: flow.id,
+            flowName: flow.name,
+            priority: flow.priority,
+            coveredBy,
+            score,
+            source: 'traceability',
+        });
+    }
+    const stats = {
+        source: 'manifest',
+        enabled: config.enabled,
+        manifestPath,
+        manifestFound: true,
+        manifestTests: manifestTests.size,
+        manifestEdges,
+        matchedFlows,
+        totalFlows: flows.length,
+        matchedTests: matchedTests.size,
+        coverageRatio: ratio(matchedFlows, flows.length),
+    };
+    if (manifestEdges === 0) {
+        warnings.push(`Traceability manifest has no file-to-test mappings: ${manifestPath}`);
+    }
+    else if (stats.coverageRatio < 0.4) {
+        warnings.push(`Traceability coverage is low (${stats.matchedFlows}/${stats.totalFlows} flows mapped). Recommendations may require heuristic fallback.`);
+    }
+    return {
+        coverage,
+        warnings,
+        stats,
+    };
+}

package/dist/esm/agent/traceability_capture.js

@@ -0,0 +1,310 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
+import { dirname, isAbsolute, resolve } from 'path';
+import { getChangedFiles } from './git.js';
+import { normalizePath } from './utils.js';
+function asRecord(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        return null;
+    }
+    return value;
+}
+function asArray(value) {
+    return Array.isArray(value) ? value : [];
+}
+function resolveFilePath(cwd, value) {
+    if (isAbsolute(value)) {
+        return value;
+    }
+    return resolve(cwd, value);
+}
+function normalizeList(values) {
+    return Array.from(new Set(values
+        .map((value) => normalizePath(value))
+        .filter(Boolean)));
+}
+function parseStringArray(value) {
+    return normalizeList(asArray(value)
+        .filter((item) => typeof item === 'string')
+        .map((item) => item));
+}
+function isExecutedStatus(status) {
+    return status !== 'skipped';
+}
+function specExecuted(spec) {
+    const tests = asArray(spec.tests);
+    if (tests.length === 0) {
+        return false;
+    }
+    for (const testValue of tests) {
+        const testNode = asRecord(testValue);
+        if (!testNode) {
+            continue;
+        }
+        const testStatus = typeof testNode.status === 'string' ? testNode.status : undefined;
+        if (testStatus && isExecutedStatus(testStatus)) {
+            return true;
+        }
+        const outcome = typeof testNode.outcome === 'string' ? testNode.outcome : undefined;
+        if (outcome && isExecutedStatus(outcome)) {
+            return true;
+        }
+        const results = asArray(testNode.results);
+        for (const resultValue of results) {
+            const resultNode = asRecord(resultValue);
+            if (!resultNode) {
+                continue;
+            }
+            const status = typeof resultNode.status === 'string' ? resultNode.status : undefined;
+            if (status && isExecutedStatus(status)) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+function relativizePath(path, roots) {
+    const normalized = normalizePath(path);
+    for (const root of roots) {
+        const normalizedRoot = normalizePath(resolve(root));
+        if (normalized === normalizedRoot) {
+            return '.';
+        }
+        if (normalized.startsWith(`${normalizedRoot}/`)) {
+            return normalized.slice(normalizedRoot.length + 1);
+        }
+    }
+    return normalized;
+}
+function collectExecutedSpecs(value, roots, output) {
+    const node = asRecord(value);
+    if (!node) {
+        return;
+    }
+    const specs = asArray(node.specs);
+    for (const specValue of specs) {
+        const specNode = asRecord(specValue);
+        if (!specNode) {
+            continue;
+        }
+        const file = typeof specNode.file === 'string' ? specNode.file : '';
+        if (!file) {
+            continue;
+        }
+        if (!specExecuted(specNode)) {
+            continue;
+        }
+        output.add(relativizePath(file, roots));
+    }
+    const suites = asArray(node.suites);
+    for (const suite of suites) {
+        collectExecutedSpecs(suite, roots, output);
+    }
+}
+function loadPlaywrightExecutedSpecs(reportPath, roots) {
+    const raw = JSON.parse(readFileSync(reportPath, 'utf-8'));
+    const specs = new Set();
+    collectExecutedSpecs(raw, roots, specs);
+    return Array.from(specs).sort();
+}
+function loadChangedFilesFromPath(filePath) {
+    const rawText = readFileSync(filePath, 'utf-8');
+    const trimmed = rawText.trim();
+    if (!trimmed) {
+        return [];
+    }
+    if (trimmed.startsWith('{') || trimmed.startsWith('[')) {
+        const parsed = JSON.parse(trimmed);
+        if (Array.isArray(parsed)) {
+            return normalizeList(parsed.filter((value) => typeof value === 'string'));
+        }
+        const node = asRecord(parsed);
+        if (!node) {
+            return [];
+        }
+        if (Array.isArray(node.files)) {
+            return normalizeList(node.files.filter((value) => typeof value === 'string'));
+        }
+        if (Array.isArray(node.changedFiles)) {
+            return normalizeList(node.changedFiles.filter((value) => typeof value === 'string'));
+        }
+        return [];
+    }
+    return normalizeList(rawText
+        .split('\n')
+        .map((line) => line.trim())
+        .filter(Boolean));
+}
+function addCoverageEntry(map, test, files) {
+    if (!test || files.length === 0) {
+        return;
+    }
+    const normalizedTest = normalizePath(test);
+    if (!map.has(normalizedTest)) {
+        map.set(normalizedTest, new Set());
+    }
+    const bucket = map.get(normalizedTest);
+    for (const file of files) {
+        bucket?.add(normalizePath(file));
+    }
+}
+function loadCoverageMap(path) {
+    const raw = JSON.parse(readFileSync(path, 'utf-8'));
+    const map = new Map();
+    const appendTestEntry = (testValue, filesValue) => {
+        if (typeof testValue !== 'string') {
+            return;
+        }
+        const files = parseStringArray(filesValue);
+        addCoverageEntry(map, testValue, files);
+    };
+    if (Array.isArray(raw)) {
+        for (const entry of raw) {
+            const node = asRecord(entry);
+            if (!node) {
+                continue;
+            }
+            appendTestEntry(node.test, node.touchedFiles);
+        }
+        return map;
+    }
+    const node = asRecord(raw);
+    if (!node) {
+        return map;
+    }
+    for (const entry of asArray(node.tests)) {
+        const testNode = asRecord(entry);
+        if (!testNode) {
+            continue;
+        }
+        appendTestEntry(testNode.test, Array.isArray(testNode.touchedFiles) ? testNode.touchedFiles : testNode.files);
+    }
+    for (const entry of asArray(node.runs)) {
+        const runNode = asRecord(entry);
+        if (!runNode) {
+            continue;
+        }
+        const files = Array.isArray(runNode.touchedFiles)
+            ? runNode.touchedFiles
+            : (Array.isArray(runNode.coveredFiles) ? runNode.coveredFiles : runNode.files);
+        appendTestEntry(runNode.test, files);
+    }
+    const mappings = asArray(node.mappings);
+    for (const mapping of mappings) {
+        const mappingNode = asRecord(mapping);
+        if (!mappingNode || typeof mappingNode.file !== 'string' || !Array.isArray(mappingNode.tests)) {
+            continue;
+        }
+        const normalizedFile = normalizePath(mappingNode.file);
+        for (const test of mappingNode.tests) {
+            if (typeof test !== 'string') {
+                continue;
+            }
+            addCoverageEntry(map, test, [normalizedFile]);
+        }
+    }
+    const fileToTests = asRecord(node.fileToTests);
+    if (fileToTests) {
+        for (const [file, tests] of Object.entries(fileToTests)) {
+            if (!Array.isArray(tests)) {
+                continue;
+            }
+            for (const test of tests) {
+                if (typeof test !== 'string') {
+                    continue;
+                }
+                addCoverageEntry(map, test, [normalizePath(file)]);
+            }
+        }
+    }
+    return map;
+}
+function coverageForSpec(specPath, coverageMap) {
+    const normalizedSpec = normalizePath(specPath);
+    const files = new Set();
+    const direct = coverageMap.get(normalizedSpec);
+    if (direct) {
+        for (const file of direct) {
+            files.add(file);
+        }
+    }
+    const prefix = `${normalizedSpec}#`;
+    for (const [key, value] of coverageMap.entries()) {
+        if (key.startsWith(prefix)) {
+            for (const file of value) {
+                files.add(file);
+            }
+        }
+    }
+    return Array.from(files).sort();
+}
+export function captureTraceabilityInput(options) {
+    const warnings = [];
+    const reportPath = resolveFilePath(process.cwd(), options.reportPath);
+    if (!existsSync(reportPath)) {
+        throw new Error(`Traceability report not found: ${reportPath}`);
+    }
+    const roots = [options.testsRoot, options.appPath].map((root) => resolve(root));
+    const executedSpecs = loadPlaywrightExecutedSpecs(reportPath, roots);
+    if (executedSpecs.length === 0) {
+        warnings.push('No executed tests found in Playwright report.');
+    }
+    let changedFiles = [];
+    if (options.changedFilesPath) {
+        const changedPath = resolveFilePath(process.cwd(), options.changedFilesPath);
+        if (existsSync(changedPath)) {
+            changedFiles = loadChangedFilesFromPath(changedPath);
+        }
+        else {
+            warnings.push(`Changed files path not found: ${changedPath}`);
+        }
+    }
+    else {
+        const diff = getChangedFiles(options.appPath, options.sinceRef, { includeUncommitted: false });
+        if (diff.error) {
+            warnings.push(`Git diff failed while building traceability input: ${diff.error}`);
+        }
+        changedFiles = diff.files;
+    }
+    changedFiles = normalizeList(changedFiles);
+    let coverageMap = new Map();
+    if (options.coverageMapPath) {
+        const coveragePath = resolveFilePath(process.cwd(), options.coverageMapPath);
+        if (existsSync(coveragePath)) {
+            coverageMap = loadCoverageMap(coveragePath);
+        }
+        else {
+            warnings.push(`Coverage map path not found: ${coveragePath}`);
+        }
+    }
+    const runs = executedSpecs.map((spec) => {
+        const mappedFiles = coverageForSpec(spec, coverageMap);
+        const touchedFiles = mappedFiles.length > 0 ? mappedFiles : changedFiles;
+        return {
+            test: spec,
+            touchedFiles,
+            timestamp: new Date().toISOString(),
+        };
+    }).filter((entry) => entry.touchedFiles.length > 0);
+    if (runs.length < executedSpecs.length && changedFiles.length === 0) {
+        warnings.push('Some executed tests had no coverage-map entries and no changed-files fallback.');
+    }
+    const outputPath = options.outputPath
+        ? resolveFilePath(process.cwd(), options.outputPath)
+        : resolve(options.testsRoot, '.e2e-ai-agents', 'traceability-input.json');
+    mkdirSync(dirname(outputPath), { recursive: true });
+    writeFileSync(outputPath, JSON.stringify({
+        schemaVersion: '1.0.0',
+        source: 'traceability-capture',
+        generatedAt: new Date().toISOString(),
+        runs,
+    }, null, 2), 'utf-8');
+    return {
+        outputPath,
+        testsSeen: executedSpecs.length,
+        runsGenerated: runs.length,
+        changedFilesUsed: changedFiles.length,
+        warnings,
+    };
+}