@yasserkhanorg/impact-gate 2.0.0

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,
+    };
+}

package/dist/esm/agent/traceability_ingest.js

@@ -0,0 +1,234 @@
+// 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, join } from 'path';
+import { normalizePath } from './utils.js';
+const DEFAULT_OPTIONS = {
+    minHits: 1,
+    maxFilesPerTest: 200,
+    maxAgeDays: 120,
+};
+function resolvePath(root, value) {
+    if (isAbsolute(value)) {
+        return value;
+    }
+    return join(root, value);
+}
+function parseDate(value) {
+    const parsed = Date.parse(value);
+    if (Number.isNaN(parsed)) {
+        return null;
+    }
+    return parsed;
+}
+function safeReadJson(path) {
+    if (!existsSync(path)) {
+        return null;
+    }
+    try {
+        return JSON.parse(readFileSync(path, 'utf-8'));
+    }
+    catch {
+        return null;
+    }
+}
+function normalizeFiles(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return Array.from(new Set(value
+        .filter((entry) => typeof entry === 'string')
+        .map((entry) => normalizePath(entry))));
+}
+function normalizeTest(value) {
+    if (typeof value !== 'string') {
+        return null;
+    }
+    const normalized = normalizePath(value);
+    return normalized ? normalized : null;
+}
+function buildEntriesFromInput(payload) {
+    const warnings = [];
+    const entries = [];
+    const pushEntry = (testValue, filesValue, timestampValue) => {
+        const test = normalizeTest(testValue);
+        const files = normalizeFiles(filesValue);
+        if (!test || files.length === 0) {
+            return;
+        }
+        entries.push({
+            test,
+            touchedFiles: files,
+            timestamp: typeof timestampValue === 'string' ? timestampValue : undefined,
+        });
+    };
+    if (Array.isArray(payload)) {
+        for (const item of payload) {
+            if (!item || typeof item !== 'object') {
+                continue;
+            }
+            const entry = item;
+            pushEntry(entry.test, entry.touchedFiles, entry.timestamp);
+        }
+        if (entries.length === 0) {
+            warnings.push('Traceability input array had no valid entries.');
+        }
+        return { entries, warnings };
+    }
+    if (!payload || typeof payload !== 'object') {
+        warnings.push('Traceability input must be an object or array.');
+        return { entries, warnings };
+    }
+    const input = payload;
+    if (Array.isArray(input.tests)) {
+        for (const item of input.tests) {
+            pushEntry(item?.test, item?.touchedFiles, item?.timestamp);
+        }
+    }
+    if (Array.isArray(input.runs)) {
+        for (const item of input.runs) {
+            const files = Array.isArray(item?.touchedFiles) ? item?.touchedFiles : (Array.isArray(item?.coveredFiles) ? item?.coveredFiles : item?.files);
+            pushEntry(item?.test, files, item?.timestamp);
+        }
+    }
+    if (input.fileToTests && typeof input.fileToTests === 'object') {
+        for (const [file, tests] of Object.entries(input.fileToTests)) {
+            if (!Array.isArray(tests)) {
+                continue;
+            }
+            const normalizedFile = normalizePath(file);
+            for (const test of tests) {
+                pushEntry(test, [normalizedFile]);
+            }
+        }
+    }
+    if (Array.isArray(input.mappings)) {
+        for (const mapping of input.mappings) {
+            const file = typeof mapping?.file === 'string' ? normalizePath(mapping.file) : null;
+            if (!file || !Array.isArray(mapping.tests)) {
+                continue;
+            }
+            for (const test of mapping.tests) {
+                pushEntry(test, [file]);
+            }
+        }
+    }
+    if (entries.length === 0) {
+        warnings.push('Traceability input had no valid test<->file entries.');
+    }
+    return { entries, warnings };
+}
+function defaultState() {
+    return {
+        schemaVersion: '1.0.0',
+        updatedAt: new Date().toISOString(),
+        tests: {},
+    };
+}
+function loadState(path) {
+    const existing = safeReadJson(path);
+    if (!existing || typeof existing !== 'object' || !existing.tests) {
+        return defaultState();
+    }
+    return {
+        schemaVersion: '1.0.0',
+        updatedAt: existing.updatedAt || new Date().toISOString(),
+        tests: existing.tests,
+    };
+}
+function pruneByAge(state, maxAgeDays) {
+    const cutoff = Date.now() - maxAgeDays * 24 * 60 * 60 * 1000;
+    for (const [test, entry] of Object.entries(state.tests)) {
+        const lastSeen = parseDate(entry.lastSeen);
+        if (lastSeen === null) {
+            continue;
+        }
+        if (lastSeen < cutoff) {
+            delete state.tests[test];
+        }
+    }
+}
+function buildManifest(state, minHits, maxFilesPerTest) {
+    const tests = Object.entries(state.tests)
+        .map(([test, entry]) => {
+        const touchedFiles = Object.entries(entry.files)
+            .filter(([, hits]) => hits >= minHits)
+            .sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0]))
+            .slice(0, maxFilesPerTest)
+            .map(([file]) => file);
+        const signalCount = Object.values(entry.files).reduce((acc, value) => acc + value, 0);
+        return {
+            test,
+            touchedFiles,
+            signalCount,
+            lastSeen: entry.lastSeen,
+        };
+    })
+        .filter((entry) => entry.touchedFiles.length > 0)
+        .sort((a, b) => a.test.localeCompare(b.test));
+    return {
+        schemaVersion: '1.0.0',
+        generatedAt: new Date().toISOString(),
+        tests,
+    };
+}
+function ensureParent(path) {
+    mkdirSync(dirname(path), { recursive: true });
+}
+export function ingestTraceabilityInput(rootPath, traceabilityConfig, inputPayload, options) {
+    const resolvedOptions = {
+        minHits: options?.minHits ?? DEFAULT_OPTIONS.minHits,
+        maxFilesPerTest: options?.maxFilesPerTest ?? DEFAULT_OPTIONS.maxFilesPerTest,
+        maxAgeDays: options?.maxAgeDays ?? DEFAULT_OPTIONS.maxAgeDays,
+    };
+    const warnings = [];
+    const manifestPath = resolvePath(rootPath, traceabilityConfig.manifestPath);
+    const statePath = join(dirname(manifestPath), 'traceability-state.json');
+    if (!traceabilityConfig.enabled) {
+        warnings.push('Traceability is disabled in config. Input was not ingested.');
+        return {
+            manifestPath,
+            statePath,
+            entriesIngested: 0,
+            testsTracked: 0,
+            edgesTracked: 0,
+            warnings,
+        };
+    }
+    const parsed = buildEntriesFromInput(inputPayload);
+    warnings.push(...parsed.warnings);
+    const state = loadState(statePath);
+    const now = new Date().toISOString();
+    for (const entry of parsed.entries) {
+        const bucket = state.tests[entry.test] || {
+            files: {},
+            seenCount: 0,
+            lastSeen: now,
+        };
+        bucket.seenCount += 1;
+        bucket.lastSeen = entry.timestamp || now;
+        for (const file of entry.touchedFiles) {
+            bucket.files[file] = (bucket.files[file] || 0) + 1;
+        }
+        state.tests[entry.test] = bucket;
+    }
+    pruneByAge(state, Math.max(1, resolvedOptions.maxAgeDays));
+    state.updatedAt = now;
+    const manifest = buildManifest(state, Math.max(1, resolvedOptions.minHits), Math.max(1, resolvedOptions.maxFilesPerTest));
+    let edgesTracked = 0;
+    for (const entry of manifest.tests) {
+        edgesTracked += entry.touchedFiles.length;
+    }
+    ensureParent(statePath);
+    ensureParent(manifestPath);
+    writeFileSync(statePath, JSON.stringify(state, null, 2), 'utf-8');
+    writeFileSync(manifestPath, JSON.stringify(manifest, null, 2), 'utf-8');
+    return {
+        manifestPath,
+        statePath,
+        entriesIngested: parsed.entries.length,
+        testsTracked: manifest.tests.length,
+        edgesTracked,
+        warnings,
+    };
+}

