@yasserkhanorg/e2e-agents 1.8.4 → 1.9.5

package/dist/esm/cache/cached_provider.js

@@ -0,0 +1,82 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+import { ResponseCache, TTL } from './response_cache.js';
+/**
+ * Decorator that adds transparent response caching to any LLMProvider.
+ *
+ * - `generateText()` checks the cache first and returns a cached response on hit.
+ *   On a miss it delegates to the inner provider, stores the result, and returns it.
+ * - All other methods (analyzeImage, streamText, capabilities, usage stats)
+ *   delegate directly to the wrapped provider.
+ *
+ * The TTL is selected based on the agent role: agents whose name contains
+ * "generat" use the shorter GENERATION TTL; all others use ANALYSIS.
+ */
+export class CachedProvider {
+    constructor(inner, cache, cacheContext) {
+        this.inner = inner;
+        this.cache = cache;
+        this.ctx = cacheContext;
+        this.name = inner.name;
+        this.capabilities = inner.capabilities;
+        // Pick TTL based on agent role
+        this.ttlMs = cacheContext.agent.toLowerCase().includes('generat')
+            ? TTL.GENERATION
+            : TTL.ANALYSIS;
+        // Wire optional methods only when the inner provider supports them
+        if (inner.analyzeImage) {
+            this.analyzeImage = (images, prompt, options) => inner.analyzeImage(images, prompt, options);
+        }
+        if (inner.streamText) {
+            this.streamText = (prompt, options) => inner.streamText(prompt, options);
+        }
+    }
+    /**
+     * Generate text with cache-through semantics.
+     * On a cache hit the inner provider is never called, saving tokens and latency.
+     */
+    async generateText(prompt, options) {
+        const { agent, family, fileHashes } = this.ctx;
+        const model = this.inner.name;
+        // Check cache
+        const cached = this.cache.get(agent, family, fileHashes, model);
+        if (cached) {
+            return {
+                text: cached.response,
+                usage: {
+                    inputTokens: cached.usage.inputTokens,
+                    outputTokens: cached.usage.outputTokens,
+                    totalTokens: cached.usage.inputTokens + cached.usage.outputTokens,
+                    cachedTokens: cached.usage.inputTokens,
+                },
+                cost: 0, // No cost on cache hit
+            };
+        }
+        // Cache miss - call inner provider
+        const response = await this.inner.generateText(prompt, options);
+        // Store in cache
+        const key = ResponseCache.buildKey({ agent, family, fileHashes, model });
+        const entry = {
+            key,
+            family,
+            response: response.text,
+            usage: {
+                inputTokens: response.usage.inputTokens,
+                outputTokens: response.usage.outputTokens,
+                cost: response.cost,
+            },
+            createdAt: new Date().toISOString(),
+            ttlMs: this.ttlMs,
+        };
+        this.cache.set(entry);
+        return response;
+    }
+    getUsageStats() {
+        return this.inner.getUsageStats();
+    }
+    resetUsageStats() {
+        this.inner.resetUsageStats();
+    }
+}
+// Re-export for convenience
+export { ResponseCache, TTL } from './response_cache.js';

package/dist/esm/cache/response_cache.js

