@yasserkhanorg/impact-gate 2.0.0

package/dist/esm/agent/native_flow.js

@@ -0,0 +1,175 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'fs';
+import { join, resolve } from 'path';
+import { isPathWithinRoot, normalizePath } from './utils.js';
+import { createMcpStatus, toSafeSlug, buildNativeStrategyOrder } from './pipeline_utils.js';
+import { validateGeneratedSpecContent, createNativePlaywrightSpec } from './spec_generator.js';
+import { resolvePlaywrightBinary } from './process_runner.js';
+import { runPlaywrightListValidation } from './validation_runner.js';
+import { buildApiSurfaceCatalog } from './api_catalog.js';
+import { resolveAgentSeedSpec } from './llm_agents_flow.js';
+export function runPackageNativeFlow(testsRoot, flow, pipeline, outputDir, testFile, playwrightBinary, apiSurface) {
+    const flowId = flow.id;
+    const flowName = flow.name;
+    const existingFile = existsSync(testFile);
+    const originalContent = existingFile ? readFileSync(testFile, 'utf-8') : null;
+    if (existingFile && !pipeline.heal) {
+        return {
+            flowId,
+            flowName,
+            generatedDir: outputDir,
+            generateStatus: 'skipped',
+        };
+    }
+    const slug = toSafeSlug(flow.id);
+    const strategies = buildNativeStrategyOrder(flow);
+    const attempts = [];
+    const candidates = [];
+    if (pipeline.heal && originalContent !== null) {
+        candidates.push({
+            label: 'existing',
+            content: originalContent,
+            write: false,
+        });
+    }
+    for (const strategy of strategies) {
+        candidates.push({
+            label: strategy,
+            strategy,
+            content: createNativePlaywrightSpec(flow, slug, strategy),
+            write: true,
+        });
+    }
+    mkdirSync(outputDir, { recursive: true });
+    let wroteNewFile = false;
+    for (let i = 0; i < candidates.length; i += 1) {
+        const candidate = candidates[i];
+        if (candidate.write) {
+            writeFileSync(testFile, candidate.content, 'utf-8');
+            wroteNewFile = true;
+        }
+        const currentContent = candidate.write ? candidate.content : (originalContent || '');
+        const qualityIssues = validateGeneratedSpecContent(currentContent, apiSurface);
+        if (qualityIssues.length > 0) {
+            attempts.push(`${candidate.label}: ${qualityIssues.map((issue) => issue.message).join(' ')}`);
+            if (pipeline.heal && i < candidates.length - 1) {
+                continue;
+            }
+            if (originalContent !== null) {
+                writeFileSync(testFile, originalContent, 'utf-8');
+            }
+            else if (wroteNewFile && existsSync(testFile)) {
+                rmSync(testFile, { force: true });
+            }
+            return {
+                flowId,
+                flowName,
+                generatedDir: outputDir,
+                generateStatus: 'failed',
+                healStatus: pipeline.heal ? 'failed' : undefined,
+                error: `Quality checks failed. Attempts: ${attempts.join(' | ')}`,
+            };
+        }
+        if (pipeline.heal) {
+            const validation = runPlaywrightListValidation(testsRoot, testFile, pipeline, playwrightBinary);
+            if (validation.status === 'failed') {
+                attempts.push(`${candidate.label}: ${validation.detail || 'playwright validation failed'}`);
+                if (i < candidates.length - 1) {
+                    continue;
+                }
+                if (originalContent !== null) {
+                    writeFileSync(testFile, originalContent, 'utf-8');
+                }
+                else if (wroteNewFile && existsSync(testFile)) {
+                    rmSync(testFile, { force: true });
+                }
+                return {
+                    flowId,
+                    flowName,
+                    generatedDir: outputDir,
+                    generateStatus: 'failed',
+                    healStatus: 'failed',
+                    error: `Heal validation failed. Attempts: ${attempts.join(' | ')}`,
+                };
+            }
+        }
+        return {
+            flowId,
+            flowName,
+            generatedDir: outputDir,
+            generateStatus: candidate.write ? 'success' : 'skipped',
+            healStatus: pipeline.heal ? 'success' : undefined,
+        };
+    }
+    if (originalContent !== null) {
+        writeFileSync(testFile, originalContent, 'utf-8');
+    }
+    else if (wroteNewFile && existsSync(testFile)) {
+        rmSync(testFile, { force: true });
+    }
+    return {
+        flowId,
+        flowName,
+        generatedDir: outputDir,
+        generateStatus: 'failed',
+        healStatus: pipeline.heal ? 'failed' : undefined,
+        error: attempts.length > 0 ? attempts.join(' | ') : 'No generation candidates were available.',
+    };
+}
+export function runPackageNativePipeline(testsRoot, flows, pipeline, baseWarnings = []) {
+    const warningSet = new Set(baseWarnings);
+    const mcp = createMcpStatus('package-native', Boolean(pipeline.mcp));
+    const playwrightBinary = pipeline.heal ? resolvePlaywrightBinary(testsRoot) : null;
+    const seedFile = resolveAgentSeedSpec(testsRoot) || 'specs/seed.spec.ts';
+    const apiSurface = buildApiSurfaceCatalog(testsRoot, seedFile);
+    if (pipeline.heal && !playwrightBinary) {
+        warningSet.add('Playwright binary was not found. Heal uses static quality checks without runtime compile validation.');
+    }
+    const results = [];
+    const outputBase = resolve(testsRoot, pipeline.outputDir || 'specs/functional/ai-assisted');
+    if (!isPathWithinRoot(testsRoot, outputBase)) {
+        warningSet.add(`Pipeline outputDir resolves outside testsRoot and was blocked: ${pipeline.outputDir}`);
+        return { runner: 'unknown', results, warnings: Array.from(warningSet), mcp: createMcpStatus('unknown', Boolean(pipeline.mcp)) };
+    }
+    for (const flow of flows) {
+        if (flow.priority !== 'P0' && flow.priority !== 'P1') {
+            continue;
+        }
+        const slug = toSafeSlug(flow.id);
+        const outputDir = normalizePath(join(outputBase, slug));
+        if (!isPathWithinRoot(testsRoot, outputDir)) {
+            results.push({
+                flowId: flow.id,
+                flowName: flow.name,
+                generatedDir: outputDir,
+                generateStatus: 'failed',
+                error: 'output directory resolves outside testsRoot',
+            });
+            continue;
+        }
+        if (pipeline.dryRun) {
+            results.push({
+                flowId: flow.id,
+                flowName: flow.name,
+                generatedDir: outputDir,
+                generateStatus: 'skipped',
+                healStatus: pipeline.heal ? 'skipped' : undefined,
+            });
+            continue;
+        }
+        const testFile = normalizePath(join(outputDir, `${slug}.spec.ts`));
+        if (!isPathWithinRoot(testsRoot, testFile)) {
+            results.push({
+                flowId: flow.id,
+                flowName: flow.name,
+                generatedDir: outputDir,
+                generateStatus: 'failed',
+                error: 'generated test path resolves outside testsRoot',
+            });
+            continue;
+        }
+        results.push(runPackageNativeFlow(testsRoot, flow, pipeline, outputDir, testFile, playwrightBinary, apiSurface));
+    }
+    return { runner: 'package-native', results, warnings: Array.from(warningSet), mcp };
+}

