@yasserkhanorg/impact-gate 2.0.0

package/dist/cli/commands/plan_crew.js

@@ -0,0 +1,316 @@
+"use strict";
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runPlanCrewAnalysis = runPlanCrewAnalysis;
+exports.buildCrewMarkdown = buildCrewMarkdown;
+exports.appendCrewToSummary = appendCrewToSummary;
+exports.buildCrewTestPlan = buildCrewTestPlan;
+exports.writeCrewArtifacts = writeCrewArtifacts;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const cross_impact_js_1 = require("../../agents/cross-impact.js");
+const impact_analyst_js_1 = require("../../agents/impact-analyst.js");
+const regression_advisor_js_1 = require("../../agents/regression-advisor.js");
+const strategist_js_1 = require("../../agents/strategist.js");
+const test_designer_js_1 = require("../../agents/test-designer.js");
+const orchestrator_js_1 = require("../../crew/orchestrator.js");
+const VALID_WORKFLOWS = new Set(['full-qa', 'quick-check', 'design-only']);
+function uniqueStrings(values) {
+    return Array.from(new Set(values.filter(Boolean)));
+}
+function singleLine(value) {
+    return value.replace(/\s+/g, ' ').trim();
+}
+function chooseCrewWorkflow(explicitWorkflow, plan) {
+    if (explicitWorkflow && VALID_WORKFLOWS.has(explicitWorkflow)) {
+        return explicitWorkflow;
+    }
+    if (plan.decision.action === 'must-add-tests' || plan.metrics.uncoveredP0P1Flows > 0) {
+        return 'design-only';
+    }
+    return 'quick-check';
+}
+function registerCrewAgents(orchestrator) {
+    orchestrator.registerAgent(new impact_analyst_js_1.ImpactAnalystAgent());
+    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());
+}
+async function runPlanCrewAnalysis(plan, config, args) {
+    const reportRoot = config.testsRoot || config.path;
+    const workflow = chooseCrewWorkflow(args.crewWorkflow, plan);
+    const normalizedProvider = config.llm.provider?.trim().toLowerCase();
+    const providerOverride = normalizedProvider && normalizedProvider !== 'auto' ? normalizedProvider : 'auto';
+    const orchestrator = new orchestrator_js_1.CrewOrchestrator();
+    registerCrewAgents(orchestrator);
+    const result = await orchestrator.run({
+        appPath: config.path,
+        testsRoot: reportRoot,
+        gitSince: args.gitSince || config.git.since,
+        routeFamilies: config.routeFamilies,
+        apiSurface: config.apiSurface,
+        workflow,
+        providerOverride: providerOverride === 'auto' ? undefined : providerOverride,
+        budgetUSD: args.budgetUSD,
+        dryRun: args.dryRun,
+    });
+    const ctx = result.context;
+    const highRiskCrossImpacts = ctx.crossImpacts.filter((entry) => entry.riskLevel === 'high');
+    const manualReviewEntries = ctx.strategyEntries.filter((entry) => entry.approach === 'manual-review');
+    return {
+        workflow,
+        providerOverride,
+        summary: {
+            impactedFlows: ctx.impactedFlows.length,
+            strategyEntries: ctx.strategyEntries.length,
+            testDesigns: ctx.testDesigns.length,
+            crossImpacts: ctx.crossImpacts.length,
+            highRiskCrossImpacts: highRiskCrossImpacts.length,
+            regressionRisks: ctx.regressionRisks.length,
+            findings: ctx.findings.length,
+            generatedSpecs: ctx.generatedSpecs.length,
+            manualReviewEntries: manualReviewEntries.length,
+            totalCostUSD: Number(ctx.usage.totalCost.toFixed(4)),
+            totalTokens: ctx.usage.totalTokens,
+        },
+        impactedFlows: ctx.impactedFlows,
+        strategyEntries: ctx.strategyEntries,
+        testDesigns: ctx.testDesigns,
+        crossImpacts: ctx.crossImpacts,
+        regressionRisks: ctx.regressionRisks,
+        findings: ctx.findings,
+        warnings: uniqueStrings([...ctx.warnings, ...result.warnings]),
+        timings: result.timings,
+    };
+}
+/**
+ * Match a strategy/design entry against a set of gap family IDs.
+ */
+function matchesGapFamily(flowId, flowName, gapFamilies) {
+    return Array.from(gapFamilies).some((fam) => flowId.startsWith(fam) || flowName.toLowerCase().includes(fam.replace(/_/g, ' ')));
+}
+function buildCrewMarkdown(crew, plan) {
+    const totalCases = crew.testDesigns.reduce((n, td) => n + td.testCases.length, 0);
+    const gapFamilies = new Set((plan?.gapDetails ?? []).map((g) => g.id));
+    const lines = [
+        '### Crew Analysis — What to Test',
+        '',
+        `Crew analyzed the diff and recommends what to verify before merging.`,
+        '',
+        `Impacted flows: **${crew.summary.impactedFlows}** | Strategy entries: **${crew.summary.strategyEntries}**`,
+    ];
+    if (totalCases > 0) {
+        const gapDesigns = gapFamilies.size > 0
+            ? crew.testDesigns.filter((td) => matchesGapFamily(td.flowId, td.flowName, gapFamilies))
+            : [];
+        const gapCases = gapDesigns.reduce((n, td) => n + td.testCases.length, 0);
+        const gapP0Cases = gapDesigns.reduce((n, td) => n + td.testCases.filter((tc) => tc.priority === 'P0').length, 0);
+        lines.push(`Structured test designs: **${crew.summary.testDesigns}** flows, **${totalCases}** test cases`);
+        if (gapDesigns.length > 0) {
+            lines.push(`Gap-focused: **${gapDesigns.length}** flows, **${gapCases}** test cases (**${gapP0Cases}** P0)`);
+        }
+    }
+    if (crew.summary.crossImpacts > 0) {
+        lines.push(`Cross-impacts: **${crew.summary.crossImpacts}** (${crew.summary.highRiskCrossImpacts} high risk)`);
+    }
+    lines.push(`Estimated AI cost: **$${crew.summary.totalCostUSD.toFixed(4)}**`);
+    if (crew.strategyEntries.length > 0) {
+        lines.push('');
+        lines.push('Top Strategy Recommendations:');
+        for (const entry of crew.strategyEntries.slice(0, 5)) {
+            lines.push(`- ${entry.priority} ${entry.flowName} -> ${entry.approach} (${entry.crossImpactRisk} cross-impact risk)`);
+        }
+    }
+    if (crew.testDesigns.length > 0) {
+        lines.push('');
+        lines.push('Structured Test Designs:');
+        for (const design of crew.testDesigns.slice(0, 3)) {
+            lines.push(`- ${design.flowName}: ${design.testCases.length} designed test case(s)`);
+        }
+    }
+    const riskyCrossImpacts = crew.crossImpacts.filter((entry) => entry.riskLevel === 'high');
+    if (riskyCrossImpacts.length > 0) {
+        lines.push('');
+        lines.push('High-Risk Cross-Impacts:');
+        for (const entry of riskyCrossImpacts.slice(0, 5)) {
+            lines.push(`- ${entry.sourceFamily} -> ${entry.affectedFamily}: ${entry.sharedDependency}`);
+        }
+    }
+    if (crew.findings.length > 0) {
+        lines.push('');
+        lines.push('Crew Findings:');
+        for (const finding of crew.findings.slice(0, 5)) {
+            lines.push(`- ${finding.severity} ${finding.type}: ${finding.summary}`);
+        }
+    }
+    if (crew.warnings.length > 0) {
+        lines.push('');
+        lines.push('Crew Warnings:');
+        for (const warning of crew.warnings.slice(0, 5)) {
+            lines.push(`- ${singleLine(warning)}`);
+        }
+    }
+    return lines.join('\n');
+}
+function appendCrewToSummary(baseMarkdown, crew, plan) {
+    return `${baseMarkdown}\n\n---\n\n${buildCrewMarkdown(crew, plan)}`;
+}
+/**
+ * Build a full structured test plan as a Markdown document.
+ * Sections: gap flows first (P0 cases expanded), then covered-flow smoke tests.
+ */
+function buildCrewTestPlan(crew, plan) {
+    const gapFamilies = new Set((plan?.gapDetails ?? []).map((g) => g.id));
+    const hasTestDesigns = crew.testDesigns.length > 0;
+    const totalCases = crew.testDesigns.reduce((n, td) => n + td.testCases.length, 0);
+    // Split strategy entries into gap-related and covered
+    const gapStrategies = gapFamilies.size > 0
+        ? crew.strategyEntries.filter((s) => matchesGapFamily(s.flowId, s.flowName, gapFamilies))
+        : [];
+    const coveredStrategies = crew.strategyEntries.filter((s) => !gapStrategies.includes(s));
+    // Split test designs (if present) into gap-related and covered
+    const gapDesigns = [];
+    const coveredDesigns = [];
+    for (const td of crew.testDesigns) {
+        if (matchesGapFamily(td.flowId, td.flowName, gapFamilies)) {
+            gapDesigns.push(td);
+        }
+        else {
+            coveredDesigns.push(td);
+        }
+    }
+    const gapCases = gapDesigns.reduce((n, td) => n + td.testCases.length, 0);
+    const coveredCases = coveredDesigns.reduce((n, td) => n + td.testCases.length, 0);
+    const lines = [
+        '# Crew Test Plan — What to Verify',
+        '',
+        '> **This is a test recommendation, not a test execution report.**',
+        '> Crew analyzed the code diff and identified what needs to be tested.',
+        '> Use this plan to guide manual QA or write automated E2E tests.',
+        '',
+        `_Auto-generated by impact-gate crew (\`${crew.workflow}\` workflow)_`,
+        '',
+        '## Summary',
+        '',
+        `| Metric | Count |`,
+        `|--------|-------|`,
+        `| Gap flows — **no existing tests, must verify** | ${gapStrategies.length} flows${hasTestDesigns ? `, **${gapCases} test cases**` : ''} |`,
+        `| Covered flows — **has tests, verify no regressions** | ${coveredStrategies.length} flows${hasTestDesigns ? `, ${coveredCases} test cases` : ''} |`,
+        `| Total | ${crew.strategyEntries.length} flows${hasTestDesigns ? `, ${totalCases} test cases` : ''} |`,
+        `| High-risk cross-impacts | ${crew.summary.highRiskCrossImpacts} |`,
+        `| AI cost | $${crew.summary.totalCostUSD.toFixed(4)} |`,
+        '',
+    ];
+    // ── Gap flows ──
+    if (gapStrategies.length > 0) {
+        lines.push('## Action Required: Gap Flows (No Existing Tests)');
+        lines.push('');
+        lines.push('These flows have **no automated E2E coverage**. Before merging, either:');
+        lines.push('1. **Write E2E tests** for the critical scenarios below, or');
+        lines.push('2. **Manually verify** each flow works as expected');
+        lines.push('');
+        for (const strategy of gapStrategies) {
+            const td = crew.testDesigns.find((d) => d.flowId === strategy.flowId);
+            lines.push(`### ${strategy.flowName}`);
+            lines.push('');
+            const actionVerb = strategy.approach === 'full-test' ? 'Write full E2E test or verify manually'
+                : strategy.approach === 'smoke-test' ? 'Smoke-test manually or add basic E2E coverage'
+                    : strategy.approach === 'manual-review' ? 'Manual review required'
+                        : 'Can skip — low risk';
+            lines.push(`**${strategy.priority}** | Recommended: **${strategy.approach}** | Cross-impact risk: **${strategy.crossImpactRisk}**`);
+            lines.push(`> ${actionVerb}`);
+            if (strategy.rationale && !strategy.rationale.includes('Default strategy')) {
+                lines.push(`> Rationale: ${strategy.rationale}`);
+            }
+            if (strategy.testCategories.length > 0) {
+                lines.push(`> Test types to cover: ${strategy.testCategories.join(', ')}`);
+            }
+            lines.push('');
+            // If test designs exist, show P0/P1 cases
+            if (td && td.testCases.length > 0) {
+                const p0Cases = td.testCases.filter((tc) => tc.priority === 'P0');
+                const p1Cases = td.testCases.filter((tc) => tc.priority === 'P1');
+                if (p0Cases.length > 0) {
+                    lines.push('**P0 — Must test:**');
+                    lines.push('');
+                    for (const tc of p0Cases) {
+                        lines.push(`- [ ] **${tc.name}** (${tc.type})`);
+                        if (tc.preconditions.length > 0) {
+                            lines.push(`  - Preconditions: ${tc.preconditions.join('; ')}`);
+                        }
+                        lines.push(`  - Steps: ${tc.steps.join(' → ')}`);
+                        lines.push(`  - Expected: ${tc.expectedOutcome}`);
+                    }
+                    lines.push('');
+                }
+                if (p1Cases.length > 0) {
+                    lines.push(`<details><summary>P1 — Should test (${p1Cases.length})</summary>`);
+                    lines.push('');
+                    for (const tc of p1Cases) {
+                        lines.push(`- [ ] **${tc.name}** (${tc.type}) — ${tc.expectedOutcome}`);
+                    }
+                    lines.push('');
+                    lines.push('</details>');
+                    lines.push('');
+                }
+            }
+        }
+    }
+    // ── Covered flows ──
+    if (coveredStrategies.length > 0) {
+        lines.push('## Regression Check: Covered Flows (Already Have Tests)');
+        lines.push('');
+        lines.push('These flows have existing E2E specs. The existing tests should catch regressions automatically.');
+        lines.push('**No manual action required** unless CI tests fail on these flows.');
+        lines.push('');
+        for (const strategy of coveredStrategies) {
+            const td = crew.testDesigns.find((d) => d.flowId === strategy.flowId);
+            const caseCount = td ? td.testCases.length : 0;
+            const detail = caseCount > 0 ? ` | ${caseCount} cases` : '';
+            lines.push(`<details><summary><strong>${strategy.flowName}</strong> — ${strategy.approach}${detail} (${strategy.priority})</summary>`);
+            lines.push('');
+            lines.push(`Existing tests should cover this. Cross-impact risk: ${strategy.crossImpactRisk}`);
+            if (strategy.rationale && !strategy.rationale.includes('Default strategy')) {
+                lines.push(`> ${strategy.rationale}`);
+            }
+            if (strategy.testCategories.length > 0) {
+                lines.push(`Test categories: ${strategy.testCategories.join(', ')}`);
+            }
+            if (td && td.testCases.length > 0) {
+                lines.push('');
+                for (const tc of td.testCases) {
+                    lines.push(`- [ ] **${tc.name}** (${tc.priority}, ${tc.type}) — ${tc.expectedOutcome}`);
+                }
+            }
+            lines.push('');
+            lines.push('</details>');
+            lines.push('');
+        }
+    }
+    // ── Cross-impacts ──
+    const highRisk = crew.crossImpacts.filter((ci) => ci.riskLevel === 'high');
+    if (highRisk.length > 0) {
+        lines.push('## High-Risk Cross-Impacts — Verify Before Release');
+        lines.push('');
+        lines.push('Changes in one area may break these related areas. Manually verify or ensure E2E tests cover both sides:');
+        lines.push('');
+        for (const ci of highRisk) {
+            lines.push(`- **${ci.sourceFamily}** → **${ci.affectedFamily}**: ${ci.sharedDependency}`);
+        }
+        lines.push('');
+    }
+    return lines.join('\n');
+}
+function writeCrewArtifacts(reportRoot, crew, plan) {
+    const outputDir = (0, path_1.join)(reportRoot, '.e2e-ai-agents');
+    (0, fs_1.mkdirSync)(outputDir, { recursive: true });
+    const crewSummaryPath = (0, path_1.join)(outputDir, 'crew-summary.json');
+    const crewMarkdownPath = (0, path_1.join)(outputDir, 'crew-summary.md');
+    const crewTestPlanPath = (0, path_1.join)(outputDir, 'crew-test-plan.md');
+    (0, fs_1.writeFileSync)(crewSummaryPath, JSON.stringify(crew, null, 2), 'utf-8');
+    (0, fs_1.writeFileSync)(crewMarkdownPath, buildCrewMarkdown(crew, plan), 'utf-8');
+    (0, fs_1.writeFileSync)(crewTestPlanPath, buildCrewTestPlan(crew, plan), 'utf-8');
+    return { crewSummaryPath, crewMarkdownPath, crewTestPlanPath };
+}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"traceability.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/traceability.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,aAAa,CAAC;AAE5C,wBAAgB,6BAA6B,CAAC,IAAI,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,CAmCpG;AAED,wBAAgB,4BAA4B,CAAC,IAAI,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,CAqCnG"}