@@ -0,0 +1,140 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as crypto from 'node:crypto';
+/**
+ * TTL presets for different cache entry types.
+ */
+export const TTL = {
+    /** 24 hours - for analysis results that change infrequently */
+    ANALYSIS: 24 * 60 * 60 * 1000,
+    /** 1 hour - for generated content that may need fresher context */
+    GENERATION: 1 * 60 * 60 * 1000,
+};
+/**
+ * Cross-run LLM response cache backed by JSON files.
+ *
+ * Stores entries as `{cacheDir}/{sha256}.json` using a content-addressed key
+ * derived from (agentRole + familyName + sorted file hashes + model).
+ */
+export class ResponseCache {
+    constructor(workspaceRoot) {
+        this.cacheDir = path.join(workspaceRoot, '.e2e-ai-agents', 'cache');
+    }
+    /**
+     * Build a deterministic SHA-256 cache key from the provided parameters.
+     */
+    static buildKey(params) {
+        const sorted = [...params.fileHashes].sort();
+        const payload = params.agent + params.family + JSON.stringify(sorted) + params.model;
+        return crypto.createHash('sha256').update(payload).digest('hex');
+    }
+    /**
+     * Retrieve a cached response if it exists and has not expired.
+     * Returns `null` on cache miss or expiry.
+     */
+    get(agent, family, fileHashes, model) {
+        const key = ResponseCache.buildKey({ agent, family, fileHashes, model });
+        const filePath = path.join(this.cacheDir, `${key}.json`);
+        try {
+            if (!fs.existsSync(filePath)) {
+                return null;
+            }
+            const raw = fs.readFileSync(filePath, 'utf-8');
+            const entry = JSON.parse(raw);
+            const age = Date.now() - new Date(entry.createdAt).getTime();
+            if (age > entry.ttlMs) {
+                // Expired - clean up eagerly
+                fs.unlinkSync(filePath);
+                return null;
+            }
+            return entry;
+        }
+        catch {
+            // Corrupted or unreadable - treat as miss
+            return null;
+        }
+    }
+    /**
+     * Write a cache entry to disk.
+     * Creates the cache directory if it does not yet exist.
+     */
+    set(entry) {
+        this.ensureCacheDir();
+        const filePath = path.join(this.cacheDir, `${entry.key}.json`);
+        fs.writeFileSync(filePath, JSON.stringify(entry, null, 2), 'utf-8');
+    }
+    /**
+     * Remove all cache entries belonging to the given family.
+     *
+     * Because the cache key is a one-way SHA-256 hash, we scan each file and
+     * check its stored `family` field. The directory is scoped to a single
+     * workspace so the scan is bounded.
+     */
+    invalidateFamily(familyName) {
+        if (!fs.existsSync(this.cacheDir)) {
+            return 0;
+        }
+        let deleted = 0;
+        const files = fs.readdirSync(this.cacheDir).filter((f) => f.endsWith('.json'));
+        for (const file of files) {
+            const filePath = path.join(this.cacheDir, file);
+            try {
+                const raw = fs.readFileSync(filePath, 'utf-8');
+                const entry = JSON.parse(raw);
+                if (entry.family === familyName) {
+                    fs.unlinkSync(filePath);
+                    deleted++;
+                }
+            }
+            catch {
+                // Skip unreadable files
+            }
+        }
+        return deleted;
+    }
+    /**
+     * Remove all expired entries from the cache directory.
+     * Returns the number of entries deleted.
+     */
+    prune() {
+        if (!fs.existsSync(this.cacheDir)) {
+            return 0;
+        }
+        let deleted = 0;
+        const now = Date.now();
+        const files = fs.readdirSync(this.cacheDir).filter((f) => f.endsWith('.json'));
+        for (const file of files) {
+            const filePath = path.join(this.cacheDir, file);
+            try {
+                const raw = fs.readFileSync(filePath, 'utf-8');
+                const entry = JSON.parse(raw);
+                const age = now - new Date(entry.createdAt).getTime();
+                if (age > entry.ttlMs) {
+                    fs.unlinkSync(filePath);
+                    deleted++;
+                }
+            }
+            catch {
+                // Corrupted file - remove it
+                try {
+                    fs.unlinkSync(filePath);
+                    deleted++;
+                }
+                catch {
+                    // Ignore if removal also fails
+                }
+            }
+        }
+        return deleted;
+    }
+    /**
+     * Ensure the cache directory exists on disk.
+     */
+    ensureCacheDir() {
+        if (!fs.existsSync(this.cacheDir)) {
+            fs.mkdirSync(this.cacheDir, { recursive: true });
+        }
+    }
+}

package/dist/esm/cli/commands/bootstrap.js