package/dist/esm/agent/pipeline.js

@@ -0,0 +1,256 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+import { existsSync } from 'fs';
+import { dirname, join, relative, resolve } from 'path';
+import { isPathWithinRoot, normalizePath } from './utils.js';
+import { createMcpStatus, finalizePipelineSummary, buildSyntheticFlowFromSpecTarget } from './pipeline_utils.js';
+import { buildApiSurfaceCatalog } from './api_catalog.js';
+import { resolvePlaywrightBinary, runCommand, summarizeCommandOutput } from './process_runner.js';
+import { runPackageNativeFlow, runPackageNativePipeline } from './native_flow.js';
+import { findDisallowedDescribeFiles, resolveAgentSeedSpec, runPlaywrightAgentsPipeline } from './llm_agents_flow.js';
+function hasE2eTestGenCLI(testsRoot) {
+    const cliPath = join(testsRoot, 'e2e-test-gen-cli.ts');
+    return existsSync(cliPath) ? cliPath : null;
+}
+export function runTargetedSpecHeal(testsRoot, targets, pipeline) {
+    const warnings = new Set();
+    const results = [];
+    const mcp = createMcpStatus('package-native', Boolean(pipeline.mcp));
+    if (targets.length === 0) {
+        warnings.add('No targeted specs provided for heal.');
+        return finalizePipelineSummary({
+            runner: 'package-native',
+            results,
+            warnings: Array.from(warnings),
+            mcp,
+        });
+    }
+    const playwrightBinary = pipeline.heal ? resolvePlaywrightBinary(testsRoot) : null;
+    const seedFile = resolveAgentSeedSpec(testsRoot) || 'specs/seed.spec.ts';
+    const apiSurface = buildApiSurfaceCatalog(testsRoot, seedFile);
+    if (pipeline.heal && !playwrightBinary) {
+        warnings.add('Playwright binary was not found. Targeted heal uses static quality checks without runtime compile validation.');
+    }
+    for (const target of targets) {
+        const inputPath = target.specPath || '';
+        const absoluteSpecPath = normalizePath(resolve(testsRoot, inputPath));
+        if (!isPathWithinRoot(testsRoot, absoluteSpecPath)) {
+            results.push({
+                flowId: inputPath || 'unknown',
+                flowName: inputPath || 'Unknown Spec',
+                generatedDir: normalizePath(dirname(absoluteSpecPath)),
+                generateStatus: 'failed',
+                healStatus: pipeline.heal ? 'failed' : undefined,
+                error: `Targeted spec resolves outside testsRoot: ${inputPath}`,
+            });
+            continue;
+        }
+        if (!existsSync(absoluteSpecPath)) {
+            results.push({
+                flowId: inputPath || 'unknown',
+                flowName: inputPath || 'Unknown Spec',
+                generatedDir: normalizePath(dirname(absoluteSpecPath)),
+                generateStatus: 'failed',
+                healStatus: pipeline.heal ? 'failed' : undefined,
+                error: `Targeted spec does not exist: ${inputPath}`,
+            });
+            continue;
+        }
+        const relativeSpecPath = normalizePath(relative(testsRoot, absoluteSpecPath));
+        if (!/\.(spec|test)\.[tj]sx?$/.test(relativeSpecPath)) {
+            warnings.add(`Skipping non-spec target path: ${relativeSpecPath}`);
+            results.push({
+                flowId: relativeSpecPath,
+                flowName: relativeSpecPath,
+                generatedDir: normalizePath(dirname(absoluteSpecPath)),
+                generateStatus: 'skipped',
+                healStatus: pipeline.heal ? 'skipped' : undefined,
+            });
+            continue;
+        }
+        if (pipeline.dryRun) {
+            results.push({
+                flowId: relativeSpecPath,
+                flowName: relativeSpecPath,
+                generatedDir: normalizePath(dirname(absoluteSpecPath)),
+                generateStatus: 'skipped',
+                healStatus: pipeline.heal ? 'skipped' : undefined,
+            });
+            continue;
+        }
+        const syntheticFlow = buildSyntheticFlowFromSpecTarget(relativeSpecPath, target);
+        results.push(runPackageNativeFlow(testsRoot, syntheticFlow, pipeline, normalizePath(dirname(absoluteSpecPath)), absoluteSpecPath, playwrightBinary, apiSurface));
+    }
+    return finalizePipelineSummary({
+        runner: 'package-native',
+        results,
+        warnings: Array.from(warnings),
+        mcp,
+    });
+}
+export function runPlaywrightPipeline(testsRoot, flows, pipeline) {
+    const mcpFallbackWarnings = [];
+    // MCP-only mode requires MCP to be enabled
+    if (pipeline.mcpOnly && !pipeline.mcp) {
+        const warnings = [
+            '❌ MCP-Only Mode Error: --pipeline-mcp-only requires --pipeline-mcp flag',
+            'Run with: npm run gen:tests -- --pipeline-mcp',
+        ];
+        return finalizePipelineSummary({
+            runner: 'unknown',
+            results: [],
+            warnings,
+            mcp: createMcpStatus('unknown', false),
+        });
+    }
+    if (pipeline.mcp) {
+        const agentsSummary = runPlaywrightAgentsPipeline(testsRoot, flows, pipeline);
+        if (agentsSummary.runner !== 'unknown' || agentsSummary.results.length > 0) {
+            return finalizePipelineSummary(agentsSummary);
+        }
+        // Handle strict MCP-only mode
+        if (pipeline.mcpOnly) {
+            const warnings = [
+                ...agentsSummary.warnings,
+                '❌ MCP-Only Mode Error: Claude Code CLI / Playwright Agents MCP is not available',
+                'Please install Claude Code CLI: brew install anthropic/tap/claude-code',
+                'Or check that the MCP server is properly configured',
+            ];
+            return finalizePipelineSummary({
+                runner: 'unknown',
+                results: agentsSummary.results,
+                warnings,
+                mcp: createMcpStatus('unknown', true),
+            });
+        }
+        if (!pipeline.mcpAllowFallback) {
+            const warnings = [
+                ...agentsSummary.warnings,
+                'Official Playwright MCP mode is strict; fallback generation is disabled unless pipeline.mcpAllowFallback=true.',
+            ];
+            return finalizePipelineSummary({
+                runner: 'unknown',
+                results: agentsSummary.results,
+                warnings,
+                mcp: createMcpStatus('unknown', true),
+            });
+        }
+        mcpFallbackWarnings.push(...agentsSummary.warnings);
+    }
+    const cliPath = hasE2eTestGenCLI(testsRoot);
+    if (!cliPath) {
+        return finalizePipelineSummary(runPackageNativePipeline(testsRoot, flows, pipeline, mcpFallbackWarnings));
+    }
+    const warnings = [...mcpFallbackWarnings];
+    const results = [];
+    const outputBase = resolve(testsRoot, pipeline.outputDir || 'specs/functional/ai-assisted');
+    if (!isPathWithinRoot(testsRoot, outputBase)) {
+        warnings.push(`Pipeline outputDir resolves outside testsRoot and was blocked: ${pipeline.outputDir}`);
+        return finalizePipelineSummary({
+            runner: 'unknown',
+            results,
+            warnings,
+            mcp: createMcpStatus('unknown', Boolean(pipeline.mcp)),
+        });
+    }
+    for (const flow of flows) {
+        if (flow.priority !== 'P0' && flow.priority !== 'P1') {
+            continue;
+        }
+        const slug = flow.id.replace(/[^a-zA-Z0-9._-]+/g, '-');
+        const outputDir = normalizePath(join(outputBase, slug));
+        if (!isPathWithinRoot(testsRoot, outputDir)) {
+            results.push({
+                flowId: flow.id,
+                flowName: flow.name,
+                generatedDir: outputDir,
+                generateStatus: 'failed',
+                error: 'output directory resolves outside testsRoot',
+            });
+            continue;
+        }
+        if (pipeline.dryRun) {
+            results.push({
+                flowId: flow.id,
+                flowName: flow.name,
+                generatedDir: outputDir,
+                generateStatus: 'skipped',
+                healStatus: 'skipped',
+            });
+            continue;
+        }
+        const generateArgs = ['tsx', cliPath, 'generate', flow.name, '--output', outputDir, '--scenarios', `${pipeline.scenarios}`];
+        if (pipeline.baseUrl) {
+            generateArgs.push('--base-url', pipeline.baseUrl);
+        }
+        if (pipeline.headless) {
+            generateArgs.push('--headless');
+        }
+        if (pipeline.browser) {
+            generateArgs.push('--browser', pipeline.browser);
+        }
+        if (pipeline.project) {
+            generateArgs.push('--project', pipeline.project);
+        }
+        if (pipeline.parallel) {
+            generateArgs.push('--parallel');
+        }
+        if (pipeline.mcp) {
+            generateArgs.push('--mcp');
+        }
+        const generateResult = runCommand('npx', generateArgs, testsRoot);
+        if (generateResult.status !== 0) {
+            results.push({
+                flowId: flow.id,
+                flowName: flow.name,
+                generatedDir: outputDir,
+                generateStatus: 'failed',
+                error: summarizeCommandOutput(generateResult.stdout, generateResult.stderr) || generateResult.error || 'generate failed',
+            });
+            continue;
+        }
+        let healStatus = 'skipped';
+        if (pipeline.heal) {
+            const healArgs = ['tsx', cliPath, 'heal', outputDir];
+            if (pipeline.browser) {
+                healArgs.push('--browser', pipeline.browser);
+            }
+            if (pipeline.project) {
+                healArgs.push('--project', pipeline.project);
+            }
+            if (pipeline.parallel) {
+                healArgs.push('--parallel');
+            }
+            if (pipeline.mcp) {
+                healArgs.push('--mcp');
+            }
+            const healResult = runCommand('npx', healArgs, testsRoot);
+            healStatus = healResult.status === 0 ? 'success' : 'failed';
+        }
+        const disallowedDescribeFiles = findDisallowedDescribeFiles(outputDir);
+        if (disallowedDescribeFiles.length > 0) {
+            results.push({
+                flowId: flow.id,
+                flowName: flow.name,
+                generatedDir: outputDir,
+                generateStatus: 'failed',
+                healStatus,
+                error: `Generated tests contain test.describe (disallowed): ${disallowedDescribeFiles.join(', ')}`,
+            });
+            continue;
+        }
+        results.push({
+            flowId: flow.id,
+            flowName: flow.name,
+            generatedDir: outputDir,
+            generateStatus: 'success',
+            healStatus,
+        });
+    }
+    return finalizePipelineSummary({
+        runner: 'e2e-test-gen',
+        results,
+        warnings,
+        mcp: createMcpStatus('e2e-test-gen', Boolean(pipeline.mcp)),
+    });
+}