package/dist/cli/commands/traceability.js

@@ -0,0 +1,77 @@
+"use strict";
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runTraceabilityCaptureCommand = runTraceabilityCaptureCommand;
+exports.runTraceabilityIngestCommand = runTraceabilityIngestCommand;
+const fs_1 = require("fs");
+const config_js_1 = require("../../agent/config.js");
+const traceability_capture_js_1 = require("../../agent/traceability_capture.js");
+const traceability_ingest_js_1 = require("../../agent/traceability_ingest.js");
+function runTraceabilityCaptureCommand(args, autoConfig) {
+    if (!args.path && !autoConfig) {
+        console.error('Error: --path is required for traceability-capture command');
+        process.exit(1);
+    }
+    if (!args.traceabilityReportPath) {
+        console.error('Error: --traceability-report <path> is required for traceability-capture 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 reportRoot = config.testsRoot || config.path;
+    const output = (0, traceability_capture_js_1.captureTraceabilityInput)({
+        appPath: config.path,
+        testsRoot: reportRoot,
+        reportPath: args.traceabilityReportPath,
+        sinceRef: args.gitSince || config.git.since,
+        outputPath: args.traceabilityCaptureOutputPath,
+        coverageMapPath: args.traceabilityCoverageMapPath,
+        changedFilesPath: args.traceabilityChangedFilesPath,
+    });
+    console.log(`Traceability input: ${output.outputPath}`);
+    console.log(`Traceability tests seen: ${output.testsSeen}`);
+    console.log(`Traceability runs generated: ${output.runsGenerated}`);
+    console.log(`Traceability changed files used: ${output.changedFilesUsed}`);
+    if (output.warnings.length > 0) {
+        console.log(`Traceability warnings: ${output.warnings.join(' | ')}`);
+    }
+}
+function runTraceabilityIngestCommand(args, autoConfig) {
+    if (!args.path && !autoConfig) {
+        console.error('Error: --path is required for traceability-ingest command');
+        process.exit(1);
+    }
+    if (!args.traceabilityInputPath) {
+        console.error('Error: --traceability-input <path> is required for traceability-ingest 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.traceabilityInputPath, 'utf-8'));
+    const output = (0, traceability_ingest_js_1.ingestTraceabilityInput)(reportRoot, config.impact.traceability, raw, {
+        minHits: args.traceabilityMinHits,
+        maxFilesPerTest: args.traceabilityMaxFilesPerTest,
+        maxAgeDays: args.traceabilityMaxAgeDays,
+    });
+    console.log(`Traceability manifest: ${output.manifestPath}`);
+    console.log(`Traceability state: ${output.statePath}`);
+    console.log(`Traceability ingested entries: ${output.entriesIngested}`);
+    console.log(`Traceability tracked tests: ${output.testsTracked}`);
+    console.log(`Traceability tracked edges: ${output.edgesTracked}`);
+    if (output.warnings.length > 0) {
+        console.log(`Traceability warnings: ${output.warnings.join(' | ')}`);
+    }
+}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"train.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/train.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,aAAa,CAAC;AAqI5C,wBAAsB,eAAe,CAAC,IAAI,EAAE,UAAU,EAAE,UAAU,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAgQ1F"}