@yasserkhanorg/impact-gate 2.0.0

package/dist/esm/agent/feedback.js

@@ -0,0 +1,317 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
+import { join } from 'path';
+import { inferSubsystemFromTestPath } from './test_path.js';
+function readJson(path) {
+    if (!existsSync(path)) {
+        return null;
+    }
+    try {
+        return JSON.parse(readFileSync(path, 'utf-8'));
+    }
+    catch {
+        return null;
+    }
+}
+function normalizeTestName(test) {
+    return test.replace(/ \(flags:.*\)$/, '').trim();
+}
+function asSet(values) {
+    return new Set(values.map(normalizeTestName).filter(Boolean));
+}
+function ratio(numerator, denominator) {
+    if (denominator <= 0) {
+        return 0;
+    }
+    return Number((numerator / denominator).toFixed(4));
+}
+function subsystemForTest(test) {
+    return inferSubsystemFromTestPath(test);
+}
+function parseTimestamp(value) {
+    const time = Date.parse(value);
+    if (Number.isNaN(time)) {
+        return null;
+    }
+    return time;
+}
+function filterRecent(entries, days) {
+    const cutoff = Date.now() - days * 24 * 60 * 60 * 1000;
+    return entries.filter((entry) => {
+        const time = parseTimestamp(entry.timestamp);
+        return time !== null && time >= cutoff;
+    });
+}
+function aggregateMetrics(entries) {
+    let truePositives = 0;
+    let recommendedTotal = 0;
+    let failuresTotal = 0;
+    let escapedTotal = 0;
+    for (const entry of entries) {
+        const recommended = asSet(entry.recommendedTests || []);
+        const failed = asSet(entry.failedTests || []);
+        const escaped = asSet(entry.escapedFailures || []);
+        const tp = Array.from(recommended).filter((test) => failed.has(test)).length;
+        truePositives += tp;
+        recommendedTotal += recommended.size;
+        failuresTotal += failed.size;
+        escapedTotal += escaped.size;
+    }
+    return {
+        precision: ratio(truePositives, recommendedTotal),
+        recall: ratio(truePositives, failuresTotal),
+        falseNegativeRate: ratio(escapedTotal, failuresTotal + escapedTotal),
+        samples: entries.length,
+    };
+}
+function aggregate(entries) {
+    const subsystemAcc = new Map();
+    for (const entry of entries) {
+        const recommended = asSet(entry.recommendedTests || []);
+        const failed = asSet(entry.failedTests || []);
+        const escaped = asSet(entry.escapedFailures || []);
+        const allSubsystems = new Set([
+            ...Array.from(recommended).map(subsystemForTest),
+            ...Array.from(failed).map(subsystemForTest),
+            ...Array.from(escaped).map(subsystemForTest),
+        ]);
+        for (const subsystem of allSubsystems) {
+            const bucket = subsystemAcc.get(subsystem) || { entries: [] };
+            bucket.entries.push({
+                ...entry,
+                recommendedTests: Array.from(recommended).filter((test) => subsystemForTest(test) === subsystem),
+                executedTests: (entry.executedTests || []).filter((test) => subsystemForTest(test) === subsystem),
+                failedTests: Array.from(failed).filter((test) => subsystemForTest(test) === subsystem),
+                escapedFailures: Array.from(escaped).filter((test) => subsystemForTest(test) === subsystem),
+            });
+            subsystemAcc.set(subsystem, bucket);
+        }
+    }
+    const bySubsystem = {};
+    for (const [subsystem, bucket] of subsystemAcc.entries()) {
+        const all = aggregateMetrics(bucket.entries);
+        const recent7d = aggregateMetrics(filterRecent(bucket.entries, 7));
+        const recent30d = aggregateMetrics(filterRecent(bucket.entries, 30));
+        bySubsystem[subsystem] = {
+            precision: all.precision,
+            recall: all.recall,
+            falseNegativeRate: all.falseNegativeRate,
+            samples: all.samples,
+            recent7d,
+            recent30d,
+        };
+    }
+    const overall = aggregateMetrics(entries);
+    const recent7d = aggregateMetrics(filterRecent(entries, 7));
+    const recent30d = aggregateMetrics(filterRecent(entries, 30));
+    return {
+        schemaVersion: '1.1.0',
+        generatedAt: new Date().toISOString(),
+        samples: entries.length,
+        overall,
+        recent7d,
+        recent30d,
+        bySubsystem,
+    };
+}
+function rateFor(runs, failed) {
+    return runs > 0 ? Number((failed / runs).toFixed(4)) : 0;
+}
+function trendFor(rate7d, rate30d) {
+    if (rate7d - rate30d >= 0.08) {
+        return 'up';
+    }
+    if (rate30d - rate7d >= 0.08) {
+        return 'down';
+    }
+    return 'stable';
+}
+function loadOwners(appRoot) {
+    const path = join(appRoot, '.e2e-ai-agents', 'subsystem-owners.json');
+    const manifest = readJson(path);
+    if (!manifest) {
+        return {};
+    }
+    if (manifest.ownersBySubsystem) {
+        return manifest.ownersBySubsystem;
+    }
+    if (manifest.subsystems) {
+        return manifest.subsystems;
+    }
+    return {};
+}
+function daysSince(value) {
+    if (!value) {
+        return null;
+    }
+    const time = parseTimestamp(value);
+    if (time === null) {
+        return null;
+    }
+    return (Date.now() - time) / (24 * 60 * 60 * 1000);
+}
+function aggregateFlaky(entries, appRoot) {
+    const acc = new Map();
+    const cutoff7 = Date.now() - 7 * 24 * 60 * 60 * 1000;
+    const cutoff30 = Date.now() - 30 * 24 * 60 * 60 * 1000;
+    const ownersBySubsystem = loadOwners(appRoot);
+    for (const entry of entries) {
+        const executed = asSet(entry.executedTests || []);
+        const failed = asSet(entry.failedTests || []);
+        const time = parseTimestamp(entry.timestamp);
+        for (const test of executed) {
+            const bucket = acc.get(test) || {
+                runs: 0,
+                failed: 0,
+                runs7d: 0,
+                failed7d: 0,
+                runs30d: 0,
+                failed30d: 0,
+                lastFailureAt: undefined,
+            };
+            bucket.runs += 1;
+            if (time !== null && time >= cutoff7) {
+                bucket.runs7d += 1;
+            }
+            if (time !== null && time >= cutoff30) {
+                bucket.runs30d += 1;
+            }
+            if (failed.has(test)) {
+                bucket.failed += 1;
+                bucket.lastFailureAt = entry.timestamp;
+                if (time !== null && time >= cutoff7) {
+                    bucket.failed7d += 1;
+                }
+                if (time !== null && time >= cutoff30) {
+                    bucket.failed30d += 1;
+                }
+            }
+            acc.set(test, bucket);
+        }
+    }
+    const tests = Array.from(acc.entries())
+        .map(([test, bucket]) => {
+        const flakeRate = rateFor(bucket.runs, bucket.failed);
+        const flakeRate7d = rateFor(bucket.runs7d, bucket.failed7d);
+        const flakeRate30d = rateFor(bucket.runs30d, bucket.failed30d);
+        const trend = trendFor(flakeRate7d, flakeRate30d);
+        const quarantine = (bucket.runs30d >= 5 && flakeRate30d >= 0.35) || (bucket.runs >= 8 && flakeRate >= 0.4);
+        const daysFromLastFailure = daysSince(bucket.lastFailureAt);
+        const quarantineState = quarantine
+            ? (daysFromLastFailure !== null && daysFromLastFailure >= 14 && flakeRate7d <= 0.05 ? 'retire-candidate' : 'active')
+            : 'none';
+        const subsystem = subsystemForTest(test);
+        const owners = ownersBySubsystem[subsystem] || [];
+        return {
+            test,
+            subsystem,
+            owners,
+            flakeRate,
+            flakeRate7d,
+            flakeRate30d,
+            trend,
+            quarantine,
+            quarantineState,
+            lastFailureAt: bucket.lastFailureAt,
+            samples: bucket.runs,
+            samples7d: bucket.runs7d,
+            samples30d: bucket.runs30d,
+        };
+    })
+        .filter((entry) => entry.flakeRate > 0)
+        .sort((a, b) => (b.flakeRate30d || b.flakeRate) - (a.flakeRate30d || a.flakeRate));
+    return {
+        schemaVersion: '1.1.0',
+        generatedAt: new Date().toISOString(),
+        tests,
+    };
+}
+export function appendFeedbackAndRecompute(appRoot, input) {
+    const baseDir = join(appRoot, '.e2e-ai-agents');
+    mkdirSync(baseDir, { recursive: true });
+    const feedbackPath = join(baseDir, 'feedback.json');
+    const existing = readJson(feedbackPath) || { schemaVersion: '1.0.0', entries: [] };
+    existing.entries.push({
+        ...input,
+        recommendedTests: input.recommendedTests || [],
+        executedTests: input.executedTests || [],
+        failedTests: input.failedTests || [],
+        escapedFailures: input.escapedFailures || [],
+    });
+    writeFileSync(feedbackPath, JSON.stringify(existing, null, 2), 'utf-8');
+    const calibration = aggregate(existing.entries);
+    const calibrationPath = join(baseDir, 'calibration.json');
+    writeFileSync(calibrationPath, JSON.stringify(calibration, null, 2), 'utf-8');
+    const flaky = aggregateFlaky(existing.entries, appRoot);
+    const flakyPath = join(baseDir, 'flaky-tests.json');
+    writeFileSync(flakyPath, JSON.stringify(flaky, null, 2), 'utf-8');
+    return { feedbackPath, calibrationPath, calibration };
+}
+export function readCalibration(appRoot) {
+    return readJson(join(appRoot, '.e2e-ai-agents', 'calibration.json'));
+}
+const DEFAULT_MIN_CONFIDENCE = 60;
+const DEFAULT_SAFE_MERGE = 85;
+const MIN_CONFIDENCE_FLOOR = 40;
+const MIN_CONFIDENCE_CEILING = 80;
+/**
+ * Compute adaptive thresholds based on calibration data.
+ * - If recent recall < 0.8: lower minConfidence (catch more escapes)
+ * - If recent precision > 0.9: raise minConfidence (fewer unnecessary tests)
+ * - Per-subsystem: if falseNegativeRate > 0.3 in 30d, always include tests
+ * Returns defaults if no calibration data exists.
+ */
+export function getAdaptiveThresholds(appRoot) {
+    const calibration = readCalibration(appRoot);
+    const reasons = [];
+    const alwaysInclude = [];
+    if (!calibration || calibration.samples === 0) {
+        return {
+            minConfidenceForTargeted: DEFAULT_MIN_CONFIDENCE,
+            safeMergeMinConfidence: DEFAULT_SAFE_MERGE,
+            alwaysIncludeSubsystems: [],
+            adjustmentReasons: ['No calibration data — using defaults'],
+        };
+    }
+    let minConfidence = DEFAULT_MIN_CONFIDENCE;
+    let safeMerge = DEFAULT_SAFE_MERGE;
+    // Adjust based on 7-day recall
+    if (calibration.recent7d.samples >= 3) {
+        if (calibration.recent7d.recall < 0.8) {
+            const adjustment = 10;
+            minConfidence -= adjustment;
+            safeMerge -= adjustment;
+            reasons.push(`Lowering confidence threshold by ${adjustment} (7d recall: ${calibration.recent7d.recall.toFixed(2)})`);
+        }
+        else if (calibration.recent7d.precision > 0.9) {
+            const adjustment = 5;
+            minConfidence += adjustment;
+            safeMerge += adjustment;
+            reasons.push(`Raising confidence threshold by ${adjustment} (7d precision: ${calibration.recent7d.precision.toFixed(2)})`);
+        }
+    }
+    // Clamp to safe ranges
+    minConfidence = Math.max(MIN_CONFIDENCE_FLOOR, Math.min(MIN_CONFIDENCE_CEILING, minConfidence));
+    safeMerge = Math.max(70, Math.min(95, safeMerge));
+    // Per-subsystem blind spot detection (30-day window)
+    for (const [subsystem, metrics] of Object.entries(calibration.bySubsystem)) {
+        const recent = metrics.recent30d;
+        if (recent.samples >= 3 && recent.falseNegativeRate > 0.3) {
+            alwaysInclude.push(subsystem);
+            reasons.push(`Always including ${subsystem} tests (30d false-negative rate: ${recent.falseNegativeRate.toFixed(2)})`);
+        }
+    }
+    if (reasons.length === 0) {
+        reasons.push('Calibration data within normal range — using defaults');
+    }
+    return {
+        minConfidenceForTargeted: minConfidence,
+        safeMergeMinConfidence: safeMerge,
+        alwaysIncludeSubsystems: alwaysInclude,
+        adjustmentReasons: reasons,
+    };
+}
+export function readFlakyTests(appRoot) {
+    return readJson(join(appRoot, '.e2e-ai-agents', 'flaky-tests.json'));
+}