@@ -0,0 +1,106 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+/**
+ * Bootstrap command — takes a project with an Understand-Anything knowledge graph
+ * and generates route-families.json + initial test stubs.
+ */
+import { existsSync, mkdirSync, writeFileSync } from 'fs';
+import { join, resolve } from 'path';
+import { logger, LogLevel } from '../../logger.js';
+import { loadKnowledgeGraph, classifyProjectType, transformKGToFamilies } from '../../knowledge/kg_bridge.js';
+import { serializeManifest } from '../../knowledge/route_families.js';
+import { detectFramework, detectTestMode } from '../../adapters/framework_adapter.js';
+import { resolveGenerationProfile } from '../../prompts/generation_profile.js';
+class BootstrapError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'BootstrapError';
+    }
+}
+export async function runBootstrapCommand(args) {
+    const projectRoot = resolve(args.path || '.');
+    if (args.verbose)
+        logger.setLevel(LogLevel.DEBUG);
+    if (args.jsonOutput)
+        logger.setJsonMode(true);
+    logger.info('e2e-ai-agents bootstrap');
+    logger.info('=======================');
+    // ---------- Step 1: Check for knowledge graph ----------
+    const kgPath = args.bootstrapKgPath
+        ? resolve(args.bootstrapKgPath)
+        : join(projectRoot, '.understand-anything', 'knowledge-graph.json');
+    if (!existsSync(kgPath)) {
+        throw new BootstrapError(`Knowledge graph not found at: ${kgPath}\n\n` +
+            'To bootstrap, first generate a knowledge graph for your project:\n' +
+            '  1. Install Understand-Anything: npm install -g understand-anything\n' +
+            '  2. Run: understand-anything analyze .\n' +
+            '  3. Then run: e2e-ai-agents bootstrap\n\n' +
+            'Or provide a path: e2e-ai-agents bootstrap --kg-path /path/to/knowledge-graph.json');
+    }
+    // ---------- Step 2: Load KG and classify ----------
+    logger.info('Loading knowledge graph...');
+    const kg = loadKnowledgeGraph(projectRoot, args.bootstrapKgPath ? kgPath : undefined);
+    if (!kg) {
+        throw new BootstrapError('Failed to load knowledge graph. Ensure it is valid JSON with nodes and edges arrays.');
+    }
+    const projectType = classifyProjectType(kg);
+    logger.info(`Project: ${kg.project.name || '(unnamed)'}`);
+    logger.info(`Type: ${projectType}`);
+    logger.info(`Frameworks: ${kg.project.frameworks.join(', ')}`);
+    logger.info(`Languages: ${kg.project.languages.join(', ')}`);
+    logger.info(`Nodes: ${kg.nodes.length}, Edges: ${kg.edges.length}`);
+    // ---------- Step 3: Transform KG to route families ----------
+    logger.info('');
+    logger.info('Generating route families from knowledge graph...');
+    const manifest = transformKGToFamilies(kg);
+    const maxFamilies = args.bootstrapMaxFamilies || 50;
+    if (manifest.families.length > maxFamilies) {
+        logger.info(`Limiting to top ${maxFamilies} families (of ${manifest.families.length} discovered). Use --max-families to adjust.`);
+        manifest.families = manifest.families.slice(0, maxFamilies);
+    }
+    const p0Count = manifest.families.filter((f) => f.priority === 'P0').length;
+    const p1Count = manifest.families.filter((f) => f.priority === 'P1').length;
+    const p2Count = manifest.families.filter((f) => f.priority === 'P2').length;
+    logger.info(`Discovered ${manifest.families.length} families: ${p0Count} P0, ${p1Count} P1, ${p2Count} P2`);
+    // ---------- Step 4: Detect/scaffold test framework ----------
+    const framework = detectFramework(projectRoot);
+    const testMode = args.bootstrapTestMode || detectTestMode(projectRoot, kg);
+    const profile = resolveGenerationProfile({ profile: args.profile, testMode }, kg);
+    logger.info(`Test framework: ${framework.name}`);
+    logger.info(`Test mode: ${testMode}`);
+    logger.info(`Generation profile: ${profile.projectName} (${profile.testFramework})`);
+    // ---------- Step 5: Write route-families.json ----------
+    const outputDir = join(projectRoot, '.e2e-ai-agents');
+    const outputPath = join(outputDir, 'route-families.json');
+    if (args.dryRun) {
+        logger.info('');
+        logger.info('Dry run — proposed manifest:');
+        console.log(serializeManifest(manifest));
+    }
+    else {
+        if (!existsSync(outputDir)) {
+            mkdirSync(outputDir, { recursive: true });
+        }
+        writeFileSync(outputPath, serializeManifest(manifest), 'utf-8');
+        logger.info(`Wrote ${outputPath}`);
+    }
+    // ---------- Step 6: Summary and next steps ----------
+    logger.info('');
+    logger.info('Bootstrap complete!');
+    logger.info('');
+    logger.info('Route families summary:');
+    for (const family of manifest.families.slice(0, 15)) {
+        const endpoints = family.apiEndpoints?.length || 0;
+        const endpointSuffix = endpoints > 0 ? ` (${endpoints} API endpoints)` : '';
+        logger.info(`  ${family.priority || 'P2'} ${family.id}: ${family.routes.join(', ')}${endpointSuffix}`);
+    }
+    if (manifest.families.length > 15) {
+        logger.info(`  ... and ${manifest.families.length - 15} more`);
+    }
+    logger.info('');
+    logger.info('Next steps:');
+    logger.info('  1. Review and refine .e2e-ai-agents/route-families.json');
+    logger.info('  2. Run `e2e-ai-agents train --enrich` to add LLM-enriched metadata');
+    logger.info('  3. Run `e2e-ai-agents plan` to see what tests are needed');
+    logger.info('  4. Run `e2e-ai-agents generate` to create test stubs');
+}

