@yasserkhanorg/impact-gate 2.0.0

package/dist/cli/commands/crew.js

@@ -0,0 +1,255 @@
+"use strict";
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runCrewCommand = runCrewCommand;
+/**
+ * CLI command: crew — runs multi-agent QA analysis workflows.
+ */
+const fs_1 = require("fs");
+const path_1 = require("path");
+const config_js_1 = require("../../agent/config.js");
+const orchestrator_js_1 = require("../../crew/orchestrator.js");
+const response_cache_js_1 = require("../../cache/response_cache.js");
+const workflows_js_1 = require("../../crew/workflows.js");
+const impact_analyst_js_1 = require("../../agents/impact-analyst.js");
+const generator_js_1 = require("../../agents/generator.js");
+const executor_js_1 = require("../../agents/executor.js");
+const healer_js_1 = require("../../agents/healer.js");
+const strategist_js_1 = require("../../agents/strategist.js");
+const test_designer_js_1 = require("../../agents/test-designer.js");
+const cross_impact_js_1 = require("../../agents/cross-impact.js");
+const regression_advisor_js_1 = require("../../agents/regression-advisor.js");
+const VALID_WORKFLOWS = ['full-qa', 'quick-check', 'design-only'];
+async function runCrewCommand(args, autoConfig) {
+    if (!args.path && !autoConfig) {
+        console.error('Error: --path is required for crew command');
+        process.exit(1);
+    }
+    const { config } = (0, config_js_1.resolveConfig)(process.cwd(), autoConfig, {
+        path: args.path,
+        profile: args.profile,
+        testsRoot: args.testsRoot,
+        mode: 'impact',
+        gitSince: args.gitSince,
+        llmProvider: args.llmProvider,
+    });
+    const testsRoot = config.testsRoot || config.path;
+    const rawWorkflow = args.crewWorkflow || 'full-qa';
+    if (!VALID_WORKFLOWS.includes(rawWorkflow)) {
+        console.error(`Error: invalid workflow '${rawWorkflow}'. Valid: ${VALID_WORKFLOWS.join(', ')}`);
+        process.exit(1);
+    }
+    const workflowName = rawWorkflow;
+    // Degraded mode: skip all AI features, deterministic analysis only
+    const degraded = args.degradedMode || process.env.E2E_AGENTS_DEGRADED === 'true';
+    if (degraded) {
+        console.log('Running in degraded mode — deterministic analysis only, no LLM calls.');
+    }
+    // Prune expired cache entries to prevent unbounded growth on CI
+    try {
+        const cache = new response_cache_js_1.ResponseCache(testsRoot);
+        const pruned = cache.prune();
+        if (pruned > 0) {
+            console.log(`Cache: pruned ${pruned} expired entries.`);
+        }
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        console.error(`Cache prune warning: ${msg}`);
+    }
+    const crewConfig = {
+        appPath: config.path,
+        testsRoot,
+        gitSince: args.gitSince || config.git.since,
+        routeFamilies: config.routeFamilies,
+        apiSurface: config.apiSurface,
+        workflow: workflowName,
+        providerOverride: args.llmProvider,
+        budgetUSD: args.budgetUSD,
+        dryRun: degraded || args.dryRun,
+        plugins: args.plugins,
+    };
+    // Create orchestrator and register all agents
+    const orchestrator = new orchestrator_js_1.CrewOrchestrator();
+    orchestrator.registerAgent(new impact_analyst_js_1.ImpactAnalystAgent());
+    orchestrator.registerAgent(new generator_js_1.GeneratorAgent());
+    orchestrator.registerAgent(new executor_js_1.ExecutorAgent());
+    orchestrator.registerAgent(new healer_js_1.HealerAgent());
+    orchestrator.registerAgent(new strategist_js_1.StrategistAgent());
+    orchestrator.registerAgent(new test_designer_js_1.TestDesignerAgent());
+    orchestrator.registerAgent(new cross_impact_js_1.CrossImpactAgent());
+    orchestrator.registerAgent(new regression_advisor_js_1.RegressionAdvisorAgent());
+    let result;
+    try {
+        result = await orchestrator.run(crewConfig);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(`Crew workflow failed: ${message}`);
+        process.exit(1);
+    }
+    const ctx = result.context;
+    // Dry-run output
+    if (result.dryRun) {
+        printDryRunOutput(result, workflowName, args.jsonOutput);
+        return;
+    }
+    // Write crew metrics to metrics.jsonl for cost-report
+    if (ctx.usage.requestCount > 0) {
+        try {
+            const baseDir = (0, path_1.join)(testsRoot, '.e2e-ai-agents');
+            (0, fs_1.mkdirSync)(baseDir, { recursive: true });
+            const metricsPath = (0, path_1.join)(baseDir, 'metrics.jsonl');
+            const crewMetric = {
+                type: 'crew-run',
+                timestamp: new Date().toISOString(),
+                workflow: workflowName,
+                totalCost: ctx.usage.totalCost,
+                totalTokens: ctx.usage.totalTokens,
+                totalInputTokens: ctx.usage.totalInputTokens,
+                totalOutputTokens: ctx.usage.totalOutputTokens,
+                agentUsage: ctx.agentUsage,
+            };
+            (0, fs_1.appendFileSync)(metricsPath, `${JSON.stringify(crewMetric)}\n`, 'utf-8');
+        }
+        catch {
+            // Non-fatal: metrics writing should not break the workflow
+        }
+    }
+    // JSON output mode
+    if (args.jsonOutput) {
+        const jsonReport = {
+            workflow: workflowName,
+            changedFiles: ctx.changedFiles.length,
+            impactedFlows: ctx.impactedFlows,
+            strategyEntries: ctx.strategyEntries,
+            testDesigns: ctx.testDesigns,
+            crossImpacts: ctx.crossImpacts,
+            regressionRisks: ctx.regressionRisks,
+            findings: ctx.findings,
+            generatedSpecs: ctx.generatedSpecs.map((s) => ({ flowId: s.flowId, specPath: s.specPath, mode: s.mode, written: s.written })),
+            usage: { cost: ctx.usage.totalCost, requests: ctx.usage.requestCount, tokens: ctx.usage.totalTokens },
+            timings: result.timings,
+            warnings: result.warnings,
+        };
+        console.log(JSON.stringify(jsonReport, null, 2));
+        return;
+    }
+    // Human-readable output
+    console.log(`Crew workflow: ${workflowName}`);
+    console.log(`Changed files: ${ctx.changedFiles.length}`);
+    console.log(`Impacted flows: ${ctx.impactedFlows.length}`);
+    console.log(`Strategy entries: ${ctx.strategyEntries.length}`);
+    console.log(`Test designs: ${ctx.testDesigns.length} (${ctx.testDesigns.reduce((sum, td) => sum + td.testCases.length, 0)} test cases)`);
+    console.log(`Cross-impacts: ${ctx.crossImpacts.length}`);
+    console.log(`Regression risks: ${ctx.regressionRisks.length}`);
+    console.log(`Findings: ${ctx.findings.length}`);
+    console.log(`Generated specs: ${ctx.generatedSpecs.length}`);
+    console.log(`Cost: $${ctx.usage.totalCost.toFixed(4)}`);
+    if (ctx.strategyEntries.length > 0) {
+        console.log('\nTest Strategy:');
+        for (const entry of ctx.strategyEntries) {
+            console.log(`  ${entry.priority} ${entry.flowName} → ${entry.approach} [${entry.testCategories.join(', ')}]`);
+        }
+    }
+    if (ctx.testDesigns.length > 0) {
+        console.log('\nTest Designs:');
+        for (const design of ctx.testDesigns) {
+            console.log(`  ${design.flowName}: ${design.testCases.length} test cases`);
+            for (const tc of design.testCases) {
+                console.log(`    [${tc.type}] ${tc.name} (${tc.priority})`);
+            }
+        }
+    }
+    if (ctx.crossImpacts.length > 0) {
+        console.log('\nCross-Family Impacts:');
+        for (const ci of ctx.crossImpacts) {
+            console.log(`  ${ci.sourceFamily} → ${ci.affectedFamily} (${ci.riskLevel}): ${ci.sharedDependency}`);
+        }
+    }
+    if (result.timings && Object.keys(result.timings).length > 0) {
+        console.log('\nPhase timings:');
+        for (const [phase, ms] of Object.entries(result.timings)) {
+            console.log(`  ${phase}: ${ms}ms`);
+        }
+    }
+    if (result.warnings.length > 0) {
+        console.log(`\nWarnings: ${result.warnings.length}`);
+        for (const w of result.warnings.slice(0, 10)) {
+            console.log(`  - ${w}`);
+        }
+        if (result.warnings.length > 10) {
+            console.log(`  ... and ${result.warnings.length - 10} more`);
+        }
+    }
+}
+function printDryRunOutput(result, workflowName, jsonOutput) {
+    const ctx = result.context;
+    const workflow = workflows_js_1.WORKFLOWS[workflowName];
+    if (jsonOutput) {
+        console.log(JSON.stringify({
+            dryRun: true,
+            workflow: workflowName,
+            changedFiles: ctx.changedFiles,
+            familyGroups: ctx.familyGroups.map((fg) => ({
+                familyId: fg.familyId,
+                featureId: fg.featureId,
+                files: fg.files,
+            })),
+            phases: workflow.phases.map((p) => ({
+                name: p.name,
+                agents: p.parallel || p.sequential || [],
+            })),
+            manifestSource: ctx.manifest?.source || 'none',
+            warnings: result.warnings,
+        }, null, 2));
+        return;
+    }
+    console.log('Dry run — no LLM calls will be made.\n');
+    console.log(`Changed files (${ctx.changedFiles.length}):`);
+    for (const f of ctx.changedFiles.slice(0, 20)) {
+        console.log(`  ${f}`);
+    }
+    if (ctx.changedFiles.length > 20) {
+        console.log(`  ... and ${ctx.changedFiles.length - 20} more`);
+    }
+    console.log(`\nAffected families (${ctx.familyGroups.length}):`);
+    for (const fg of ctx.familyGroups) {
+        const label = fg.featureId ? `${fg.familyId}/${fg.featureId}` : fg.familyId;
+        console.log(`  ${label} (${fg.files.length} files)`);
+    }
+    if (ctx.manifest?.source === 'heuristic') {
+        console.log('\n  Note: Using directory-based heuristics. Run `impact-gate train` for better accuracy.');
+    }
+    console.log(`\nWorkflow: ${workflowName}`);
+    const phaseNames = workflow.phases
+        .map((p) => {
+        const agents = p.parallel || p.sequential || [];
+        return agents.length > 0 ? `${p.name} (${agents.join(', ')})` : p.name;
+    })
+        .join(' → ');
+    console.log(`Phases: ${phaseNames}`);
+    // Cost estimation based on workflow and family count
+    const familyCount = Math.max(ctx.familyGroups.length, 1);
+    const agentCount = workflow.phases.reduce((sum, p) => sum + (p.parallel?.length || 0) + (p.sequential?.length || 0), 0);
+    const costEstimate = estimateCost(workflowName, familyCount, agentCount);
+    console.log(`\nEstimated cost: $${costEstimate.low.toFixed(2)}-$${costEstimate.high.toFixed(2)}`);
+    if (ctx.modelRoutingProviderType) {
+        console.log(`  With model routing: $${(costEstimate.low * 0.5).toFixed(2)}-$${(costEstimate.high * 0.5).toFixed(2)} (Haiku for classification)`);
+    }
+}
+/** Rough cost estimation based on observed averages per workflow type */
+function estimateCost(workflow, families, _agents) {
+    // Per-family cost ranges by workflow (based on typical Sonnet pricing)
+    const ranges = {
+        'quick-check': { low: 0.03, high: 0.10 },
+        'design-only': { low: 0.10, high: 0.40 },
+        'full-qa': { low: 0.30, high: 1.00 },
+    };
+    const range = ranges[workflow] || ranges['full-qa'];
+    return {
+        low: range.low * families,
+        high: range.high * families,
+    };
+}

