@yasserkhanorg/impact-gate 2.0.0

package/dist/agentic/runner.js

@@ -0,0 +1,210 @@
+"use strict";
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runAgenticGeneration = runAgenticGeneration;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const playwright_runner_js_1 = require("./playwright_runner.js");
+const fix_loop_js_1 = require("./fix_loop.js");
+const generation_js_1 = require("../prompts/generation.js");
+const api_surface_js_1 = require("../knowledge/api_surface.js");
+const sanitize_js_1 = require("../crew/sanitize.js");
+function buildGeneratePrompt(scenario, apiSurfaceHint, profile) {
+    const projectName = profile?.projectName || 'Mattermost';
+    const importSource = profile?.importStatement || '@mattermost/playwright-lib';
+    const scenariosBlock = scenario.scenarios
+        .map((s, i) => `  ${i + 1}. ${(0, sanitize_js_1.sanitizeForPrompt)(s)}`)
+        .join('\n');
+    return [
+        `Generate a ${projectName} Playwright E2E test file.`,
+        '',
+        `FLOW: ${(0, sanitize_js_1.sanitizeForPrompt)(scenario.name)}`,
+        `Route Family: ${scenario.routeFamily}`,
+        `Priority: ${scenario.priority}`,
+        scenario.evidence ? `Evidence: ${(0, sanitize_js_1.sanitizeForPrompt)(scenario.evidence)}` : '',
+        '',
+        'SCENARIOS TO IMPLEMENT:',
+        scenariosBlock,
+        '',
+        'AVAILABLE PAGE OBJECTS AND METHODS:',
+        apiSurfaceHint || 'Use page.getByRole() or page.getByTestId() for selectors.',
+        '',
+        'MANDATORY RULES:',
+        `1. Import ONLY from "${importSource}" — no other test framework imports.`,
+        '2. Every test must call `await pw.initSetup()` first.',
+        '3. Use `await pw.testBrowser.login(user)` to log in — never hardcode credentials.',
+        '4. Use ONLY page object methods listed above. Do NOT invent methods.',
+        '5. If a method is not available, use `page.getByRole()` or `page.getByTestId()`.',
+        `6. Tag every test: {tag: '@${scenario.routeFamily}'}`,
+        '7. Write one test per scenario with a descriptive name.',
+        `8. Use \`expect\` from "${importSource}".`,
+        '9. Include the copyright header.',
+        '10. NEVER fabricate test IDs (MM-TXXXX). Use descriptive names only.',
+        '',
+        'EXAMPLE STRUCTURE:',
+        '```typescript',
+        '// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.',
+        '// See LICENSE.txt for license information.',
+        '',
+        `import {expect, test} from '${importSource}';`,
+        '',
+        'test(',
+        "    'user can post a message in channel',",
+        `    {tag: '@${scenario.routeFamily}'},`,
+        '    async ({pw}) => {',
+        '        const {user} = await pw.initSetup();',
+        '        const {channelsPage} = await pw.testBrowser.login(user);',
+        '        await channelsPage.goto();',
+        '        await channelsPage.toBeVisible();',
+        '        // test steps...',
+        '    },',
+        ');',
+        '```',
+        '',
+        'Return ONLY the TypeScript code. No explanations.',
+    ].filter(Boolean).join('\n');
+}
+function resolveSpecPath(scenario, testsRoot) {
+    let specPath;
+    if (scenario.targetSpec) {
+        specPath = (0, path_1.join)(testsRoot, scenario.targetSpec);
+    }
+    else {
+        const safeName = scenario.id.replace(/[^a-zA-Z0-9_-]/g, '_').toLowerCase();
+        const outputDir = (0, path_1.join)(testsRoot, 'specs', 'functional', 'ai-assisted');
+        specPath = (0, path_1.join)(outputDir, `${safeName}.spec.ts`);
+    }
+    // SECURITY: Prevent path traversal
+    const resolved = (0, path_1.resolve)(specPath);
+    const resolvedRoot = (0, path_1.resolve)(testsRoot);
+    if (!resolved.startsWith(resolvedRoot + '/') && resolved !== resolvedRoot) {
+        throw new Error(`Path traversal blocked: ${specPath} resolves outside testsRoot`);
+    }
+    if (!resolved.endsWith('.spec.ts') && !resolved.endsWith('.test.ts')) {
+        throw new Error(`Invalid spec path: must end in .spec.ts or .test.ts`);
+    }
+    return specPath;
+}
+async function generateInitialSpec(provider, scenario, specPath, apiSurfaceHint, profile) {
+    const prompt = buildGeneratePrompt(scenario, apiSurfaceHint, profile);
+    const response = await provider.generateText(prompt, {
+        maxTokens: 8000,
+        temperature: 0.1,
+        timeout: 60000,
+        systemPrompt: `You are an expert Playwright test writer for ${profile?.projectName || 'Mattermost'}. Return only TypeScript code.`,
+    });
+    // Reuse existing parsing logic from prompts/generation.ts
+    const parsed = (0, generation_js_1.parseGenerationResponse)(response.text, specPath, 'create_spec', scenario.id);
+    return parsed?.code ?? null;
+}
+async function runSingleScenario(scenario, options) {
+    const { config, provider } = options;
+    const warnings = [];
+    const specPath = resolveSpecPath(scenario, config.testsRoot);
+    // Build API surface hint
+    let apiHint = options.apiSurfaceHint || '';
+    if (!apiHint && options.apiSurface) {
+        const allClassNames = options.apiSurface.pageObjects.map((po) => po.className);
+        apiHint = (0, api_surface_js_1.formatApiSurfaceForPrompt)(options.apiSurface, allClassNames);
+    }
+    // Step 1: Generate initial spec
+    let specCode;
+    try {
+        specCode = await generateInitialSpec(provider, scenario, specPath, apiHint, options.generationProfile);
+    }
+    catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        warnings.push(`Generation failed for ${scenario.id}: ${msg}`);
+        return { specPath, scenarioSource: scenario.id, status: 'failed', attempts: 0, warnings };
+    }
+    if (!specCode) {
+        warnings.push(`LLM returned invalid code for ${scenario.id}`);
+        return { specPath, scenarioSource: scenario.id, status: 'failed', attempts: 0, warnings };
+    }
+    // Write the spec file
+    const dir = (0, path_1.dirname)(specPath);
+    if (!(0, fs_1.existsSync)(dir)) {
+        (0, fs_1.mkdirSync)(dir, { recursive: true });
+    }
+    (0, fs_1.writeFileSync)(specPath, specCode, 'utf-8');
+    // Dry run: skip execution
+    if (config.dryRun) {
+        return { specPath, scenarioSource: scenario.id, status: 'skipped', attempts: 0, warnings };
+    }
+    // Step 2: Run -> Fix loop
+    let lastRun;
+    for (let attempt = 1; attempt <= config.maxAttempts; attempt++) {
+        lastRun = (0, playwright_runner_js_1.runPlaywrightSpec)(specPath, config.testsRoot, {
+            project: config.project,
+            baseUrl: config.baseUrl,
+            timeoutMs: config.testTimeoutMs,
+        });
+        // All passed!
+        if (lastRun.failed === 0 && lastRun.compiled) {
+            return {
+                specPath,
+                scenarioSource: scenario.id,
+                status: 'passed',
+                attempts: attempt,
+                finalRun: lastRun,
+                warnings,
+            };
+        }
+        // If this is the last attempt, don't try to fix
+        if (attempt >= config.maxAttempts) {
+            break;
+        }
+        // Step 3: Fix
+        const currentCode = (0, fs_1.readFileSync)(specPath, 'utf-8');
+        try {
+            const fixResult = await (0, fix_loop_js_1.generateFix)(provider, {
+                specCode: currentCode,
+                failures: lastRun.failures,
+                attempt,
+                maxAttempts: config.maxAttempts,
+                apiSurfaceHint: apiHint,
+            });
+            if (fixResult.code) {
+                (0, fs_1.writeFileSync)(specPath, fixResult.code, 'utf-8');
+            }
+            else {
+                warnings.push(`Fix attempt ${attempt} returned invalid code for ${scenario.id}`);
+            }
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            warnings.push(`Fix attempt ${attempt} failed for ${scenario.id}: ${msg}`);
+        }
+    }
+    return {
+        specPath,
+        scenarioSource: scenario.id,
+        status: lastRun?.compiled === false ? 'compile-error' : 'max-attempts',
+        attempts: config.maxAttempts,
+        finalRun: lastRun,
+        warnings,
+    };
+}
+async function runAgenticGeneration(options) {
+    const startTime = Date.now();
+    const results = [];
+    const warnings = [];
+    for (const scenario of options.scenarios) {
+        const result = await runSingleScenario(scenario, options);
+        results.push(result);
+        warnings.push(...result.warnings);
+    }
+    const totalPassed = results.filter((r) => r.status === 'passed').length;
+    const totalFailed = results.filter((r) => r.status !== 'passed' && r.status !== 'skipped').length;
+    const totalAttempts = results.reduce((sum, r) => sum + r.attempts, 0);
+    return {
+        results,
+        totalGenerated: results.length,
+        totalPassed,
+        totalFailed,
+        totalAttempts,
+        durationMs: Date.now() - startTime,
+        warnings,
+    };
+}