package/dist/esm/cli/commands/cost_report.js

@@ -0,0 +1,112 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+/**
+ * CLI command: cost-report — displays LLM cost breakdown from metrics.
+ */
+import { existsSync, readFileSync } from 'fs';
+import { join } from 'path';
+function parseMetricsFile(filePath) {
+    if (!existsSync(filePath)) {
+        return [];
+    }
+    const lines = readFileSync(filePath, 'utf-8').split('\n');
+    const events = [];
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        try {
+            const parsed = JSON.parse(trimmed);
+            if (parsed.type === 'crew-run') {
+                events.push(parsed);
+            }
+        }
+        catch {
+            continue;
+        }
+    }
+    return events;
+}
+function filterByDays(events, days) {
+    const cutoff = Date.now() - days * 24 * 60 * 60 * 1000;
+    return events.filter((e) => new Date(e.timestamp).getTime() >= cutoff);
+}
+export function runCostReportCommand(args) {
+    const reportRoot = args.path || args.testsRoot || process.cwd();
+    const metricsPath = join(reportRoot, '.e2e-ai-agents', 'metrics.jsonl');
+    const days = 30; // Default; could be added as a CLI flag later
+    const allEvents = parseMetricsFile(metricsPath);
+    const events = filterByDays(allEvents, days);
+    if (events.length === 0) {
+        console.log('No crew metrics found.');
+        if (!existsSync(metricsPath)) {
+            console.log(`Metrics file not found at: ${metricsPath}`);
+        }
+        else {
+            console.log('Run `e2e-ai-agents crew` to generate cost data.');
+        }
+        return;
+    }
+    // JSON output
+    if (args.jsonOutput) {
+        const report = buildReport(events, days);
+        console.log(JSON.stringify(report, null, 2));
+        return;
+    }
+    // Human-readable output
+    const totalCost = events.reduce((sum, e) => sum + e.totalCost, 0);
+    const totalRuns = events.length;
+    console.log(`E2E Agents Cost Report (last ${days} days)`);
+    console.log('='.repeat(45));
+    console.log(`\nTotal: $${totalCost.toFixed(2)} across ${totalRuns} runs\n`);
+    // By workflow
+    const byWorkflow = new Map();
+    for (const e of events) {
+        const entry = byWorkflow.get(e.workflow) || { runs: 0, cost: 0 };
+        entry.runs++;
+        entry.cost += e.totalCost;
+        byWorkflow.set(e.workflow, entry);
+    }
+    console.log('By workflow:');
+    for (const [workflow, data] of [...byWorkflow.entries()].sort((a, b) => b[1].cost - a[1].cost)) {
+        const avg = data.cost / data.runs;
+        console.log(`  ${workflow.padEnd(14)} | ${String(data.runs).padStart(3)} runs | $${data.cost.toFixed(2).padStart(6)} | avg $${avg.toFixed(2)}/run`);
+    }
+    // By agent (top 5)
+    const byAgent = new Map();
+    for (const e of events) {
+        for (const au of e.agentUsage) {
+            byAgent.set(au.agent, (byAgent.get(au.agent) || 0) + au.cost);
+        }
+    }
+    const sortedAgents = [...byAgent.entries()].sort((a, b) => b[1] - a[1]).slice(0, 5);
+    if (sortedAgents.length > 0) {
+        console.log('\nBy agent (top 5):');
+        for (const [agent, cost] of sortedAgents) {
+            const pct = totalCost > 0 ? ((cost / totalCost) * 100).toFixed(0) : '0';
+            console.log(`  ${agent.padEnd(20)} | $${cost.toFixed(2).padStart(6)} | ${pct.padStart(3)}%`);
+        }
+    }
+}
+function buildReport(events, days) {
+    const totalCost = events.reduce((sum, e) => sum + e.totalCost, 0);
+    const byWorkflow = {};
+    const byAgent = {};
+    for (const e of events) {
+        if (!byWorkflow[e.workflow]) {
+            byWorkflow[e.workflow] = { runs: 0, cost: 0 };
+        }
+        byWorkflow[e.workflow].runs++;
+        byWorkflow[e.workflow].cost += e.totalCost;
+        for (const au of e.agentUsage) {
+            byAgent[au.agent] = (byAgent[au.agent] || 0) + au.cost;
+        }
+    }
+    return {
+        days,
+        totalRuns: events.length,
+        totalCost,
+        byWorkflow,
+        byAgent,
+    };
+}