package/dist/cli/commands/feedback.d.ts

@@ -0,0 +1,3 @@
+import type { ParsedArgs } from '../types.js';
+export declare function runFeedbackCommand(args: ParsedArgs, autoConfig: string | undefined): void;
+//# sourceMappingURL=feedback.d.ts.map

package/dist/cli/commands/feedback.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"feedback.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/feedback.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,aAAa,CAAC;AAE5C,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,CAiCzF"}

package/dist/cli/commands/feedback.js

@@ -0,0 +1,39 @@
+"use strict";
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runFeedbackCommand = runFeedbackCommand;
+const fs_1 = require("fs");
+const config_js_1 = require("../../agent/config.js");
+const feedback_js_1 = require("../../agent/feedback.js");
+function runFeedbackCommand(args, autoConfig) {
+    if (!args.path && !autoConfig) {
+        console.error('Error: --path is required for feedback command');
+        process.exit(1);
+    }
+    if (!args.feedbackInputPath) {
+        console.error('Error: --feedback-input <path> is required for feedback command');
+        process.exit(1);
+    }
+    const { config } = (0, config_js_1.resolveConfig)(process.cwd(), autoConfig, {
+        path: args.path,
+        profile: args.profile,
+        testsRoot: args.testsRoot,
+        mode: 'impact',
+        llmProvider: args.llmProvider,
+    });
+    const reportRoot = config.testsRoot || config.path;
+    const raw = JSON.parse((0, fs_1.readFileSync)(args.feedbackInputPath, 'utf-8'));
+    const payload = {
+        timestamp: raw.timestamp || new Date().toISOString(),
+        runSet: raw.runSet || 'targeted',
+        recommendedTests: raw.recommendedTests || [],
+        executedTests: raw.executedTests || [],
+        failedTests: raw.failedTests || [],
+        escapedFailures: raw.escapedFailures || [],
+    };
+    const output = (0, feedback_js_1.appendFeedbackAndRecompute)(reportRoot, payload);
+    console.log(`Feedback data: ${output.feedbackPath}`);
+    console.log(`Calibration data: ${output.calibrationPath}`);
+    console.log(`Calibration overall: precision=${output.calibration.overall.precision}, recall=${output.calibration.overall.recall}, fnr=${output.calibration.overall.falseNegativeRate}`);
+}