package/dist/esm/agent/pipeline_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/pipeline_utils.js

@@ -0,0 +1,146 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+import { basename } from 'path';
+import { baseNameWithoutExt, normalizePath, titleCase, tokenize, uniqueTokens } from './utils.js';
+export function createMcpStatus(backend, requested) {
+    return {
+        requested,
+        active: requested && (backend === 'e2e-test-gen' || backend === 'playwright-agents'),
+        backend,
+    };
+}
+export function classifyPipelineFailure(result) {
+    if (result.failureCategory || result.failureCode) {
+        return result;
+    }
+    if (!result.error) {
+        return result;
+    }
+    const errorText = result.error.toLowerCase();
+    if (errorText.includes('etimedout') || errorText.includes('timed out')) {
+        return { ...result, failureCategory: 'environment', failureCode: 'mcp_timeout' };
+    }
+    if (errorText.includes('outside testsroot')) {
+        return { ...result, failureCategory: 'path-safety', failureCode: 'path_outside_tests_root' };
+    }
+    if (errorText.includes('playwright binary') || errorText.includes('not found')) {
+        return { ...result, failureCategory: 'environment', failureCode: 'dependency_missing' };
+    }
+    if (errorText.includes('compile validation')) {
+        return { ...result, failureCategory: 'validation', failureCode: 'compile_validation_failed' };
+    }
+    if (errorText.includes('runtime validation') || errorText.includes('playwright test failed')) {
+        return { ...result, failureCategory: 'runtime', failureCode: 'runtime_validation_failed' };
+    }
+    if (errorText.includes('quality checks failed') || errorText.includes('invalid test content')) {
+        return { ...result, failureCategory: 'quality', failureCode: 'quality_guard_failed' };
+    }
+    if (errorText.includes('generate failed') || errorText.includes('did not produce expected test file')) {
+        return { ...result, failureCategory: 'generation', failureCode: 'generation_failed' };
+    }
+    return { ...result, failureCategory: 'unknown', failureCode: 'unknown' };
+}
+export function finalizePipelineSummary(summary) {
+    return {
+        ...summary,
+        results: summary.results.map(classifyPipelineFailure),
+    };
+}
+export function toSafeSlug(value) {
+    return value.replace(/[^a-zA-Z0-9._-]+/g, '-').replace(/^-+|-+$/g, '') || 'flow';
+}
+export function stripSpecSuffix(value) {
+    return value.replace(/\.(spec|test)\.[^.]+$/i, '').replace(/\.[^.]+$/, '');
+}
+export function buildSyntheticFlowFromSpecTarget(relativeSpecPath, target) {
+    const normalizedSpecPath = normalizePath(relativeSpecPath);
+    const noSuffix = stripSpecSuffix(normalizedSpecPath);
+    const flowId = toSafeSlug(noSuffix.replace(/\//g, '.'));
+    const base = baseNameWithoutExt(stripSpecSuffix(basename(normalizedSpecPath)));
+    const flowName = titleCase(base.replace(/[._-]+/g, ' ')) || 'Recovered Spec';
+    const keywords = uniqueTokens(tokenize(noSuffix.replace(/[/.]/g, ' ')));
+    const reasons = [
+        `Playwright report marked this spec as ${target.status || 'unstable'}.`,
+        target.reason || `Auto-heal target: ${normalizedSpecPath}`,
+    ];
+    return {
+        id: flowId,
+        name: flowName,
+        kind: 'flow',
+        score: target.status === 'failed' ? 12 : 9,
+        priority: target.status === 'failed' ? 'P0' : 'P1',
+        reasons,
+        keywords,
+        files: [normalizedSpecPath],
+    };
+}
+export function firstFlowFiles(flow) {
+    return (flow.files || []).filter(Boolean).slice(0, 5);
+}
+export function buildNativeStrategyOrder(flow) {
+    const flowId = (flow.id || '').toLowerCase();
+    const haystack = [
+        flow.id,
+        flow.name,
+        ...(flow.files || []),
+        ...(flow.reasons || []),
+        ...(flow.keywords || []),
+    ].join(' ').toLowerCase();
+    const strategies = [];
+    if (flowId.includes('search')) {
+        strategies.push('search-baseline');
+    }
+    if (flowId.includes('threads') || flowId.includes('thread')) {
+        strategies.push('thread-reply');
+    }
+    if (flowId.includes('channels.lifecycle')) {
+        strategies.push('lifecycle-channel');
+    }
+    if (flowId.includes('channels.settings')) {
+        strategies.push('channel-settings');
+    }
+    if (flowId.includes('channels.switch')) {
+        strategies.push('channel-switch');
+    }
+    if (flowId.includes('messaging.markdown')) {
+        strategies.push('markdown-post');
+    }
+    if (flowId.includes('messaging.mentions')) {
+        strategies.push('mentions-post');
+    }
+    if (flowId.includes('messaging.realtime')) {
+        strategies.push('realtime-post');
+    }
+    if (/(thread|reply|rhs|sidebar[_-]?right)/.test(haystack)) {
+        strategies.push('thread-reply');
+    }
+    if (/(create|join|leave|invite)/.test(haystack)) {
+        strategies.push('lifecycle-channel');
+    }
+    if (/(settings|preferences)/.test(haystack)) {
+        strategies.push('channel-settings');
+    }
+    if (/(switch|quick\\s*switch)/.test(haystack)) {
+        strategies.push('channel-switch');
+    }
+    if (/(markdown|format)/.test(haystack)) {
+        strategies.push('markdown-post');
+    }
+    if (/(mention|@)/.test(haystack)) {
+        strategies.push('mentions-post');
+    }
+    if (/(realtime|websocket|presence)/.test(haystack)) {
+        strategies.push('realtime-post');
+    }
+    if (/(search|find|spotlight)/.test(haystack)) {
+        strategies.push('search-baseline');
+    }
+    if (/(message|post|realtime|websocket|chat)/.test(haystack)) {
+        strategies.push('message-post');
+    }
+    if (/(channel|navigation|sidebar|switch)/.test(haystack)) {
+        strategies.push('channel-baseline');
+    }
+    strategies.push('generic-baseline');
+    return Array.from(new Set(strategies));
+}

package/dist/esm/agent/plan.js

@@ -0,0 +1,83 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+import { appendFileSync, existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
+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) {
+    const trimmed = line.trim();
+    if (!trimmed) {
+        return null;
+    }
+    try {
+        const parsed = JSON.parse(trimmed);
+        if (!parsed || parsed.schemaVersion !== '1.0.0' || typeof parsed.runId !== 'string') {
+            return null;
+        }
+        return parsed;
+    }
+    catch {
+        return null;
+    }
+}
+export function appendPlanMetrics(appRoot, plan) {
+    const baseDir = join(appRoot, '.e2e-ai-agents');
+    mkdirSync(baseDir, { recursive: true });
+    const eventsPath = join(appRoot, PLAN_METRICS_EVENTS_PATH);
+    const summaryPath = join(appRoot, PLAN_METRICS_SUMMARY_PATH);
+    const event = {
+        schemaVersion: '1.0.0',
+        timestamp: new Date().toISOString(),
+        runId: plan.runId,
+        sourceRunId: plan.sourceRunId,
+        action: plan.decision.action,
+        runSet: plan.runSet,
+        confidence: plan.confidence,
+        changedFiles: plan.metrics.changedFiles,
+        impactedFlows: plan.metrics.impactedFlows,
+        uncoveredP0P1Flows: plan.metrics.uncoveredP0P1Flows,
+        warnings: plan.metrics.warnings,
+        enforcementMode: plan.enforcement.mode,
+        enforcementShouldFail: plan.enforcement.shouldFail,
+    };
+    appendFileSync(eventsPath, `${JSON.stringify(event)}\n`, 'utf-8');
+    const allEvents = existsSync(eventsPath)
+        ? readFileSync(eventsPath, 'utf-8')
+            .split('\n')
+            .map(parsePlanMetricLine)
+            .filter((item) => Boolean(item))
+        : [event];
+    const byAction = {
+        'run-now': 0,
+        'must-add-tests': 0,
+        'safe-to-merge': 0,
+    };
+    const byRunSet = {
+        smoke: 0,
+        targeted: 0,
+        full: 0,
+    };
+    let totalConfidence = 0;
+    let blockingRecommendations = 0;
+    for (const metricEvent of allEvents) {
+        byAction[metricEvent.action] += 1;
+        byRunSet[metricEvent.runSet] += 1;
+        totalConfidence += metricEvent.confidence;
+        if (metricEvent.enforcementShouldFail) {
+            blockingRecommendations += 1;
+        }
+    }
+    const totalRuns = allEvents.length;
+    const summary = {
+        schemaVersion: '1.0.0',
+        generatedAt: new Date().toISOString(),
+        totalRuns,
+        averageConfidence: totalRuns > 0 ? Number((totalConfidence / totalRuns).toFixed(2)) : 0,
+        byAction,
+        byRunSet,
+        blockingRecommendations,
+        blockingRate: totalRuns > 0 ? Number((blockingRecommendations / totalRuns).toFixed(4)) : 0,
+    };
+    writeFileSync(summaryPath, JSON.stringify(summary, null, 2), 'utf-8');
+    return { eventsPath, summaryPath };
+}