package/dist/agentic/types.d.ts

@@ -0,0 +1,62 @@
+export interface TestFailure {
+    testTitle: string;
+    specPath: string;
+    error: string;
+    /** Truncated stack trace */
+    stack: string;
+    /** Expected vs actual if available */
+    expected?: string;
+    actual?: string;
+    /** Line number in spec where failure occurred */
+    line?: number;
+}
+export interface PlaywrightRunResult {
+    specPath: string;
+    passed: number;
+    failed: number;
+    flaky: number;
+    skipped: number;
+    failures: TestFailure[];
+    /** Raw stdout (truncated) */
+    stdout: string;
+    /** Duration in ms */
+    durationMs: number;
+    /** Whether the spec even compiled */
+    compiled: boolean;
+}
+export interface AgenticConfig {
+    /** Max fix attempts before giving up (default: 3) */
+    maxAttempts: number;
+    /** Playwright project to use (default: 'chrome') */
+    project: string;
+    /** Base URL for Playwright (e.g. http://localhost:8065) */
+    baseUrl?: string;
+    /** Timeout per test run in ms (default: 120000) */
+    testTimeoutMs: number;
+    /** LLM provider override */
+    provider?: string;
+    /** Whether to use Playwright MCP for browser exploration */
+    useMcp?: boolean;
+    /** Dry run — generate but don't run tests */
+    dryRun?: boolean;
+    /** Tests root directory */
+    testsRoot: string;
+}
+export interface AgenticResult {
+    specPath: string;
+    scenarioSource: string;
+    status: 'passed' | 'failed' | 'max-attempts' | 'compile-error' | 'skipped';
+    attempts: number;
+    finalRun?: PlaywrightRunResult;
+    warnings: string[];
+}
+export interface AgenticSummary {
+    results: AgenticResult[];
+    totalGenerated: number;
+    totalPassed: number;
+    totalFailed: number;
+    totalAttempts: number;
+    durationMs: number;
+    warnings: string[];
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/agentic/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/agentic/types.ts"],"names":[],"mappings":"AAGA,MAAM,WAAW,WAAW;IACxB,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,4BAA4B;IAC5B,KAAK,EAAE,MAAM,CAAC;IACd,sCAAsC;IACtC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,iDAAiD;IACjD,IAAI,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,mBAAmB;IAChC,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,WAAW,EAAE,CAAC;IACxB,6BAA6B;IAC7B,MAAM,EAAE,MAAM,CAAC;IACf,qBAAqB;IACrB,UAAU,EAAE,MAAM,CAAC;IACnB,qCAAqC;IACrC,QAAQ,EAAE,OAAO,CAAC;CACrB;AAED,MAAM,WAAW,aAAa;IAC1B,qDAAqD;IACrD,WAAW,EAAE,MAAM,CAAC;IACpB,oDAAoD;IACpD,OAAO,EAAE,MAAM,CAAC;IAChB,2DAA2D;IAC3D,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,mDAAmD;IACnD,aAAa,EAAE,MAAM,CAAC;IACtB,4BAA4B;IAC5B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,4DAA4D;IAC5D,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,6CAA6C;IAC7C,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,2BAA2B;IAC3B,SAAS,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,aAAa;IAC1B,QAAQ,EAAE,MAAM,CAAC;IACjB,cAAc,EAAE,MAAM,CAAC;IACvB,MAAM,EAAE,QAAQ,GAAG,QAAQ,GAAG,cAAc,GAAG,eAAe,GAAG,SAAS,CAAC;IAC3E,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,mBAAmB,CAAC;IAC/B,QAAQ,EAAE,MAAM,EAAE,CAAC;CACtB;AAED,MAAM,WAAW,cAAc;IAC3B,OAAO,EAAE,aAAa,EAAE,CAAC;IACzB,cAAc,EAAE,MAAM,CAAC;IACvB,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;IACpB,aAAa,EAAE,MAAM,CAAC;IACtB,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,MAAM,EAAE,CAAC;CACtB"}

package/dist/agentic/types.js

@@ -0,0 +1,4 @@
+"use strict";
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/agents/coverage-evaluator.d.ts

@@ -0,0 +1,8 @@
+import type { Agent, AgentTask, AgentResult } from '../crew/protocol.js';
+import type { CrewContext } from '../crew/context.js';
+import type { AgentRole } from '../crew/types.js';
+export declare class CoverageEvaluatorAgent implements Agent {
+    readonly role: AgentRole;
+    execute(_task: AgentTask, ctx: CrewContext): Promise<AgentResult>;
+}
+//# sourceMappingURL=coverage-evaluator.d.ts.map

package/dist/agents/coverage-evaluator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"coverage-evaluator.d.ts","sourceRoot":"","sources":["../../src/agents/coverage-evaluator.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAC,KAAK,EAAE,SAAS,EAAE,WAAW,EAAC,MAAM,qBAAqB,CAAC;AACvE,OAAO,KAAK,EAAC,WAAW,EAAC,MAAM,oBAAoB,CAAC;AACpD,OAAO,KAAK,EAAC,SAAS,EAAC,MAAM,kBAAkB,CAAC;AAEhD,qBAAa,sBAAuB,YAAW,KAAK;IAChD,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAwB;IAE1C,OAAO,CAAC,KAAK,EAAE,SAAS,EAAE,GAAG,EAAE,WAAW,GAAG,OAAO,CAAC,WAAW,CAAC;CAmC1E"}

package/dist/agents/coverage-evaluator.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.CoverageEvaluatorAgent = void 0;
+/**
+ * Coverage Evaluator Agent — wraps pipeline stage2 (coverage evaluation) in the Agent interface.
+ */
+const stage2_coverage_js_1 = require("../pipeline/stage2_coverage.js");
+class CoverageEvaluatorAgent {
+    constructor() {
+        this.role = 'coverage-evaluator';
+    }
+    async execute(_task, ctx) {
+        const warnings = [];
+        if (ctx.impactedFlows.length === 0) {
+            warnings.push('Coverage evaluator: no impacted flows to evaluate.');
+            return { role: this.role, status: 'partial', output: [], warnings };
+        }
+        try {
+            const result = await (0, stage2_coverage_js_1.runCoverageStage)(ctx.impactedFlows, ctx.specIndex, ctx.context, ctx.testsRoot, { provider: ctx.providerOverride });
+            // Replace impacted flows with coverage-enriched versions.
+            // This is intentionally a full replace (not push) because coverage evaluation
+            // returns the same flow IDs with updated coverage fields.
+            ctx.impactedFlows = result.decisions;
+            warnings.push(...result.warnings);
+            return {
+                role: this.role,
+                status: 'success',
+                output: result.decisions,
+                warnings,
+            };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            warnings.push(`Coverage evaluator failed: ${message}`);
+            return { role: this.role, status: 'failed', output: null, warnings };
+        }
+    }
+}
+exports.CoverageEvaluatorAgent = CoverageEvaluatorAgent;

package/dist/agents/cross-impact.d.ts

@@ -0,0 +1,13 @@
+import type { Agent, AgentTask, AgentResult } from '../crew/protocol.js';
+import type { CrewContext } from '../crew/context.js';
+import type { AgentRole } from '../crew/types.js';
+export declare class CrossImpactAgent implements Agent {
+    readonly role: AgentRole;
+    execute(_task: AgentTask, ctx: CrewContext): Promise<AgentResult>;
+    /**
+     * Deterministic cross-impact detection: find families that share webapp/server paths
+     * or components with the directly impacted families.
+     */
+    private detectDeterministic;
+}
+//# sourceMappingURL=cross-impact.d.ts.map

package/dist/agents/cross-impact.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cross-impact.d.ts","sourceRoot":"","sources":["../../src/agents/cross-impact.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAC,KAAK,EAAE,SAAS,EAAE,WAAW,EAAC,MAAM,qBAAqB,CAAC;AACvE,OAAO,KAAK,EAAC,WAAW,EAAC,MAAM,oBAAoB,CAAC;AACpD,OAAO,KAAK,EAAC,SAAS,EAAc,MAAM,kBAAkB,CAAC;AAK7D,qBAAa,gBAAiB,YAAW,KAAK;IAC1C,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAkB;IAEpC,OAAO,CAAC,KAAK,EAAE,SAAS,EAAE,GAAG,EAAE,WAAW,GAAG,OAAO,CAAC,WAAW,CAAC;IA4FvE;;;OAGG;IACH,OAAO,CAAC,mBAAmB;CAyC9B"}

package/dist/agents/cross-impact.js

@@ -0,0 +1,140 @@
+"use strict";
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CrossImpactAgent = void 0;
+/**
+ * Cross-Impact Analyst Agent — finds ripple effects across route families
+ * by analyzing shared dependencies between changed families and all other families.
+ */
+const provider_js_1 = require("../crew/provider.js");
+const cross_impact_js_1 = require("../prompts/cross-impact.js");
+const VALID_RISK = new Set(['high', 'medium', 'low']);
+const MAX_CROSS_IMPACTS = 50;
+class CrossImpactAgent {
+    constructor() {
+        this.role = 'cross-impact';
+    }
+    async execute(_task, ctx) {
+        const warnings = [];
+        if (ctx.routeFamilies.length === 0) {
+            warnings.push('Cross-impact: no route families available.');
+            return { role: this.role, status: 'partial', output: [], warnings };
+        }
+        // Determine directly impacted families from family groups
+        const directlyImpacted = new Set(ctx.familyGroups.map((g) => g.familyId));
+        if (directlyImpacted.size === 0) {
+            warnings.push('Cross-impact: no directly impacted families.');
+            return { role: this.role, status: 'partial', output: [], warnings };
+        }
+        // First: deterministic cross-impact detection via shared paths
+        const deterministicCrossImpacts = this.detectDeterministic(ctx, directlyImpacted)
+            .slice(0, MAX_CROSS_IMPACTS);
+        ctx.crossImpacts.push(...deterministicCrossImpacts);
+        // Then: LLM-enriched analysis for semantic cross-impacts
+        try {
+            const provider = await (0, provider_js_1.getCrewProvider)(ctx.providerOverride, ctx.budgetUSD, {
+                agentRole: 'cross-impact',
+                modelRoutingProviderType: ctx.modelRoutingProviderType,
+                modelRoutingOverrides: ctx.modelRoutingOverrides,
+                budgetLedger: ctx.budgetLedger,
+            });
+            const prompt = (0, cross_impact_js_1.buildCrossImpactPrompt)({
+                changedFiles: ctx.changedFiles,
+                families: ctx.routeFamilies,
+                directlyImpactedFamilyIds: Array.from(directlyImpacted),
+            });
+            const response = await provider.generateText(prompt, {
+                maxTokens: 3000,
+                temperature: 0,
+                timeout: 45000,
+                systemPrompt: 'Return only valid JSON. Do not include markdown fences unless necessary.',
+            });
+            const parsed = (0, cross_impact_js_1.parseCrossImpactResponse)(response.text);
+            if (parsed && parsed.crossImpacts.length > 0) {
+                const familyIds = new Set(ctx.routeFamilies.map((f) => f.id));
+                const llmCrossImpacts = parsed.crossImpacts
+                    .filter((ci) => familyIds.has(ci.sourceFamily) &&
+                    familyIds.has(ci.affectedFamily) &&
+                    ci.sourceFamily !== ci.affectedFamily)
+                    .map((ci) => ({
+                    sourceFamily: ci.sourceFamily,
+                    affectedFamily: ci.affectedFamily,
+                    sharedDependency: ci.sharedDependency || 'unknown',
+                    riskLevel: VALID_RISK.has(ci.riskLevel) ? ci.riskLevel : 'low',
+                    evidence: ci.evidence || '',
+                }));
+                // Deduplicate against deterministic results
+                const existing = new Set(ctx.crossImpacts.map((ci) => `${ci.sourceFamily}->${ci.affectedFamily}`));
+                for (const ci of llmCrossImpacts) {
+                    if (ctx.crossImpacts.length >= MAX_CROSS_IMPACTS)
+                        break;
+                    const key = `${ci.sourceFamily}->${ci.affectedFamily}`;
+                    if (!existing.has(key)) {
+                        ctx.crossImpacts.push(ci);
+                        existing.add(key);
+                    }
+                }
+            }
+            return {
+                role: this.role,
+                status: ctx.crossImpacts.length > 0 ? 'success' : 'partial',
+                output: ctx.crossImpacts,
+                usage: provider.getUsageStats(),
+                warnings,
+            };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            warnings.push(`Cross-impact LLM analysis failed: ${message}. Using deterministic results only.`);
+            return {
+                role: this.role,
+                status: deterministicCrossImpacts.length > 0 ? 'partial' : 'failed',
+                output: ctx.crossImpacts,
+                warnings,
+            };
+        }
+    }
+    /**
+     * Deterministic cross-impact detection: find families that share webapp/server paths
+     * or components with the directly impacted families.
+     */
+    detectDeterministic(ctx, directlyImpacted) {
+        const results = [];
+        for (const sourceId of directlyImpacted) {
+            const source = ctx.routeFamilies.find((f) => f.id === sourceId);
+            if (!source)
+                continue;
+            const sourcePaths = new Set([
+                ...(source.webappPaths || []),
+                ...(source.serverPaths || []),
+                ...(source.components || []),
+            ]);
+            if (sourcePaths.size === 0)
+                continue;
+            for (const target of ctx.routeFamilies) {
+                if (target.id === sourceId)
+                    continue;
+                const targetPaths = [
+                    ...(target.webappPaths || []),
+                    ...(target.serverPaths || []),
+                    ...(target.components || []),
+                ];
+                for (const path of targetPaths) {
+                    if (sourcePaths.has(path)) {
+                        results.push({
+                            sourceFamily: sourceId,
+                            affectedFamily: target.id,
+                            sharedDependency: path,
+                            riskLevel: 'medium',
+                            evidence: `Shared path: ${path} is referenced by both ${sourceId} and ${target.id}`,
+                        });
+                        break; // One match per family pair is enough
+                    }
+                }
+            }
+        }
+        return results;
+    }
+}
+exports.CrossImpactAgent = CrossImpactAgent;

package/dist/agents/executor.d.ts

@@ -0,0 +1,8 @@
+import type { Agent, AgentTask, AgentResult } from '../crew/protocol.js';
+import type { CrewContext } from '../crew/context.js';
+import type { AgentRole } from '../crew/types.js';
+export declare class ExecutorAgent implements Agent {
+    readonly role: AgentRole;
+    execute(_task: AgentTask, ctx: CrewContext): Promise<AgentResult>;
+}
+//# sourceMappingURL=executor.d.ts.map

package/dist/agents/executor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"executor.d.ts","sourceRoot":"","sources":["../../src/agents/executor.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAC,KAAK,EAAE,SAAS,EAAE,WAAW,EAAC,MAAM,qBAAqB,CAAC;AACvE,OAAO,KAAK,EAAC,WAAW,EAAC,MAAM,oBAAoB,CAAC;AACpD,OAAO,KAAK,EAAC,SAAS,EAAC,MAAM,kBAAkB,CAAC;AAKhD,qBAAa,aAAc,YAAW,KAAK;IACvC,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAc;IAEhC,OAAO,CAAC,KAAK,EAAE,SAAS,EAAE,GAAG,EAAE,WAAW,GAAG,OAAO,CAAC,WAAW,CAAC;CA6D1E"}

package/dist/agents/executor.js

@@ -0,0 +1,75 @@
+"use strict";
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExecutorAgent = void 0;
+/**
+ * Executor Agent — wraps agentic test execution in the Agent interface.
+ * Runs generated specs through Playwright and collects results.
+ */
+const provider_js_1 = require("../crew/provider.js");
+const runner_js_1 = require("../agentic/runner.js");
+const MAX_FIX_ATTEMPTS = 2;
+const TEST_TIMEOUT_MS = 120000;
+class ExecutorAgent {
+    constructor() {
+        this.role = 'executor';
+    }
+    async execute(_task, ctx) {
+        const warnings = [];
+        const writtenSpecs = ctx.generatedSpecs.filter((s) => s.written);
+        if (writtenSpecs.length === 0) {
+            warnings.push('Executor: no written specs to execute.');
+            return { role: this.role, status: 'partial', output: null, warnings };
+        }
+        // Build ScenarioInput[] from generated specs + impacted flows
+        const flowMap = new Map(ctx.impactedFlows.map((f) => [f.flowId, f]));
+        const scenarios = writtenSpecs.map((spec) => {
+            const flow = flowMap.get(spec.flowId);
+            return {
+                id: spec.flowId,
+                name: flow?.flowName || spec.flowId,
+                scenarios: flow?.scenariosToAdd || [],
+                routeFamily: flow?.routeFamily || 'unknown',
+                priority: flow?.priority || 'P2',
+                targetSpec: spec.mode === 'add_scenarios' ? spec.specPath : undefined,
+                changedFiles: flow?.changedFiles,
+                evidence: flow?.evidence,
+            };
+        });
+        try {
+            const provider = await (0, provider_js_1.getCrewProvider)(ctx.providerOverride, ctx.budgetUSD, {
+                agentRole: 'executor',
+                modelRoutingProviderType: ctx.modelRoutingProviderType,
+                modelRoutingOverrides: ctx.modelRoutingOverrides,
+                budgetLedger: ctx.budgetLedger,
+            });
+            const summary = await (0, runner_js_1.runAgenticGeneration)({
+                scenarios,
+                config: {
+                    maxAttempts: MAX_FIX_ATTEMPTS,
+                    project: 'chrome',
+                    testTimeoutMs: TEST_TIMEOUT_MS,
+                    provider: ctx.providerOverride,
+                    testsRoot: ctx.testsRoot,
+                },
+                provider,
+                apiSurface: ctx.apiSurface,
+            });
+            warnings.push(...summary.warnings);
+            return {
+                role: this.role,
+                status: summary.totalPassed > 0 ? 'success' : 'partial',
+                output: summary,
+                usage: provider.getUsageStats(),
+                warnings,
+            };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            warnings.push(`Executor failed: ${message}`);
+            return { role: this.role, status: 'failed', output: null, warnings };
+        }
+    }
+}
+exports.ExecutorAgent = ExecutorAgent;

package/dist/agents/explorer.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Explorer Agent — wraps the QA agent browser exploration loop in the Agent interface.
+ * This agent is optional and only runs when a browser environment is available.
+ */
+import type { Agent, AgentTask, AgentResult } from '../crew/protocol.js';
+import type { CrewContext } from '../crew/context.js';
+import type { AgentRole } from '../crew/types.js';
+export declare class ExplorerAgent implements Agent {
+    readonly role: AgentRole;
+    execute(_task: AgentTask, ctx: CrewContext): Promise<AgentResult>;
+}
+//# sourceMappingURL=explorer.d.ts.map

package/dist/agents/explorer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"explorer.d.ts","sourceRoot":"","sources":["../../src/agents/explorer.ts"],"names":[],"mappings":"AAGA;;;GAGG;AAEH,OAAO,KAAK,EAAC,KAAK,EAAE,SAAS,EAAE,WAAW,EAAC,MAAM,qBAAqB,CAAC;AACvE,OAAO,KAAK,EAAC,WAAW,EAAC,MAAM,oBAAoB,CAAC;AACpD,OAAO,KAAK,EAAC,SAAS,EAAC,MAAM,kBAAkB,CAAC;AAEhD,qBAAa,aAAc,YAAW,KAAK;IACvC,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAc;IAEhC,OAAO,CAAC,KAAK,EAAE,SAAS,EAAE,GAAG,EAAE,WAAW,GAAG,OAAO,CAAC,WAAW,CAAC;CAmC1E"}