package/dist/cli/commands/finalize.d.ts

@@ -0,0 +1,3 @@
+import type { ParsedArgs } from '../types.js';
+export declare function runFinalizeCommand(args: ParsedArgs, autoConfig: string | undefined): void;
+//# sourceMappingURL=finalize.d.ts.map

package/dist/cli/commands/finalize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"finalize.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/finalize.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,aAAa,CAAC;AAE5C,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,CAiCzF"}

package/dist/cli/commands/finalize.js

@@ -0,0 +1,41 @@
+"use strict";
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runFinalizeCommand = runFinalizeCommand;
+const config_js_1 = require("../../agent/config.js");
+const handoff_js_1 = require("../../agent/handoff.js");
+function runFinalizeCommand(args, autoConfig) {
+    if (!args.path && !autoConfig) {
+        console.error('Error: --path is required for finalize-generated-tests command');
+        process.exit(1);
+    }
+    const { config } = (0, config_js_1.resolveConfig)(process.cwd(), autoConfig, {
+        path: args.path,
+        profile: args.profile,
+        testsRoot: args.testsRoot,
+        mode: 'gap',
+        llmProvider: args.llmProvider,
+    });
+    const result = (0, handoff_js_1.finalizeGeneratedTests)({
+        appPath: config.path,
+        testsRoot: config.testsRoot || config.path,
+        branch: args.branch,
+        commitMessage: args.commitMessage,
+        createPr: args.createPr,
+        prTitle: args.prTitle,
+        prBody: args.prBody,
+        baseBranch: args.prBase,
+        dryRun: args.dryRun,
+    });
+    console.log(`Finalize repo root: ${result.repoRoot}`);
+    console.log(`Finalize branch: ${result.branch}`);
+    console.log(`Finalize staged paths: ${result.stagedPaths.join(', ') || 'none'}`);
+    console.log(`Finalize commit: ${result.committed ? 'created' : 'skipped'}`);
+    if (result.commitSha) {
+        console.log(`Finalize commit sha: ${result.commitSha}`);
+    }
+    if (result.prUrl) {
+        console.log(`Finalize PR: ${result.prUrl}`);
+    }
+}