package/dist/esm/agent/types.js

@@ -0,0 +1,3 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+export {};

package/dist/esm/agent/utils.js

@@ -0,0 +1,138 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+import { readFileSync, statSync } from 'fs';
+import { basename, extname, posix, relative, resolve } from 'path';
+const MAX_READ_BYTES = 1024 * 1024; // 1MB
+const STOP_WORDS = new Set([
+    'index',
+    'component',
+    'components',
+    'page',
+    'pages',
+    'screen',
+    'screens',
+    'view',
+    'views',
+    'route',
+    'routes',
+    'feature',
+    'features',
+    'module',
+    'modules',
+    'flow',
+    'flows',
+    'test',
+    'tests',
+    'spec',
+    'specs',
+    'hooks',
+    'hook',
+    'context',
+    'state',
+    'store',
+]);
+const GLOB_CHARS = /[*?[\]{}()!]/;
+export function hasGlobChars(value) {
+    return GLOB_CHARS.test(value);
+}
+export function globToRegExp(pattern) {
+    const normalized = normalizePath(pattern);
+    let regex = '^';
+    let i = 0;
+    while (i < normalized.length) {
+        const char = normalized[i];
+        if (char === '*') {
+            const next = normalized[i + 1];
+            if (next === '*') {
+                regex += '.*';
+                i += 2;
+                continue;
+            }
+            regex += '[^/]*';
+            i += 1;
+            continue;
+        }
+        if (char === '?') {
+            regex += '[^/]';
+            i += 1;
+            continue;
+        }
+        if ('\\.[]{}()+-^$|'.includes(char)) {
+            regex += `\\${char}`;
+        }
+        else {
+            regex += char;
+        }
+        i += 1;
+    }
+    regex += '$';
+    return new RegExp(regex);
+}
+export function matchGlob(pathValue, pattern) {
+    const normalizedPath = normalizePath(pathValue);
+    const normalizedPattern = normalizePath(pattern);
+    if (!hasGlobChars(normalizedPattern)) {
+        if (normalizedPattern.endsWith('/')) {
+            return normalizedPath.startsWith(normalizedPattern);
+        }
+        return normalizedPath === normalizedPattern || normalizedPath.startsWith(`${normalizedPattern}/`);
+    }
+    const regex = globToRegExp(normalizedPattern);
+    return regex.test(normalizedPath);
+}
+export function safeReadTextFile(path) {
+    try {
+        const stats = statSync(path);
+        if (stats.size > MAX_READ_BYTES) {
+            return null;
+        }
+        return readFileSync(path, 'utf-8');
+    }
+    catch {
+        return null;
+    }
+}
+export function normalizePath(pathValue) {
+    return pathValue.split('\\').join('/');
+}
+export function toRelativePosix(root, filePath) {
+    const relative = posix.relative(normalizePath(root), normalizePath(filePath));
+    return relative.startsWith('../') ? normalizePath(filePath) : relative;
+}
+export function isPathWithinRoot(root, target) {
+    const rootAbs = resolve(root);
+    const targetAbs = resolve(target);
+    const rel = relative(rootAbs, targetAbs);
+    return rel === '' || (!rel.startsWith('..') && !rel.includes(`..${posix.sep}`) && !rel.includes('..\\'));
+}
+export function fileExtension(pathValue) {
+    return extname(pathValue).replace('.', '').toLowerCase();
+}
+export function baseNameWithoutExt(pathValue) {
+    const base = basename(pathValue);
+    const ext = extname(base);
+    return ext ? base.slice(0, -ext.length) : base;
+}
+function splitCamelCase(value) {
+    return value.replace(/([a-z])([A-Z])/g, '$1 $2');
+}
+export function tokenize(value) {
+    const normalized = splitCamelCase(value)
+        .replace(/[_\-.]/g, ' ')
+        .replace(/[^a-zA-Z0-9\s]/g, ' ')
+        .toLowerCase();
+    return normalized
+        .split(/\s+/)
+        .map((token) => token.trim())
+        .filter((token) => token.length > 2 && !STOP_WORDS.has(token));
+}
+export function uniqueTokens(tokens) {
+    return Array.from(new Set(tokens.filter(Boolean)));
+}
+export function titleCase(value) {
+    return value
+        .split(/[\s_-]+/)
+        .filter(Boolean)
+        .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
+        .join(' ');
+}