package/dist/agents/explorer.js

@@ -0,0 +1,43 @@
+"use strict";
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExplorerAgent = void 0;
+class ExplorerAgent {
+    constructor() {
+        this.role = 'explorer';
+    }
+    async execute(_task, ctx) {
+        const warnings = [];
+        // Explorer requires browser environment — skip gracefully if not available
+        try {
+            // Build target flows from impacted flows
+            const targetFlows = ctx.impactedFlows
+                .filter((d) => d.action !== 'cannot_determine')
+                .map((d) => ({
+                id: d.flowId,
+                name: d.flowName,
+                url: d.specificRoute,
+                priority: d.priority,
+            }));
+            if (targetFlows.length === 0) {
+                warnings.push('Explorer: no target flows for exploration.');
+                return { role: this.role, status: 'partial', output: null, warnings };
+            }
+            // Convert QA findings to crew findings
+            warnings.push(`Explorer: ${targetFlows.length} flows available for exploration (requires browser environment).`);
+            return {
+                role: this.role,
+                status: 'partial',
+                output: { targetFlows },
+                warnings,
+            };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            warnings.push(`Explorer failed: ${message}`);
+            return { role: this.role, status: 'failed', output: null, warnings };
+        }
+    }
+}
+exports.ExplorerAgent = ExplorerAgent;

package/dist/agents/generator.d.ts

@@ -0,0 +1,8 @@
+import type { Agent, AgentTask, AgentResult } from '../crew/protocol.js';
+import type { CrewContext } from '../crew/context.js';
+import type { AgentRole } from '../crew/types.js';
+export declare class GeneratorAgent implements Agent {
+    readonly role: AgentRole;
+    execute(_task: AgentTask, ctx: CrewContext): Promise<AgentResult>;
+}
+//# sourceMappingURL=generator.d.ts.map

package/dist/agents/generator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generator.d.ts","sourceRoot":"","sources":["../../src/agents/generator.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAC,KAAK,EAAE,SAAS,EAAE,WAAW,EAAC,MAAM,qBAAqB,CAAC;AACvE,OAAO,KAAK,EAAC,WAAW,EAAC,MAAM,oBAAoB,CAAC;AACpD,OAAO,KAAK,EAAC,SAAS,EAAC,MAAM,kBAAkB,CAAC;AA6ChD,qBAAa,cAAe,YAAW,KAAK;IACxC,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAe;IAEjC,OAAO,CAAC,KAAK,EAAE,SAAS,EAAE,GAAG,EAAE,WAAW,GAAG,OAAO,CAAC,WAAW,CAAC;CAoC1E"}