package/dist/cli/commands/gate.d.ts

@@ -0,0 +1,3 @@
+import type { ParsedArgs } from '../types.js';
+export declare function runGateCommand(args: ParsedArgs, autoConfig: string | undefined): Promise<void>;
+//# sourceMappingURL=gate.d.ts.map

package/dist/cli/commands/gate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gate.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/gate.ts"],"names":[],"mappings":"AAgBA,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,aAAa,CAAC;AAE5C,wBAAsB,cAAc,CAAC,IAAI,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,GAAG,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC,CAgFpG"}

package/dist/cli/commands/gate.js

@@ -0,0 +1,89 @@
+"use strict";
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runGateCommand = runGateCommand;
+/**
+ * CLI command: gate — CI coverage gate that exits 1 if coverage is below threshold.
+ *
+ * Runs deterministic impact analysis (no LLM required) and checks what
+ * percentage of impacted features have test coverage.
+ *
+ * Usage:
+ *   impact-gate gate --threshold 80 --path . --since origin/main
+ */
+const config_js_1 = require("../../agent/config.js");
+const git_js_1 = require("../../agent/git.js");
+const impact_engine_js_1 = require("../../engine/impact_engine.js");
+async function runGateCommand(args, autoConfig) {
+    if (!args.path && !autoConfig) {
+        console.error('Error: --path is required for gate command');
+        process.exit(1);
+    }
+    let threshold = args.gateThreshold ?? 80;
+    if (threshold > 0 && threshold < 1) {
+        threshold = threshold * 100;
+    }
+    const { config } = (0, config_js_1.resolveConfig)(process.cwd(), autoConfig, {
+        path: args.path,
+        profile: args.profile,
+        testsRoot: args.testsRoot,
+        mode: 'impact',
+        gitSince: args.gitSince,
+    });
+    const testsRoot = config.testsRoot || config.path;
+    const gitSince = args.gitSince || config.git.since;
+    // Get changed files
+    const result = await (0, git_js_1.getChangedFiles)(config.path, gitSince);
+    const changedFiles = result.files;
+    if (changedFiles.length === 0) {
+        console.log('No changed files detected. Gate passes.');
+        process.exit(0);
+    }
+    // Run deterministic impact analysis
+    const impact = (0, impact_engine_js_1.analyzeImpact)(changedFiles, {
+        testsRoot,
+        routeFamilies: config.routeFamilies,
+    });
+    const totalFeatures = impact.impactedFeatures.length;
+    if (totalFeatures === 0) {
+        console.log('No impacted features detected. Gate passes.');
+        process.exit(0);
+    }
+    const coveredFeatures = impact.impactedFeatures.filter((f) => f.coverageStatus === 'covered' || f.coverageStatus === 'partial').length;
+    const coveragePercent = Math.round((coveredFeatures / totalFeatures) * 100);
+    // Output
+    if (args.jsonOutput) {
+        console.log(JSON.stringify({
+            threshold,
+            coveragePercent,
+            totalFeatures,
+            coveredFeatures,
+            passed: coveragePercent >= threshold,
+            uncoveredFeatures: impact.impactedFeatures
+                .filter((f) => f.coverageStatus === 'uncovered')
+                .map((f) => ({ id: f.featureId || f.familyId, priority: f.priority })),
+        }, null, 2));
+    }
+    else {
+        console.log(`Coverage gate: ${coveragePercent}% (${coveredFeatures}/${totalFeatures} features covered)`);
+        console.log(`Threshold: ${threshold}%`);
+        if (coveragePercent < threshold) {
+            console.log(`\nFAILED — coverage ${coveragePercent}% is below ${threshold}% threshold`);
+            const uncovered = impact.impactedFeatures.filter((f) => f.coverageStatus === 'uncovered');
+            if (uncovered.length > 0) {
+                console.log('\nUncovered features:');
+                for (const f of uncovered.slice(0, 10)) {
+                    console.log(`  ${f.priority || 'P2'} ${f.featureId || f.familyId}`);
+                }
+                if (uncovered.length > 10) {
+                    console.log(`  ... and ${uncovered.length - 10} more`);
+                }
+            }
+        }
+        else {
+            console.log('\nPASSED');
+        }
+    }
+    process.exit(coveragePercent >= threshold ? 0 : 1);
+}

