@yasserkhanorg/e2e-agents 0.5.16 → 0.6.0

package/dist/esm/agent/types.js

@@ -0,0 +1,3 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+export {};

package/dist/esm/api.js

@@ -1,21 +1,13 @@
 // Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
 // See LICENSE.txt for license information.
-import { existsSync, readFileSync } from 'fs';
-import { join } from 'path';
 import { resolveConfig } from './agent/config.js';
-import { runGap, runImpact } from './agent/runner.js';
-import { appendPlanMetrics, attachDeveloperActions, buildPlanFromImpactReport, renderCiSummaryMarkdown, writeCiSummary, writePlanReport, } from './agent/plan.js';
-import { applyOperationalInsights } from './agent/operational_insights.js';
+import { appendPlanMetrics, } from './agent/plan.js';
+import { analyzeImpact as analyzeImpactV2 } from './engine/impact_engine.js';
+import { buildPlanFromImpact, renderCiSummaryMarkdown, writeCiSummary, writePlanReport, } from './engine/plan_builder.js';
+import { getChangedFiles } from './agent/git.js';
 import { finalizeGeneratedTests } from './agent/handoff.js';
 import { ingestTraceabilityInput, } from './agent/traceability_ingest.js';
 import { captureTraceabilityInput, } from './agent/traceability_capture.js';