package/dist/esm/cli/commands/crew.js

@@ -3,8 +3,12 @@
 /**
  * CLI command: crew — runs multi-agent QA analysis workflows.
  */
+import { appendFileSync, mkdirSync } from 'fs';
+import { join } from 'path';
 import { resolveConfig } from '../../agent/config.js';
 import { CrewOrchestrator } from '../../crew/orchestrator.js';
+import { ResponseCache } from '../../cache/response_cache.js';
+import { WORKFLOWS } from '../../crew/workflows.js';
 import { ImpactAnalystAgent } from '../../agents/impact-analyst.js';
 import { GeneratorAgent } from '../../agents/generator.js';
 import { ExecutorAgent } from '../../agents/executor.js';
@@ -34,6 +38,23 @@ export async function runCrewCommand(args, autoConfig) {
         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 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,
@@ -43,7 +64,7 @@ export async function runCrewCommand(args, autoConfig) {
         workflow: workflowName,
         providerOverride: args.llmProvider,
         budgetUSD: args.budgetUSD,
-        dryRun: args.dryRun,
+        dryRun: degraded || args.dryRun,
     };
     // Create orchestrator and register all agents
     const orchestrator = new CrewOrchestrator();
@@ -65,6 +86,33 @@ export async function runCrewCommand(args, autoConfig) {
         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 = join(testsRoot, '.e2e-ai-agents');
+            mkdirSync(baseDir, { recursive: true });
+            const metricsPath = 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,
+            };
+            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 = {
@@ -132,3 +180,72 @@ export async function runCrewCommand(args, autoConfig) {
         }
     }
 }
+function printDryRunOutput(result, workflowName, jsonOutput) {
+    const ctx = result.context;
+    const workflow = 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 `e2e-ai-agents 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/esm/cli/commands/gate.js

@@ -0,0 +1,83 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+/**
+ * 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:
+ *   e2e-ai-agents gate --threshold 80 --path . --since origin/main
+ */
+import { resolveConfig } from '../../agent/config.js';
+import { getChangedFiles } from '../../agent/git.js';
+import { analyzeImpact } from '../../engine/impact_engine.js';
+export async function runGateCommand(args, autoConfig) {
+    if (!args.path && !autoConfig) {
+        console.error('Error: --path is required for gate command');
+        process.exit(1);
+    }
+    const threshold = args.gateThreshold ?? 80;
+    const { config } = 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 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 = 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);
+}