package/dist/cli/commands/generate.d.ts

@@ -0,0 +1,4 @@
+import type { resolveConfig } from '../../agent/config.js';
+import type { ParsedArgs } from '../types.js';
+export declare function runGenerateCommand(args: ParsedArgs, config: ReturnType<typeof resolveConfig>['config']): Promise<void>;
+//# sourceMappingURL=generate.d.ts.map

package/dist/cli/commands/generate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/generate.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAC,aAAa,EAAC,MAAM,uBAAuB,CAAC;AAKzD,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,aAAa,CAAC;AAE5C,wBAAsB,kBAAkB,CAAC,IAAI,EAAE,UAAU,EAAE,MAAM,EAAE,UAAU,CAAC,OAAO,aAAa,CAAC,CAAC,QAAQ,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CA0G5H"}

package/dist/cli/commands/generate.js

@@ -0,0 +1,108 @@
+"use strict";
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runGenerateCommand = runGenerateCommand;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const provider_factory_js_1 = require("../../provider_factory.js");
+const runner_js_1 = require("../../agentic/runner.js");
+const api_surface_js_1 = require("../../knowledge/api_surface.js");
+async function runGenerateCommand(args, config) {
+    const reportRoot = config.testsRoot || config.path;
+    // Load scenarios from --scenarios flag or plan-report.json
+    let scenarios = [];
+    if (args.generateScenarios) {
+        let raw;
+        if ((0, fs_1.existsSync)(args.generateScenarios)) {
+            raw = JSON.parse((0, fs_1.readFileSync)(args.generateScenarios, 'utf-8'));
+        }
+        else {
+            raw = JSON.parse(args.generateScenarios);
+        }
+        if (!Array.isArray(raw)) {
+            console.error('--scenarios must be a JSON array of ScenarioInput objects.');
+            process.exit(1);
+        }
+        for (const item of raw) {
+            if (!item.id || !item.name || !Array.isArray(item.scenarios) || !item.routeFamily || !item.priority) {
+                console.error(`Invalid scenario: each must have id, name, scenarios[], routeFamily, priority.`);
+                process.exit(1);
+            }
+        }
+        scenarios = raw;
+    }
+    else {
+        // Try plan.json first (written by plan/suggest command), then plan-report.json (legacy)
+        const planJsonPath = (0, path_1.join)(reportRoot, '.e2e-ai-agents', 'plan.json');
+        const planReportPath = (0, path_1.join)(reportRoot, '.e2e-ai-agents', 'plan-report.json');
+        const resolvedPlanPath = (0, fs_1.existsSync)(planJsonPath) ? planJsonPath : (0, fs_1.existsSync)(planReportPath) ? planReportPath : null;
+        if (!resolvedPlanPath) {
+            console.error('No plan report found. Run `plan` first or pass --scenarios.');
+            process.exit(1);
+        }
+        const planReport = JSON.parse((0, fs_1.readFileSync)(resolvedPlanPath, 'utf-8'));
+        scenarios = (planReport.gapDetails || []).map((gap) => ({
+            id: gap.id,
+            name: gap.id,
+            scenarios: gap.missingScenarios || gap.reasons || ['Verify core user flow'],
+            routeFamily: gap.id.split('.')[0] || gap.id,
+            priority: 'P1',
+        }));
+    }
+    if (scenarios.length === 0) {
+        console.log('No scenarios to generate tests for.');
+        return;
+    }
+    let apiSurface;
+    try {
+        apiSurface = (0, api_surface_js_1.loadOrBuildApiSurface)(reportRoot, config.apiSurface);
+    }
+    catch {
+        console.warn('Could not load API surface catalog. Generation will use generic selectors.');
+    }
+    const provider = await provider_factory_js_1.LLMProviderFactory.createFromPreference(config.llm.provider);
+    console.log(`Generating tests for ${scenarios.length} scenario(s)...`);
+    const summary = await (0, runner_js_1.runAgenticGeneration)({
+        scenarios,
+        config: {
+            maxAttempts: args.maxAttempts || 3,
+            project: args.pipelineProject || 'chrome',
+            baseUrl: args.pipelineBaseUrl,
+            testTimeoutMs: 120000,
+            testsRoot: reportRoot,
+            dryRun: args.dryRun,
+        },
+        provider,
+        apiSurface,
+    });
+    console.log(`\nAgentic Generation Summary:`);
+    console.log(`  Generated: ${summary.totalGenerated}`);
+    console.log(`  Passed:    ${summary.totalPassed}`);
+    console.log(`  Failed:    ${summary.totalFailed}`);
+    console.log(`  Attempts:  ${summary.totalAttempts}`);
+    console.log(`  Duration:  ${(summary.durationMs / 1000).toFixed(1)}s`);
+    for (const result of summary.results) {
+        const icon = result.status === 'passed' ? 'PASS' : result.status === 'skipped' ? 'SKIP' : 'FAIL';
+        console.log(`  [${icon}] ${result.scenarioSource} (${result.attempts} attempts)`);
+        if (result.status === 'passed' || result.status === 'skipped') {
+            console.log(`     ${result.specPath}`);
+        }
+    }
+    if (summary.warnings.length > 0) {
+        console.log(`\nWarnings:`);
+        for (const w of summary.warnings) {
+            console.warn(`  - ${w}`);
+        }
+    }
+    const summaryDir = (0, path_1.join)(reportRoot, '.e2e-ai-agents');
+    if (!(0, fs_1.existsSync)(summaryDir)) {
+        (0, fs_1.mkdirSync)(summaryDir, { recursive: true });
+    }
+    const summaryPath = (0, path_1.join)(summaryDir, 'agentic-summary.json');
+    (0, fs_1.writeFileSync)(summaryPath, JSON.stringify(summary, null, 2), 'utf-8');
+    console.log(`\nReport: ${summaryPath}`);
+    if (summary.totalFailed > 0) {
+        process.exit(1);
+    }
+}

