@yasserkhanorg/e2e-agents 0.5.16 → 0.7.0

package/dist/esm/agent/plan.js

@@ -1,359 +1,7 @@
 // Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
 // See LICENSE.txt for license information.
 import { appendFileSync, existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
-import { dirname, join } from 'path';
-import { minimatch } from 'minimatch';
-const DEFAULT_POLICY = {
-    minConfidenceForTargeted: 60,
-    safeMergeMinConfidence: 85,
-    forceFullOnWarningsAtOrAbove: 2,
-    forceFullOnP0WithGaps: true,
-    forceFullOnRiskyFiles: true,
-    riskyFilePatterns: [
-        '**/auth/**',
-        '**/login/**',
-        '**/permissions/**',
-        '**/admin/**',
-        '**/security/**',
-        '**/migrations/**',
-        '**/schema/**',
-        '**/*.sql',
-        '**/webhook/**',
-    ],
-    enforcementMode: 'advisory',
-    blockOnActions: ['must-add-tests'],
-};
-function countPriority(flows) {
-    const counts = { p0: 0, p1: 0, p2: 0 };
-    for (const flow of flows) {
-        if (flow.priority === 'P0')
-            counts.p0 += 1;
-        else if (flow.priority === 'P1')
-            counts.p1 += 1;
-        else
-            counts.p2 += 1;
-    }
-    return counts;
-}
-function computeConfidence(impact, p0, p1) {
-    let confidence = 85;
-    confidence -= Math.min(25, impact.warnings.length * 8);
-    confidence -= Math.min(20, impact.gaps.length * 5);
-    if (p0 > 0) {
-        confidence -= Math.min(10, p0 * 3);
-    }
-    else if (p1 > 0) {
-        confidence -= Math.min(6, p1 * 2);
-    }
-    if (impact.impactModel) {
-        if (impact.impactModel.flowMapping === 'catalog') {
-            confidence += 4;
-        }
-        else if (impact.impactModel.flowMapping === 'ai') {
-            confidence += 4;
-        }
-        if (impact.impactModel.testMapping === 'catalog') {
-            confidence += 4;
-        }
-        else if (impact.impactModel.testMapping === 'traceability') {
-            confidence += 6;
-        }
-        else if (impact.impactModel.testMapping === 'ai') {
-            confidence += 4;
-        }
-        if (impact.impactModel.confidenceClass === 'medium') {
-            confidence -= 4;
-        }
-        else if (impact.impactModel.confidenceClass === 'low') {
-            confidence -= 12;
-        }
-        if (impact.impactModel.traceability) {
-            if (!impact.impactModel.traceability.manifestFound) {
-                confidence -= 6;
-            }
-            else if (impact.impactModel.traceability.coverageRatio >= 0.8) {
-                confidence += 2;
-            }
-            else if (impact.impactModel.traceability.coverageRatio < 0.5) {
-                confidence -= 4;
-            }
-        }
-        if (impact.impactModel.dependencyGraph?.truncated) {
-            confidence -= 6;
-        }
-        if (impact.impactModel.dependencyGraph && impact.impactModel.dependencyGraph.expandedFiles > 0) {
-            confidence += 2;
-        }
-    }
-    return Math.max(0, Math.min(100, confidence));
-}
-function findRiskyFiles(changedFiles, patterns) {
-    const risky = changedFiles.filter((file) => patterns.some((pattern) => minimatch(file, pattern, { matchBase: true })));
-    return [...new Set(risky)];
-}
-function pickRunSet(impact, p0, confidence, policy) {
-    const reasons = [];
-    const triggeredRules = [];
-    const riskyFiles = findRiskyFiles(impact.changedFiles, policy.riskyFilePatterns);
-    if (impact.warnings.length > 0) {
-        reasons.push('Impact analysis emitted warnings; broader safety coverage is recommended.');
-    }
-    if (impact.gaps.length > 0) {
-        reasons.push('Uncovered P0/P1 flows were detected.');
-    }
-    if (p0 > 0) {
-        reasons.push('P0 flows are impacted by this change set.');
-    }
-    if (policy.forceFullOnRiskyFiles && riskyFiles.length > 0) {
-        triggeredRules.push('risky-files');
-        reasons.push(`Risky file patterns matched: ${riskyFiles.join(', ')}`);
-    }
-    if (impact.impactModel?.confidenceClass === 'low') {
-        triggeredRules.push('low-traceability');
-        reasons.push('Impact mapping confidence is low.');
-    }
-    if (impact.impactModel?.traceability?.manifestFound && impact.impactModel.traceability.coverageRatio < 0.4) {
-        triggeredRules.push('traceability-low-coverage');
-        reasons.push('Traceability manifest coverage is low for impacted flows; broader safety run is recommended.');
-    }
-    if (impact.impactModel?.dependencyGraph?.truncated) {
-        triggeredRules.push('dependency-graph-truncated');
-        reasons.push('Dependency graph expansion was truncated; broader safety run is recommended.');
-    }
-    if (confidence < policy.minConfidenceForTargeted) {
-        triggeredRules.push('low-confidence');
-    }
-    if (impact.warnings.length >= policy.forceFullOnWarningsAtOrAbove) {
-        triggeredRules.push('warning-threshold');
-    }
-    if (policy.forceFullOnP0WithGaps && p0 > 0 && impact.gaps.length > 0) {
-        triggeredRules.push('p0-with-gaps');
-    }
-    if (triggeredRules.length > 0) {
-        return {
-            runSet: 'full',
-            reasons: reasons.length > 0 ? reasons : ['Low confidence in targeted recommendation.'],
-            triggeredRules,
-            riskyFiles,
-        };
-    }
-    if (impact.recommendedTests && impact.recommendedTests.length > 0) {
-        return {
-            runSet: 'targeted',
-            reasons: reasons.length > 0 ? reasons : ['Sufficient confidence for targeted run list.'],
-            triggeredRules,
-            riskyFiles,
-        };
-    }
-    return {
-        runSet: 'smoke',
-        reasons: reasons.length > 0 ? reasons : ['No targeted tests were mapped from the impacted flows.'],
-        triggeredRules,
-        riskyFiles,
-    };
-}
-function buildDecision(runSet, confidence, impact, policy) {
-    if (impact.gaps.length > 0) {
-        return {
-            action: 'must-add-tests',
-            title: 'Must add tests',
-            summary: `Detected ${impact.gaps.length} uncovered P0/P1 flow(s). Add or update tests before merge.`,
-        };
-    }
-    if (impact.changedFiles.length === 0 && impact.flows.length === 0) {
-        return {
-            action: 'safe-to-merge',
-            title: 'Safe to merge',
-            summary: 'No app file changes detected — no E2E coverage required for this change set.',
-        };
-    }
-    if (runSet === 'smoke' && confidence >= policy.safeMergeMinConfidence && impact.warnings.length === 0) {
-        return {
-            action: 'safe-to-merge',
-            title: 'Safe to merge',
-            summary: 'No critical coverage gaps were detected and policy confidence is high.',
-        };
-    }
-    const coveredCount = impact.coverage.filter((c) => c.coveredBy.length > 0).length;
-    const coverageSuffix = coveredCount > 0
-        ? ` All ${coveredCount} impacted flow(s) have test coverage.`
-        : '';
-    return {
-        action: 'run-now',
-        title: 'Run now',
-        summary: `Impacted flows are covered by existing tests.${coverageSuffix} Verify with the E2E suite before merge.`,
-    };
-}
-function evaluateEnforcement(decision, policy) {
-    const blockOnActions = (policy.blockOnActions && policy.blockOnActions.length > 0)
-        ? [...policy.blockOnActions]
-        : ['must-add-tests'];
-    const matchedAction = blockOnActions.includes(decision.action);
-    if (policy.enforcementMode === 'block' && matchedAction) {
-        return {
-            mode: policy.enforcementMode,
-            blockOnActions,
-            matchedAction,
-            shouldFail: true,
-            summary: `Blocking mode active: decision "${decision.action}" is configured to fail CI.`,
-        };
-    }
-    if (policy.enforcementMode === 'warn' && matchedAction) {
-        return {
-            mode: policy.enforcementMode,
-            blockOnActions,
-            matchedAction,
-            shouldFail: false,
-            summary: `Warning mode active: decision "${decision.action}" is advisory-only for CI.`,
-        };
-    }
-    if (policy.enforcementMode === 'block') {
-        return {
-            mode: policy.enforcementMode,
-            blockOnActions,
-            matchedAction,
-            shouldFail: false,
-            summary: `Blocking mode active, but decision "${decision.action}" is not configured for CI failure.`,
-        };
-    }
-    if (policy.enforcementMode === 'warn') {
-        return {
-            mode: policy.enforcementMode,
-            blockOnActions,
-            matchedAction,
-            shouldFail: false,
-            summary: `Warning mode active, but decision "${decision.action}" is not configured for warning.`,
-        };
-    }
-    return {
-        mode: policy.enforcementMode,
-        blockOnActions,
-        matchedAction,
-        shouldFail: false,
-        summary: 'Advisory mode active: recommendations do not fail CI by default.',
-    };
-}
-export function refreshPlanEnforcement(plan) {
-    return {
-        ...plan,
-        enforcement: evaluateEnforcement(plan.decision, plan.policy.applied),
-    };
-}
-export function buildPlanFromImpactReport(impact, policyOverride) {
-    if (impact.mode !== 'impact') {
-        throw new Error(`Plan generation requires impact report data, received mode=${impact.mode}`);
-    }
-    const policy = { ...DEFAULT_POLICY, ...(policyOverride || {}) };
-    const { p0, p1, p2 } = countPriority(impact.flows);
-    const confidence = computeConfidence(impact, p0, p1);
-    const runSet = pickRunSet(impact, p0, confidence, policy);
-    const decision = buildDecision(runSet.runSet, confidence, impact, policy);
-    const enforcement = evaluateEnforcement(decision, policy);
-    const requiredNewTests = impact.gaps.map((flow) => `${flow.id}: ${flow.name}`);
-    const gapDetails = impact.gaps.map((flow) => ({
-        id: flow.id,
-        name: flow.name,
-        priority: flow.priority,
-        reasons: (flow.reasons || []).slice(0, 5),
-        files: (flow.files || []).slice(0, 6),
-        existingTests: flow.existingTests && flow.existingTests.length > 0 ? flow.existingTests.slice(0, 3) : undefined,
-        missingScenarios: flow.missingScenarios && flow.missingScenarios.length > 0 ? flow.missingScenarios.slice(0, 5) : undefined,
-    }));
-    const coveredFlowIds = new Set(impact.gaps.map((g) => g.id));
-    const coveredFlows = impact.coverage
-        .filter((c) => c.coveredBy.length > 0 && !coveredFlowIds.has(c.flowId))
-        .map((c) => ({
-        id: c.flowId,
-        name: c.flowName,
-        priority: c.priority,
-        coveredBy: c.coveredBy.slice(0, 3),
-    }));
-    const sourceRunId = impact.runMetadata?.runId;
-    const runId = `plan-${sourceRunId || Date.now().toString(36)}`;
-    return {
-        schemaVersion: '1.0.0',
-        runId,
-        sourceRunId,
-        generatedAt: new Date().toISOString(),
-        source: 'impact',
-        runSet: runSet.runSet,
-        confidence,
-        reasons: runSet.reasons,
-        recommendedTests: impact.recommendedTests || [],
-        requiredNewTests,
-        gapDetails,
-        coveredFlows,
-        policy: {
-            riskyFiles: runSet.riskyFiles,
-            triggeredRules: runSet.triggeredRules,
-            applied: policy,
-        },
-        decision,
-        enforcement,
-        metrics: {
-            changedFiles: impact.changedFiles.length,
-            impactedFlows: impact.flows.length,
-            p0Flows: p0,
-            p1Flows: p1,
-            p2Flows: p2,
-            uncoveredP0P1Flows: impact.gaps.length,
-            warnings: impact.warnings.length,
-        },
-    };
-}
-export function attachDeveloperActions(plan, context) {
-    const safeSince = context.sinceRef ? ` --since "${context.sinceRef}"` : '';
-    const generateBaseCommand = context.configPath
-        ? `npx e2e-ai-agents approve-and-generate --config "${context.configPath}" --pipeline --pipeline-mcp --pipeline-mcp-only${safeSince}`
-        : `npx e2e-ai-agents approve-and-generate --path "${context.appPath}" --tests-root "${context.testsRoot}" --pipeline --pipeline-mcp --pipeline-mcp-only${safeSince}`;
-    const runRecommendedTests = plan.recommendedTests.length > 0
-        ? `node -e "const fs=require('fs'); const p=JSON.parse(fs.readFileSync('${context.testsRoot}/.e2e-ai-agents/plan.json','utf8')); const tests=p.recommendedTests.map((t)=>t.replace(/ \\(flags:.*\\)$/,'')); console.log(tests.join(' '));" | xargs npx playwright test`
-        : undefined;
-    return {
-        ...plan,
-        nextActions: {
-            requiresUserApprovalForGeneration: true,
-            runRecommendedTests,
-            runSmokeSuite: 'npx playwright test --grep @smoke --project=chrome',
-            runFullSuite: 'npx playwright test --project=chrome',
-            approveAndGenerate: generateBaseCommand,
-            generateMissingTests: generateBaseCommand,
-            healGeneratedTests: generateBaseCommand,
-            commitGeneratedTests: `npx e2e-ai-agents finalize-generated-tests --path "${context.appPath}" --tests-root "${context.testsRoot}" --commit-message "test(e2e): add generated coverage and healed specs"`,
-            openPullRequest: `npx e2e-ai-agents finalize-generated-tests --path "${context.appPath}" --tests-root "${context.testsRoot}" --create-pr`,
-        },
-    };
-}
-export function writePlanReport(appRoot, plan) {
-    const baseDir = join(appRoot, '.e2e-ai-agents');
-    mkdirSync(baseDir, { recursive: true });
-    const planPath = join(baseDir, 'plan.json');
-    writeFileSync(planPath, JSON.stringify(plan, null, 2), 'utf-8');
-    return planPath;
-}
-export function renderCiSummaryMarkdown(plan) {
-    const lines = [];
-    const { p0Flows, p1Flows, uncoveredP0P1Flows, changedFiles, impactedFlows } = plan.metrics;
-    const mustAddTests = plan.decision.action === 'must-add-tests';
-    const statusEmoji = mustAddTests ? '🔴' : plan.decision.action === 'safe-to-merge' ? '🟢' : '🟡';
-    lines.push(`## ${statusEmoji} E2E Coverage: ${plan.decision.title}`);
-    lines.push('');
-    lines.push(`${plan.decision.summary}`);
-    lines.push('');
-    lines.push(`**${changedFiles}** files changed → **${impactedFlows}** flows impacted` +
-        (p0Flows > 0 || p1Flows > 0 ? ` (P0: ${p0Flows}, P1: ${p1Flows})` : ''));
-    if (mustAddTests && plan.requiredNewTests.length > 0) {
-        lines.push('');
-        lines.push('### ⚠️ Add E2E tests for these uncovered P0/P1 flows');
-        lines.push('');
-        lines.push(`The following ${uncoveredP0P1Flows} flow(s) have no test coverage and must be covered before merge:`);
-        lines.push('');
-        for (const gap of plan.requiredNewTests) {
-            lines.push(`- ${gap}`);
-        }
-    }
-    return lines.join('\n');
-}
+import { join } from 'path';
 const PLAN_METRICS_EVENTS_PATH = '.e2e-ai-agents/metrics.jsonl';
 const PLAN_METRICS_SUMMARY_PATH = '.e2e-ai-agents/metrics-summary.json';
 function parsePlanMetricLine(line) {
@@ -433,10 +81,3 @@ export function appendPlanMetrics(appRoot, plan) {
     writeFileSync(summaryPath, JSON.stringify(summary, null, 2), 'utf-8');
     return { eventsPath, summaryPath };
 }
-export function writeCiSummary(appRoot, markdown, relativePath = '.e2e-ai-agents/ci-summary.md') {
-    const fullPath = join(appRoot, relativePath);
-    const dir = dirname(fullPath);
-    mkdirSync(dir, { recursive: true });
-    writeFileSync(fullPath, markdown, 'utf-8');
-    return fullPath;
-}

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/api.js

@@ -1,21 +1,16 @@
 // Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
 // See LICENSE.txt for license information.
-import { existsSync, readFileSync } from 'fs';
-import { join } from 'path';
 import { resolveConfig } from './agent/config.js';
-import { runGap, runImpact } from './agent/runner.js';
-import { appendPlanMetrics, attachDeveloperActions, buildPlanFromImpactReport, renderCiSummaryMarkdown, writeCiSummary, writePlanReport, } from './agent/plan.js';
-import { applyOperationalInsights } from './agent/operational_insights.js';
+import { appendPlanMetrics, } from './agent/plan.js';
+import { analyzeImpact as analyzeImpactV2 } from './engine/impact_engine.js';
+import { buildPlanFromImpact, renderCiSummaryMarkdown, writeCiSummary, writePlanReport, } from './engine/plan_builder.js';
+import { getChangedFiles } from './agent/git.js';
+import { loadDiffs } from './engine/diff_loader.js';
+import { enrichImpactWithAI } from './engine/ai_enrichment.js';
+import { AnthropicProvider } from './anthropic_provider.js';
 import { finalizeGeneratedTests } from './agent/handoff.js';
 import { ingestTraceabilityInput, } from './agent/traceability_ingest.js';
 import { captureTraceabilityInput, } from './agent/traceability_capture.js';
-function readReportJson(reportPath) {
-    if (!existsSync(reportPath)) {
-        throw new Error(`Expected report not found: ${reportPath}`);
-    }
-    const raw = readFileSync(reportPath, 'utf-8');
-    return JSON.parse(raw);
-}
 function resolveAgent(options, mode) {
     const cwd = options.cwd || process.cwd();
     const { config } = resolveConfig(cwd, options.configPath, {
@@ -27,63 +22,76 @@ function resolveAgent(options, mode) {
     }
     return config;
 }
-function reportPathFor(configPath, mode) {
-    return join(configPath, '.e2e-ai-agents', mode === 'impact' ? 'impact.json' : 'gap.json');
+export function handoffGeneratedTests(options) {
+    return finalizeGeneratedTests(options);
 }
-export async function analyzeImpact(options = {}) {
-    const config = resolveAgent(options, 'impact');
-    await runImpact(config, { apply: options.apply ?? false });
+export function ingestTraceability(options) {
+    const cwd = options.cwd || process.cwd();
+    const { config } = resolveConfig(cwd, options.configPath, {
+        path: options.path,
+        testsRoot: options.testsRoot,
+        mode: 'impact',
+    });
     const reportRoot = config.testsRoot || config.path;
-    const reportPath = reportPathFor(reportRoot, 'impact');
-    const report = readReportJson(reportPath);
-    return { report, reportPath };
+    return ingestTraceabilityInput(reportRoot, config.impact.traceability, options.payload, options.options);
 }
-export async function findGaps(options = {}) {
-    const config = resolveAgent(options, 'gap');
-    await runGap(config, { apply: options.apply ?? false });
+export function analyzeImpactDeterministic(options = {}) {
+    const config = resolveAgent(options, 'impact');
     const reportRoot = config.testsRoot || config.path;
-    const reportPath = reportPathFor(reportRoot, 'gap');
-    const report = readReportJson(reportPath);
-    return { report, reportPath };
+    const gitResult = getChangedFiles(config.path, config.git.since, { includeUncommitted: config.git.includeUncommitted });
+    return analyzeImpactV2(gitResult.files, {
+        testsRoot: reportRoot,
+        routeFamilies: config.routeFamilies,
+    });
 }
-export async function recommendTests(options = {}) {
+export function recommendTestsDeterministic(options = {}) {
     const config = resolveAgent(options, 'impact');
-    await runImpact(config, { apply: options.apply ?? false });
     const reportRoot = config.testsRoot || config.path;
-    const impactPath = reportPathFor(reportRoot, 'impact');
-    const report = readReportJson(impactPath);
-    const basePlan = buildPlanFromImpactReport(report, config.policy);
-    const withActions = attachDeveloperActions(basePlan, {
-        appPath: config.path,
+    const gitResult = getChangedFiles(config.path, config.git.since, { includeUncommitted: config.git.includeUncommitted });
+    const impact = analyzeImpactV2(gitResult.files, {
         testsRoot: reportRoot,
-        sinceRef: config.git.since,
+        routeFamilies: config.routeFamilies,
     });
-    const plan = applyOperationalInsights(withActions, reportRoot);
+    const plan = buildPlanFromImpact(impact, config.policy);
     const planPath = writePlanReport(reportRoot, plan);
     const ciSummaryMarkdown = renderCiSummaryMarkdown(plan);
     const ciSummaryPath = writeCiSummary(reportRoot, ciSummaryMarkdown);
     appendPlanMetrics(reportRoot, plan);
-    return {
-        report,
-        reportPath: impactPath,
-        plan,
-        planPath,
-        ciSummaryMarkdown,
-        ciSummaryPath,
-    };
+    return { impact, plan, planPath, ciSummaryMarkdown, ciSummaryPath };
 }
-export function handoffGeneratedTests(options) {
-    return finalizeGeneratedTests(options);
-}
-export function ingestTraceability(options) {
-    const cwd = options.cwd || process.cwd();
-    const { config } = resolveConfig(cwd, options.configPath, {
-        path: options.path,
-        testsRoot: options.testsRoot,
-        mode: 'impact',
-    });
+export async function recommendTestsAI(options = {}) {
+    const config = resolveAgent(options, 'impact');
     const reportRoot = config.testsRoot || config.path;
-    return ingestTraceabilityInput(reportRoot, config.impact.traceability, options.payload, options.options);
+    const gitResult = getChangedFiles(config.path, config.git.since, { includeUncommitted: config.git.includeUncommitted });
+    const impact = analyzeImpactV2(gitResult.files, {
+        testsRoot: reportRoot,
+        routeFamilies: config.routeFamilies,
+    });
+    const apiKey = process.env.ANTHROPIC_API_KEY;
+    let aiEnrichment;
+    if (apiKey) {
+        const diffs = loadDiffs(config.path, config.git.since, gitResult.files);
+        const provider = new AnthropicProvider({ apiKey });
+        // Collect all known spec paths from impacted features
+        const specSet = new Set();
+        for (const feature of impact.impactedFeatures) {
+            for (const s of feature.playwrightSpecs) {
+                specSet.add(s);
+            }
+        }
+        aiEnrichment = await enrichImpactWithAI({
+            deterministicImpact: impact,
+            diffs,
+            provider,
+            specList: [...specSet],
+        });
+    }
+    const plan = buildPlanFromImpact(impact, config.policy, aiEnrichment);
+    const planPath = writePlanReport(reportRoot, plan);
+    const ciSummaryMarkdown = renderCiSummaryMarkdown(plan);
+    const ciSummaryPath = writeCiSummary(reportRoot, ciSummaryMarkdown);
+    appendPlanMetrics(reportRoot, plan);
+    return { impact, plan, planPath, ciSummaryMarkdown, ciSummaryPath, aiEnrichment };
 }
 export function captureTraceability(options) {
     const cwd = options.cwd || process.cwd();