-function readReportJson(reportPath) {
-    if (!existsSync(reportPath)) {
-        throw new Error(`Expected report not found: ${reportPath}`);
-    }
-    const raw = readFileSync(reportPath, 'utf-8');
-    return JSON.parse(raw);
-}
 function resolveAgent(options, mode) {
     const cwd = options.cwd || process.cwd();
     const { config } = resolveConfig(cwd, options.configPath, {
@@ -27,63 +19,42 @@ function resolveAgent(options, mode) {
     }
     return config;
 }
-function reportPathFor(configPath, mode) {
-    return join(configPath, '.e2e-ai-agents', mode === 'impact' ? 'impact.json' : 'gap.json');
+export function handoffGeneratedTests(options) {
+    return finalizeGeneratedTests(options);
 }
-export async function analyzeImpact(options = {}) {
-    const config = resolveAgent(options, 'impact');
-    await runImpact(config, { apply: options.apply ?? false });
+export function ingestTraceability(options) {
+    const cwd = options.cwd || process.cwd();
+    const { config } = resolveConfig(cwd, options.configPath, {
+        path: options.path,
+        testsRoot: options.testsRoot,
+        mode: 'impact',
+    });
     const reportRoot = config.testsRoot || config.path;
-    const reportPath = reportPathFor(reportRoot, 'impact');
-    const report = readReportJson(reportPath);
-    return { report, reportPath };
+    return ingestTraceabilityInput(reportRoot, config.impact.traceability, options.payload, options.options);
 }
-export async function findGaps(options = {}) {
-    const config = resolveAgent(options, 'gap');
-    await runGap(config, { apply: options.apply ?? false });
+export function analyzeImpactDeterministic(options = {}) {
+    const config = resolveAgent(options, 'impact');
     const reportRoot = config.testsRoot || config.path;
-    const reportPath = reportPathFor(reportRoot, 'gap');
-    const report = readReportJson(reportPath);
-    return { report, reportPath };
+    const gitResult = getChangedFiles(config.path, config.git.since, { includeUncommitted: config.git.includeUncommitted });
+    return analyzeImpactV2(gitResult.files, {
+        testsRoot: reportRoot,
+        routeFamilies: config.routeFamilies,
+    });
 }
-export async function recommendTests(options = {}) {
+export function recommendTestsDeterministic(options = {}) {
     const config = resolveAgent(options, 'impact');
-    await runImpact(config, { apply: options.apply ?? false });
     const reportRoot = config.testsRoot || config.path;
-    const impactPath = reportPathFor(reportRoot, 'impact');
-    const report = readReportJson(impactPath);
-    const basePlan = buildPlanFromImpactReport(report, config.policy);
-    const withActions = attachDeveloperActions(basePlan, {
-        appPath: config.path,
+    const gitResult = getChangedFiles(config.path, config.git.since, { includeUncommitted: config.git.includeUncommitted });
+    const impact = analyzeImpactV2(gitResult.files, {
         testsRoot: reportRoot,
-        sinceRef: config.git.since,
+        routeFamilies: config.routeFamilies,
     });
-    const plan = applyOperationalInsights(withActions, reportRoot);
+    const plan = buildPlanFromImpact(impact, config.policy);
     const planPath = writePlanReport(reportRoot, plan);
     const ciSummaryMarkdown = renderCiSummaryMarkdown(plan);
     const ciSummaryPath = writeCiSummary(reportRoot, ciSummaryMarkdown);
     appendPlanMetrics(reportRoot, plan);
-    return {
-        report,
-        reportPath: impactPath,
-        plan,
-        planPath,
-        ciSummaryMarkdown,
-        ciSummaryPath,
-    };
-}
-export function handoffGeneratedTests(options) {
-    return finalizeGeneratedTests(options);
-}
-export function ingestTraceability(options) {
-    const cwd = options.cwd || process.cwd();
-    const { config } = resolveConfig(cwd, options.configPath, {
-        path: options.path,
-        testsRoot: options.testsRoot,
-        mode: 'impact',
-    });
-    const reportRoot = config.testsRoot || config.path;
-    return ingestTraceabilityInput(reportRoot, config.impact.traceability, options.payload, options.options);
+    return { impact, plan, planPath, ciSummaryMarkdown, ciSummaryPath };
 }
 export function captureTraceability(options) {
     const cwd = options.cwd || process.cwd();

package/dist/esm/cli.js

@@ -1,14 +1,15 @@
 #!/usr/bin/env node
 // Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
 // See LICENSE.txt for license information.
-import { appendFileSync, existsSync, readFileSync, writeFileSync } from 'fs';
+import { appendFileSync, existsSync, readFileSync } from 'fs';
 import { dirname, join, resolve } from 'path';
 import { resolveConfig } from './agent/config.js';
 import { AnthropicProvider } from './anthropic_provider.js';
 import { LLMProviderError } from './provider_interface.js';
-import { runGap, runImpact } from './agent/runner.js';
-import { appendPlanMetrics, attachDeveloperActions, buildPlanFromImpactReport, renderCiSummaryMarkdown, writeCiSummary, writePlanReport, } from './agent/plan.js';
-import { applyOperationalInsights } from './agent/operational_insights.js';
+import { appendPlanMetrics } from './agent/plan.js';
+import { analyzeImpact as analyzeImpactV2 } from './engine/impact_engine.js';
+import { buildPlanFromImpact, renderCiSummaryMarkdown, writeCiSummary, writePlanReport, } from './engine/plan_builder.js';
+import { getChangedFiles } from './agent/git.js';
 import { appendFeedbackAndRecompute } from './agent/feedback.js';
 import { finalizeGeneratedTests } from './agent/handoff.js';
 import { ingestTraceabilityInput } from './agent/traceability_ingest.js';
@@ -59,13 +60,9 @@ function printUsage() {
     console.log([
         'Usage:',
         '  e2e-ai-agents impact --path <app-root> [options]',
-        '  e2e-ai-agents gap --path <app-root> [options]',
         '  e2e-ai-agents plan --path <app-root> [options]',
-        '  e2e-ai-agents generate --path <app-root> [options]',
-        '  e2e-ai-agents heal --path <app-root> --traceability-report <json> [options]',
         '  e2e-ai-agents suggest --path <app-root> [options]',
-        '  e2e-ai-agents approve-and-generate --path <app-root> [options]',
-        '  e2e-ai-agents auto-heal-pr --path <app-root> [options]',
+        '  e2e-ai-agents heal --path <app-root> --traceability-report <json> [options]',
         '  e2e-ai-agents finalize-generated-tests --path <app-root> [options]',
         '  e2e-ai-agents feedback --path <app-root> --feedback-input <json>',
         '  e2e-ai-agents traceability-capture --path <app-root> --traceability-report <json>',
@@ -144,13 +141,9 @@ function parseArgs(argv) {
     }
     const command = argv[0];
     if (command === 'impact'
-        || command === 'gap'
         || command === 'plan'
-        || command === 'generate'
         || command === 'heal'
         || command === 'suggest'
-        || command === 'approve-and-generate'
-        || command === 'auto-heal-pr'
         || command === 'finalize-generated-tests'
         || command === 'feedback'
         || command === 'traceability-capture'
@@ -759,117 +752,6 @@ async function main() {
         }
         return;
     }
-    if (args.command === 'auto-heal-pr') {
-        if (!args.path && !autoConfig) {
-            // eslint-disable-next-line no-console
-            console.error('Error: --path is required for auto-heal-pr command');
-            process.exit(1);
-        }
-        const { config } = resolveConfig(process.cwd(), autoConfig, {
-            path: args.path,
-            profile: args.profile,
-            testsRoot: args.testsRoot,
-            mode: 'gap',
-            framework: args.framework,
-            timeLimitMinutes: args.timeLimitMinutes,
-            budget: {
-                maxUSD: args.budgetUSD,
-                maxTokens: args.budgetTokens,
-            },
-            testPatterns: args.testPatterns,
-            flowPatterns: args.flowPatterns,
-            flowExclude: args.flowExclude,
-            flowCatalogPath: args.flowCatalogPath,
-            specPDF: args.specPDF,
-            gitSince: args.gitSince,
-            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,
-        });
-        if (args.allowFallback) {
-            config.impact.allowFallback = true;
-        }
-        await runGap(config, { apply: true });
-        const reportRoot = config.testsRoot || config.path;
-        if (args.traceabilityReportPath) {
-            const unstableSpecs = extractPlaywrightUnstableSpecs(args.traceabilityReportPath, [reportRoot, config.path]);
-            if (unstableSpecs.length > 0) {
-                const targetedSummary = 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;
-                // eslint-disable-next-line no-console
-                console.log(`Auto-heal targeted unstable specs: ${unstableSpecs.length} (healed=${healedCount})`);
-                if (targetedSummary.warnings.length > 0) {
-                    // eslint-disable-next-line no-console
-                    console.log(`Auto-heal warnings: ${targetedSummary.warnings.join(' | ')}`);
-                }
-                const gapPath = join(reportRoot, '.e2e-ai-agents', 'gap.json');
-                if (existsSync(gapPath)) {
-                    const gap = JSON.parse(readFileSync(gapPath, 'utf-8'));
-                    const existingResults = Array.isArray(gap.pipeline?.results) ? gap.pipeline?.results : [];
-                    const existingWarnings = Array.isArray(gap.pipeline?.warnings) ? gap.pipeline?.warnings : [];
-                    gap.pipeline = {
-                        runner: gap.pipeline?.runner || targetedSummary.runner,
-                        results: [...existingResults, ...targetedSummary.results],
-                        warnings: Array.from(new Set([...(existingWarnings || []), ...targetedSummary.warnings])),
-                    };
-                    writeFileSync(gapPath, `${JSON.stringify(gap, null, 2)}\n`, 'utf-8');
-                }
-            }
-            else {
-                // eslint-disable-next-line no-console
-                console.log('Auto-heal targeted unstable specs: 0');
-            }
-        }
-        const branchSuffix = new Date().toISOString().replace(/[:.]/g, '-');
-        const result = finalizeGeneratedTests({
-            appPath: config.path,
-            testsRoot: reportRoot,
-            branch: args.branch || `auto-heal-${branchSuffix}`,
-            commitMessage: args.commitMessage || 'test(e2e): auto-heal generated specs',
-            createPr: true,
-            prTitle: args.prTitle || 'test(e2e): auto-heal generated specs',
-            prBody: args.prBody || 'Automated e2e-heal run generated by @yasserkhanorg/e2e-agents.',
-            baseBranch: args.prBase || 'master',
-            dryRun: args.dryRun,
-        });
-        // eslint-disable-next-line no-console
-        console.log(`Auto-heal repo root: ${result.repoRoot}`);
-        // eslint-disable-next-line no-console
-        console.log(`Auto-heal branch: ${result.branch}`);
-        // eslint-disable-next-line no-console
-        console.log(`Auto-heal staged paths: ${result.stagedPaths.join(', ') || 'none'}`);
-        // eslint-disable-next-line no-console
-        console.log(`Auto-heal commit: ${result.committed ? 'created' : 'skipped'}`);
-        if (result.commitSha) {
-            // eslint-disable-next-line no-console
-            console.log(`Auto-heal commit sha: ${result.commitSha}`);
-        }
-        if (result.prUrl) {
-            // eslint-disable-next-line no-console
-            console.log(`Auto-heal PR: ${result.prUrl}`);
-        }
-        return;
-    }
     if (args.command === 'heal') {
         if (!args.path && !autoConfig) {
             // eslint-disable-next-line no-console
@@ -934,13 +816,11 @@ async function main() {
         printUsage();
         process.exit(1);
     }
-    const forcePipelineFromApproval = args.command === 'approve-and-generate' || args.command === 'generate';
-    const forceAIPipelineFromApproval = args.command === 'approve-and-generate' || args.command === 'generate';
-    const { config, configPath } = resolveConfig(process.cwd(), autoConfig, {
+    const { config } = resolveConfig(process.cwd(), autoConfig, {
         path: args.path,
         profile: args.profile,
         testsRoot: args.testsRoot,
-        mode: (args.command === 'gap' || args.command === 'approve-and-generate' || args.command === 'generate') ? 'gap' : 'impact',
+        mode: 'impact',
         framework: args.framework,
         timeLimitMinutes: args.timeLimitMinutes,
         budget: {
@@ -954,7 +834,7 @@ async function main() {
         specPDF: args.specPDF,
         gitSince: args.gitSince,
         llmProvider: args.llmProvider,
-        pipeline: (args.pipeline || forcePipelineFromApproval)
+        pipeline: args.pipeline
             ? {
                 enabled: true,
                 scenarios: args.pipelineScenarios,
@@ -965,9 +845,9 @@ async function main() {
                 project: args.pipelineProject,
                 parallel: args.pipelineParallel,
                 dryRun: args.pipelineDryRun,
-                mcp: args.pipelineMcp !== undefined ? args.pipelineMcp : forceAIPipelineFromApproval,
+                mcp: args.pipelineMcp,
                 mcpAllowFallback: args.pipelineMcpAllowFallback,
-                mcpOnly: args.pipelineMcpOnly !== undefined ? args.pipelineMcpOnly : forceAIPipelineFromApproval,
+                mcpOnly: args.pipelineMcpOnly,
                 mcpCommandTimeoutMs: args.pipelineMcpTimeoutMs,
                 mcpRetries: args.pipelineMcpRetries,
             }
@@ -988,42 +868,38 @@ async function main() {
             }
             : undefined,
     });
-    if (args.allowFallback) {
-        config.impact.allowFallback = true;
-    }
     if (args.command === 'impact') {
-        await runImpact(config, { apply: args.apply });
-        return;
-    }
-    if (args.command === 'suggest' || args.command === 'plan') {
         const reportRoot = config.testsRoot || config.path;
-        const impactPath = join(reportRoot, '.e2e-ai-agents', 'impact.json');
-        try {
-            await runImpact(config, { apply: args.apply });
-        }
-        catch (err) {
-            // If impact analysis already ran (e.g. a prior CI step wrote impact.json),
-            // fall back to that data rather than failing the plan step.
-            if (existsSync(impactPath)) {
+        const gitResult = getChangedFiles(config.path, config.git.since, { includeUncommitted: config.git.includeUncommitted });
+        const impactResult = analyzeImpactV2(gitResult.files, {
+            testsRoot: reportRoot,
+            routeFamilies: config.routeFamilies,
+        });
+        // eslint-disable-next-line no-console
+        console.log(`Impact: ${impactResult.changedFiles.length} changed files → ${impactResult.impactedFeatures.length} features impacted`);
+        // eslint-disable-next-line no-console
+        console.log(`Unbound files: ${impactResult.unboundFiles.length}`);
+        for (const f of impactResult.impactedFeatures) {
+            const label = f.featureId || f.familyId;
+            // eslint-disable-next-line no-console
+            console.log(`  [${f.priority}] ${label}: ${f.coverageStatus} (PW=${f.playwrightSpecs.length}, Cy=${f.cypressSpecs.length})`);
+        }
+        if (impactResult.warnings.length > 0) {
+            for (const w of impactResult.warnings) {
                 // eslint-disable-next-line no-console
-                console.warn(`Impact re-run failed (${err instanceof Error ? err.message : String(err)}); using existing impact.json.`);
-            }
-            else {
-                throw err;
+                console.warn(`  Warning: ${w}`);
             }
         }
-        if (!existsSync(impactPath)) {
-            throw new Error(`Impact report not found at ${impactPath}`);
-        }
-        const impact = JSON.parse(readFileSync(impactPath, 'utf-8'));
-        const basePlan = buildPlanFromImpactReport(impact, config.policy);
-        const withActions = attachDeveloperActions(basePlan, {
-            appPath: config.path,
+        return;
+    }
+    if (args.command === 'suggest' || args.command === 'plan') {
+        const reportRoot = config.testsRoot || config.path;
+        const gitResult = getChangedFiles(config.path, config.git.since, { includeUncommitted: config.git.includeUncommitted });
+        const impactResult = analyzeImpactV2(gitResult.files, {
             testsRoot: reportRoot,
-            sinceRef: config.git.since,
-            configPath,
+            routeFamilies: config.routeFamilies,
         });
-        const plan = applyOperationalInsights(withActions, reportRoot);
+        const plan = buildPlanFromImpact(impactResult, config.policy);
         const planPath = writePlanReport(reportRoot, plan);
         const summaryMarkdown = renderCiSummaryMarkdown(plan);
         const summaryPath = writeCiSummary(reportRoot, summaryMarkdown, args.ciCommentPath);
@@ -1054,25 +930,16 @@ async function main() {
         console.log(`CI summary: ${summaryPath}`);
         // eslint-disable-next-line no-console
         console.log(`Plan metrics: ${metrics.summaryPath}`);
-        if (plan.nextActions) {
-            // eslint-disable-next-line no-console
-            console.log(`Next action (run existing): ${plan.nextActions.runRecommendedTests || plan.nextActions.runSmokeSuite}`);
-            // eslint-disable-next-line no-console
-            console.log(`Next action (approve + generate): ${plan.nextActions.approveAndGenerate || plan.nextActions.generateMissingTests}`);
-            // eslint-disable-next-line no-console
-            console.log(`Next action (heal): ${plan.nextActions.healGeneratedTests}`);
-        }
         const failOnLegacyFlag = args.failOnMustAddTests && plan.decision.action === 'must-add-tests';
         if (failOnLegacyFlag || plan.enforcement.shouldFail) {
             process.exit(2);
         }
         return;
     }
-    if (args.command === 'approve-and-generate' || args.command === 'generate') {
-        await runGap(config, { apply: args.apply });
-        return;
-    }
-    await runGap(config, { apply: args.apply });
+    // eslint-disable-next-line no-console
+    console.error(`Unknown command: ${args.command}`);
+    printUsage();
+    process.exit(1);
 }
 async function runLlmHealth() {
     if (!process.env.ANTHROPIC_API_KEY) {

package/dist/esm/engine/impact_engine.js

@@ -0,0 +1,191 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+import { existsSync, readdirSync } from 'fs';
+import { join } from 'path';
+import { loadRouteFamilyManifest, bindFilesToFamilies, getSpecDirsForBinding, getCypressSpecDirsForBinding, getPriorityForBinding, getUserFlowsForBinding, } from '../knowledge/route_families.js';
+function scanDirForSpecs(baseDir, specDir, extension) {
+    const fullDir = join(baseDir, specDir);
+    if (!existsSync(fullDir)) {
+        return [];
+    }
+    const specs = [];
+    try {
+        const items = readdirSync(fullDir, { withFileTypes: true });
+        for (const item of items) {
+            const itemPath = join(fullDir, item.name);
+            if (item.isDirectory()) {
+                specs.push(...scanDirForSpecsRecursive(itemPath, extension));
+            }
+            else if (item.name.endsWith(extension)) {
+                specs.push(join(specDir, item.name));
+            }
+        }
+    }
+    catch {
+        // Directory not readable
+    }
+    return specs;
+}
+function scanDirForSpecsRecursive(dir, extension) {
+    const specs = [];
+    try {
+        const items = readdirSync(dir, { withFileTypes: true });
+        for (const item of items) {
+            const fullPath = join(dir, item.name);
+            if (item.isDirectory()) {
+                specs.push(...scanDirForSpecsRecursive(fullPath, extension));
+            }
+            else if (item.name.endsWith(extension)) {
+                specs.push(fullPath);
+            }
+        }
+    }
+    catch {
+        // Directory not readable
+    }
+    return specs;
+}
+function resolvePlaywrightSpecs(testsRoot, specDirs) {
+    const specs = [];
+    for (const dir of specDirs) {
+        specs.push(...scanDirForSpecs(testsRoot, dir, '.spec.ts'));
+    }
+    return specs;
+}
+function resolveCypressSpecs(cypressRoot, specDirs) {
+    const specs = [];
+    for (const dir of specDirs) {
+        // cypressSpecDirs are relative to testsRoot (e.g. ../cypress/tests/integration/channels/search/)
+        // Resolve them relative to the cypress root
+        const resolvedDir = join(cypressRoot, dir.replace(/^\.\.\/cypress\//, ''));
+        if (!existsSync(resolvedDir)) {
+            continue;
+        }
+        const found = scanDirForSpecsRecursive(resolvedDir, '.js');
+        const tsFound = scanDirForSpecsRecursive(resolvedDir, '.ts');
+        specs.push(...found, ...tsFound);
+    }
+    return specs;
+}
+function computeCoverageStatus(pwSpecs, cySpecs) {
+    const hasPw = pwSpecs.length > 0;
+    const hasCy = cySpecs.length > 0;
+    if (hasPw && hasCy) {
+        return 'covered';
+    }
+    if (hasPw || hasCy) {
+        return 'partial';
+    }
+    return 'uncovered';
+}
+/**
+ * Group file bindings into a deduplicated map of family/feature → changed files.
+ */
+function groupBindings(fileBindings) {
+    const groups = new Map();
+    for (const fb of fileBindings) {
+        for (const binding of fb.bindings) {
+            const key = binding.feature || binding.family;
+            const existing = groups.get(key);
+            if (existing) {
+                if (!existing.files.includes(fb.file)) {
+                    existing.files.push(fb.file);
+                }
+            }
+            else {
+                groups.set(key, {
+                    familyId: binding.family,
+                    featureId: binding.feature,
+                    files: [fb.file],
+                });
+            }
+        }
+    }
+    return groups;
+}
+export function analyzeImpact(changedFiles, options) {
+    const { testsRoot, routeFamilies } = options;
+    const warnings = [];
+    // Load manifest
+    const manifest = loadRouteFamilyManifest(testsRoot, routeFamilies);
+    if (!manifest) {
+        return {
+            changedFiles,
+            expandedFiles: options.expandedFiles || [],
+            impactedFeatures: [],
+            unboundFiles: [...changedFiles],
+            warnings: ['Route family manifest not found. All files are unbound.'],
+        };
+    }
+    // Combine original + expanded files
+    const allFiles = [...new Set([...changedFiles, ...(options.expandedFiles || [])])];
+    // Bind files to families
+    const fileBindings = bindFilesToFamilies(allFiles, manifest);
+    // Find unbound files
+    const unboundFiles = fileBindings
+        .filter((fb) => fb.bindings.length === 0)
+        .map((fb) => fb.file);
+    // Group bindings into features
+    const groups = groupBindings(fileBindings.filter((fb) => fb.bindings.length > 0));
+    // Determine cypress root
+    const cypressRoot = options.cypressRoot || inferCypressRoot(testsRoot);
+    // Resolve specs and compute coverage for each feature
+    const impactedFeatures = [];
+    for (const group of groups.values()) {
+        const binding = { family: group.familyId, feature: group.featureId };
+        const specDirs = getSpecDirsForBinding(manifest, binding);
+        const cypressSpecDirs = getCypressSpecDirsForBinding(manifest, binding);
+        const priority = getPriorityForBinding(manifest, binding);
+        const userFlows = getUserFlowsForBinding(manifest, binding);
+        const playwrightSpecs = resolvePlaywrightSpecs(testsRoot, specDirs);
+        const cypressSpecs = cypressRoot ? resolveCypressSpecs(cypressRoot, cypressSpecDirs) : [];
+        const coverageStatus = computeCoverageStatus(playwrightSpecs, cypressSpecs);
+        impactedFeatures.push({
+            familyId: group.familyId,
+            featureId: group.featureId,
+            priority,
+            changedFiles: group.files,
+            playwrightSpecs,
+            cypressSpecs,
+            userFlows,
+            coverageStatus,
+        });
+    }
+    // Sort by priority (P0 first, then P1, then P2)
+    const priorityOrder = { P0: 0, P1: 1, P2: 2 };
+    impactedFeatures.sort((a, b) => priorityOrder[a.priority] - priorityOrder[b.priority]);
+    if (unboundFiles.length > 0 && unboundFiles.length <= 5) {
+        warnings.push(`${unboundFiles.length} file(s) not mapped to any route family: ${unboundFiles.join(', ')}`);
+    }
+    else if (unboundFiles.length > 5) {
+        warnings.push(`${unboundFiles.length} file(s) not mapped to any route family`);
+    }
+    return {
+        changedFiles,
+        expandedFiles: options.expandedFiles || [],
+        impactedFeatures,
+        unboundFiles,
+        warnings,
+    };
+}
+function inferCypressRoot(testsRoot) {
+    // testsRoot is typically the Playwright tests directory
+    // Cypress tests are at a sibling path: e2e-tests/cypress/tests/integration/channels/
+    const candidate = join(testsRoot, '..', 'cypress');
+    if (existsSync(candidate)) {
+        return candidate;
+    }
+    return undefined;
+}
+/**
+ * Get gaps: P0/P1 features with 'uncovered' status.
+ */
+export function getGaps(result) {
+    return result.impactedFeatures.filter((f) => (f.priority === 'P0' || f.priority === 'P1') && f.coverageStatus === 'uncovered');
+}
+/**
+ * Get partial gaps: P0/P1 features with 'partial' status (advisory).
+ */
+export function getPartialGaps(result) {
+    return result.impactedFeatures.filter((f) => (f.priority === 'P0' || f.priority === 'P1') && f.coverageStatus === 'partial');
+}