package/dist/esm/agent/git.js

@@ -0,0 +1,252 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+import { spawnSync } from 'child_process';
+import { normalizePath } from './utils.js';
+// Directories that contain CI/tooling/docs/tests — never relevant to impact analysis.
+const IGNORED_DIR_SEGMENTS = [
+    '.github',
+    '.claude',
+    '.vscode',
+    '.idea',
+    'node_modules',
+    'e2e-tests',
+    '__tests__',
+    '__mocks__',
+    'testlib',
+    'scripts',
+];
+// Exact filenames (basename) that are never relevant.
+const IGNORED_BASENAMES = new Set([
+    'package.json',
+    'package-lock.json',
+    '.gitignore',
+    '.prettierignore',
+    '.prettierrc',
+    '.eslintrc',
+    '.eslintrc.js',
+    '.eslintrc.json',
+    '.editorconfig',
+    '.npmrc',
+    '.mcp.json',
+    'CHANGELOG.md',
+    'README.md',
+    'LICENSE',
+    'LICENSE.txt',
+    'tsconfig.json',
+    'jest.config.js',
+    'jest.config.ts',
+    'babel.config.js',
+    'webpack.config.js',
+    'Makefile',
+    'config.mk',
+    'go.mod',
+    'go.sum',
+]);
+// Extensions that are never source code.
+const IGNORED_EXTENSIONS = new Set([
+    '.md',
+    '.txt',
+    '.lock',
+    '.png', '.jpg', '.jpeg', '.gif', '.svg', '.ico',
+    '.woff', '.woff2', '.ttf', '.eot',
+    '.yml', '.yaml',
+    '.sh',
+]);
+// File patterns that indicate test/spec files (not production code).
+const TEST_FILE_PATTERNS = [
+    /\.spec\.[tj]sx?$/,
+    /\.test\.[tj]sx?$/,
+    /_test\.go$/,
+    /\.stories\.[tj]sx?$/,
+    /\.d\.ts$/,
+];
+// Config file patterns that are not production source code.
+const CONFIG_FILE_PATTERNS = [
+    /\.config\.[tj]sx?$/,
+    /\.config\.json$/,
+    /\.config\.js$/,
+];
+function isRelevantFile(file) {
+    const segments = file.split('/');
+    const basename = segments[segments.length - 1] || file;
+    if (IGNORED_BASENAMES.has(basename)) {
+        return false;
+    }
+    for (const seg of segments) {
+        if (IGNORED_DIR_SEGMENTS.includes(seg)) {
+            return false;
+        }
+    }
+    const dotIdx = basename.lastIndexOf('.');
+    if (dotIdx > 0) {
+        const ext = basename.slice(dotIdx).toLowerCase();
+        if (IGNORED_EXTENSIONS.has(ext)) {
+            return false;
+        }
+    }
+    // Filter test/spec files — they don't impact production features
+    for (const pattern of TEST_FILE_PATTERNS) {
+        if (pattern.test(basename)) {
+            return false;
+        }
+    }
+    // Filter config files
+    for (const pattern of CONFIG_FILE_PATTERNS) {
+        if (pattern.test(basename)) {
+            return false;
+        }
+    }
+    return true;
+}
+export function runGitRaw(args, cwd) {
+    const result = spawnSync('git', args, {
+        cwd,
+        encoding: 'utf-8',
+        timeout: 30000,
+    });
+    if (result.error || result.status !== 0) {
+        return null;
+    }
+    return result.stdout;
+}
+function runGit(args, cwd) {
+    const output = runGitRaw(args, cwd);
+    if (output === null) {
+        return null;
+    }
+    return output
+        .split('\n')
+        .map((file) => file.trim())
+        .filter(Boolean)
+        .map((file) => normalizePath(file));
+}
+function parseStatusLines(lines) {
+    const files = [];
+    for (const line of lines) {
+        if (!line)
+            continue;
+        if (line.length < 4)
+            continue;
+        const pathPart = line.slice(3).trim();
+        if (!pathPart)
+            continue;
+        if (pathPart.includes('->')) {
+            const parts = pathPart.split('->').map((part) => part.trim());
+            const target = parts[parts.length - 1];
+            if (target) {
+                files.push(normalizePath(target));
+            }
+        }
+        else {
+            files.push(normalizePath(pathPart));
+        }
+    }
+    return files;
+}
+// Comment-line patterns by file extension.
+// A diff that ONLY touches these lines is a comment-only change (typo fix, doc update).
+const COMMENT_PATTERNS = [
+    { extensions: ['.go'], pattern: /^\s*(\/\/|\/\*|\*)/ },
+    { extensions: ['.ts', '.tsx', '.js', '.jsx'], pattern: /^\s*(\/\/|\/\*|\*|\*\/)/ },
+    { extensions: ['.py'], pattern: /^\s*#/ },
+    { extensions: ['.css', '.scss'], pattern: /^\s*(\/\*|\*|\*\/)/ },
+];
+/**
+ * Check if a file's diff only changes comment lines (no code changes).
+ * Returns true if the diff is comment-only and can be safely excluded.
+ */
+function isCommentOnlyDiff(file, repoRoot, baseRef) {
+    const diff = runGitRaw(['diff', `${baseRef}..HEAD`, '-U0', '--', file], repoRoot);
+    if (!diff)
+        return false;
+    const ext = file.slice(file.lastIndexOf('.'));
+    const commentEntry = COMMENT_PATTERNS.find((cp) => cp.extensions.includes(ext));
+    if (!commentEntry)
+        return false;
+    // Extract only added/removed content lines (skip diff headers)
+    const contentLines = diff
+        .split('\n')
+        .filter((line) => (line.startsWith('+') || line.startsWith('-')) && !line.startsWith('+++') && !line.startsWith('---'));
+    if (contentLines.length === 0)
+        return false;
+    // Every changed line must be a comment line
+    return contentLines.every((line) => {
+        const content = line.slice(1).trim(); // Remove +/- prefix
+        return content === '' || commentEntry.pattern.test(content);
+    });
+}
+/**
+ * Check if a file path is a test file (spec, test, or in test directories).
+ * Shared across pipeline and crew orchestrators.
+ */
+export function isTestFile(file) {
+    const normalized = file.replace(/\\/g, '/');
+    return /\.(spec|test)\.(ts|tsx|js|jsx)$/.test(normalized) ||
+        /\.snap$/.test(normalized) ||
+        /_test\.go$/.test(normalized) ||
+        normalized.includes('__tests__/') ||
+        normalized.includes('__snapshots__/') ||
+        normalized.includes('/tests/') ||
+        normalized.includes('/test/');
+}
+export function getChangedFiles(appRoot, since, options) {
+    try {
+        const files = new Set();
+        let baseRef = since;
+        let baseStrategy = 'direct';
+        const mergeBase = runGitRaw(['merge-base', since, 'HEAD'], appRoot);
+        if (mergeBase) {
+            const candidate = mergeBase
+                .split('\n')
+                .map((line) => line.trim())
+                .find(Boolean);
+            if (candidate) {
+                baseRef = candidate;
+                baseStrategy = 'merge-base';
+            }
+        }
+        // Get repo root so we capture ALL changed files (including server/, webapp/, etc.)
+        // not just files under the appRoot subdirectory.
+        const repoRoot = runGitRaw(['rev-parse', '--show-toplevel'], appRoot)?.trim() || appRoot;
+        const diffFiles = runGit(['diff', '--name-only', `${baseRef}..HEAD`], repoRoot);
+        if (!diffFiles) {
+            return { files: [], filteredTestFiles: [], error: 'git diff failed' };
+        }
+        diffFiles.forEach((file) => files.add(file));
+        if (options?.includeUncommitted) {
+            const staged = runGit(['diff', '--name-only', '--cached'], repoRoot) || [];
+            staged.forEach((file) => files.add(file));
+            const unstaged = runGit(['diff', '--name-only'], repoRoot) || [];
+            unstaged.forEach((file) => files.add(file));
+            const statusOutput = runGitRaw(['status', '--porcelain'], repoRoot);
+            if (statusOutput) {
+                const statusLines = statusOutput.split('\n').filter(Boolean);
+                parseStatusLines(statusLines).forEach((file) => files.add(file));
+            }
+        }
+        const allFiles = Array.from(files);
+        const relevant = [];
+        const filteredTestFiles = [];
+        for (const f of allFiles) {
+            if (isRelevantFile(f)) {
+                // Skip files where the diff only touches comments (typo fixes, doc updates)
+                if (isCommentOnlyDiff(f, repoRoot, baseRef)) {
+                    continue;
+                }
+                relevant.push(f);
+            }
+            else {
+                // Only capture files that were filtered because they match test patterns.
+                // Config, docs, workflow files etc. are not useful for PR-test detection.
+                const basename = f.split('/').pop() || f;
+                if (TEST_FILE_PATTERNS.some((p) => p.test(basename))) {
+                    filteredTestFiles.push(f);
+                }
+            }
+        }
+        return { files: relevant, filteredTestFiles, baseRef, baseStrategy };
+    }
+    catch {
+        return { files: [], filteredTestFiles: [], error: 'git diff failed' };
+    }
+}