package/dist/cli/commands/heal.d.ts

@@ -0,0 +1,3 @@
+import type { ParsedArgs } from '../types.js';
+export declare function runHealCommand(args: ParsedArgs, autoConfig: string | undefined): void;
+//# sourceMappingURL=heal.d.ts.map

package/dist/cli/commands/heal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"heal.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/heal.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,aAAa,CAAC;AAE5C,wBAAgB,cAAc,CAAC,IAAI,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,CA0DrF"}

package/dist/cli/commands/heal.js

@@ -0,0 +1,60 @@
+"use strict";
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runHealCommand = runHealCommand;
+const config_js_1 = require("../../agent/config.js");
+const pipeline_js_1 = require("../../agent/pipeline.js");
+const playwright_report_js_1 = require("../../agent/playwright_report.js");
+function runHealCommand(args, autoConfig) {
+    if (!args.path && !autoConfig) {
+        console.error('Error: --path is required for heal command');
+        process.exit(1);
+    }
+    if (!args.traceabilityReportPath) {
+        console.error('Error: --traceability-report <path> is required for heal command');
+        process.exit(1);
+    }
+    const { config } = (0, config_js_1.resolveConfig)(process.cwd(), autoConfig, {
+        path: args.path,
+        profile: args.profile,
+        testsRoot: args.testsRoot,
+        mode: 'gap',
+        framework: args.framework,
+        pipeline: {
+            enabled: true,
+            scenarios: args.pipelineScenarios,
+            outputDir: args.pipelineOutput,
+            baseUrl: args.pipelineBaseUrl,
+            browser: args.pipelineBrowser,
+            headless: args.pipelineHeadless,
+            project: args.pipelineProject,
+            parallel: args.pipelineParallel,
+            dryRun: args.pipelineDryRun,
+            mcp: args.pipelineMcp,
+            mcpAllowFallback: args.pipelineMcpAllowFallback,
+            mcpOnly: args.pipelineMcpOnly,
+        },
+        llmProvider: args.llmProvider,
+    });
+    const reportRoot = config.testsRoot || config.path;
+    const unstableSpecs = (0, playwright_report_js_1.extractPlaywrightUnstableSpecs)(args.traceabilityReportPath, [reportRoot, config.path]);
+    if (unstableSpecs.length === 0) {
+        console.log('Heal targeted unstable specs: 0');
+        return;
+    }
+    const targetedSummary = (0, pipeline_js_1.runTargetedSpecHeal)(reportRoot, unstableSpecs.map((spec) => ({
+        specPath: spec.specPath,
+        status: spec.status,
+        reason: `Playwright report: failingTests=${spec.failingTests}, flakyTests=${spec.flakyTests}`,
+    })), {
+        ...config.pipeline,
+        enabled: true,
+        heal: true,
+    });
+    const healedCount = targetedSummary.results.filter((result) => result.healStatus === 'success').length;
+    console.log(`Heal targeted unstable specs: ${unstableSpecs.length} (healed=${healedCount})`);
+    if (targetedSummary.warnings.length > 0) {
+        console.log(`Heal warnings: ${targetedSummary.warnings.join(' | ')}`);
+    }
+}

package/dist/cli/commands/impact.d.ts

@@ -0,0 +1,4 @@
+import type { resolveConfig } from '../../agent/config.js';
+import type { ParsedArgs } from '../types.js';
+export declare function runImpactCommand(args: ParsedArgs, config: ReturnType<typeof resolveConfig>['config']): void;
+//# sourceMappingURL=impact.d.ts.map

package/dist/cli/commands/impact.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"impact.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/impact.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAC,aAAa,EAAC,MAAM,uBAAuB,CAAC;AAIzD,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,aAAa,CAAC;AAE5C,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,UAAU,EAAE,MAAM,EAAE,UAAU,CAAC,OAAO,aAAa,CAAC,CAAC,QAAQ,CAAC,GAAG,IAAI,CAwB3G"}