@yasserkhanorg/e2e-agents 1.8.5 → 1.10.0

package/dist/esm/knowledge/failure_history.js

@@ -0,0 +1,121 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+/**
+ * Tracks historical test failure correlations: which tests fail when certain files change.
+ * Used to boost confidence in impact analysis — if a file change historically breaks a test,
+ * future changes to that file should prioritize that test.
+ *
+ * Data is stored as a JSON file at .e2e-ai-agents/failure-history.json.
+ */
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
+import { join, dirname } from 'path';
+const DEFAULT_HISTORY = {
+    correlations: [],
+    totalRuns: 0,
+    updatedAt: new Date().toISOString(),
+};
+export function loadFailureHistory(testsRoot) {
+    const historyPath = join(testsRoot, '.e2e-ai-agents', 'failure-history.json');
+    if (!existsSync(historyPath)) {
+        return { ...DEFAULT_HISTORY };
+    }
+    try {
+        const raw = JSON.parse(readFileSync(historyPath, 'utf-8'));
+        if (!Array.isArray(raw.correlations)) {
+            return { ...DEFAULT_HISTORY };
+        }
+        return raw;
+    }
+    catch {
+        return { ...DEFAULT_HISTORY };
+    }
+}
+export function saveFailureHistory(testsRoot, history) {
+    const historyPath = join(testsRoot, '.e2e-ai-agents', 'failure-history.json');
+    try {
+        const dir = dirname(historyPath);
+        if (!existsSync(dir)) {
+            mkdirSync(dir, { recursive: true });
+        }
+        history.updatedAt = new Date().toISOString();
+        writeFileSync(historyPath, JSON.stringify(history, null, 2), 'utf-8');
+    }
+    catch {
+        // Non-fatal — history is advisory, not required
+    }
+}
+/**
+ * Record that a set of changed files caused a set of spec failures.
+ * Call this after a test run where failures were observed.
+ */
+export function recordFailures(history, changedFiles, failedSpecs) {
+    const now = new Date().toISOString();
+    const updated = { ...history, totalRuns: history.totalRuns + 1, correlations: [...history.correlations] };
+    for (const changedFile of changedFiles) {
+        for (const specFile of failedSpecs) {
+            const existing = updated.correlations.find((c) => c.changedFile === changedFile && c.specFile === specFile);
+            if (existing) {
+                existing.count++;
+                existing.lastSeen = now;
+            }
+            else {
+                updated.correlations.push({
+                    changedFile,
+                    specFile,
+                    count: 1,
+                    lastSeen: now,
+                });
+            }
+        }
+    }
+    // Prune stale correlations (not seen in 90 days)
+    const cutoff = new Date();
+    cutoff.setDate(cutoff.getDate() - 90);
+    const cutoffStr = cutoff.toISOString();
+    updated.correlations = updated.correlations.filter((c) => c.lastSeen >= cutoffStr);
+    return updated;
+}
+/**
+ * Get a confidence boost (0-20) for a file based on historical failure patterns.
+ * A file that historically causes test failures gets a higher confidence boost
+ * when detected as impacted, meaning the system is more confident it needs testing.
+ */
+export function getConfidenceBoost(history, changedFile) {
+    const correlations = history.correlations.filter((c) => c.changedFile === changedFile);
+    if (correlations.length === 0) {
+        return 0;
+    }
+    // More correlations and higher counts = more confidence
+    const totalCount = correlations.reduce((sum, c) => sum + c.count, 0);
+    const uniqueSpecs = correlations.length;
+    // Scale: 1 correlation = +5, 3+ = +10, 5+ with high counts = +15, max +20
+    if (totalCount >= 10 && uniqueSpecs >= 5)
+        return 20;
+    if (totalCount >= 5 && uniqueSpecs >= 3)
+        return 15;
+    if (totalCount >= 3)
+        return 10;
+    return 5;
+}
+/**
+ * Get the most likely failing specs for a set of changed files, based on history.
+ * Returns specs sorted by correlation strength (count * recency).
+ */
+export function getPredictedFailures(history, changedFiles, limit = 10) {
+    const specScores = new Map();
+    for (const changedFile of changedFiles) {
+        for (const c of history.correlations) {
+            if (c.changedFile !== changedFile)
+                continue;
+            // Score: count weighted by recency (days since last seen)
+            const daysSince = (Date.now() - new Date(c.lastSeen).getTime()) / (1000 * 60 * 60 * 24);
+            const recencyWeight = Math.max(0.1, 1 - daysSince / 90);
+            const score = c.count * recencyWeight;
+            specScores.set(c.specFile, (specScores.get(c.specFile) || 0) + score);
+        }
+    }
+    return Array.from(specScores.entries())
+        .map(([specFile, score]) => ({ specFile, score }))
+        .sort((a, b) => b.score - a.score)
+        .slice(0, limit);
+}

package/dist/esm/knowledge/kg_bridge.js

@@ -0,0 +1,381 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+/**
+ * Bridge between Understand-Anything's knowledge graph and e2e-agents' route families.
+ * Transforms KG nodes/edges into RouteFamilyManifest so existing pipeline works unchanged.
+ */
+import { existsSync, readFileSync } from 'fs';
+import { join } from 'path';
+import { logger } from '../logger.js';
+import { deriveClusterId, deriveClusterIdFromPath } from './cluster_utils.js';
+const UA_DIR = '.understand-anything';
+const KG_FILE = 'knowledge-graph.json';
+const DIFF_FILE = 'diff-overlay.json';
+const FRONTEND_FRAMEWORKS = new Set([
+    'react', 'vue', 'angular', 'svelte', 'next', 'nextjs', 'next.js',
+    'nuxt', 'nuxtjs', 'gatsby', 'remix', 'astro', 'solid', 'solidjs',
+    'preact', 'lit', 'stencil', 'qwik',
+]);
+const BACKEND_FRAMEWORKS = new Set([
+    'express', 'fastify', 'koa', 'hapi', 'nest', 'nestjs',
+    'django', 'flask', 'fastapi', 'rails', 'spring', 'gin', 'echo', 'fiber',
+    'actix', 'axum', 'rocket', 'phoenix', 'laravel',
+]);
+/**
+ * Loads the knowledge graph from .understand-anything/knowledge-graph.json
+ * or from a custom path when provided.
+ */
+export function loadKnowledgeGraph(projectRoot, customPath) {
+    const kgPath = customPath || join(projectRoot, UA_DIR, KG_FILE);
+    if (!existsSync(kgPath)) {
+        return null;
+    }
+    try {
+        const raw = JSON.parse(readFileSync(kgPath, 'utf-8'));
+        if (!raw.nodes || !Array.isArray(raw.nodes) || !raw.edges || !Array.isArray(raw.edges)) {
+            logger.warn('Knowledge graph missing required nodes/edges arrays');
+            return null;
+        }
+        if (!raw.project) {
+            logger.warn('Knowledge graph missing project metadata');
+            return null;
+        }
+        // Field-level validation: filter out invalid nodes rather than rejecting the whole graph
+        const MAX_STRING_LEN = 1000;
+        const validNodes = raw.nodes.filter((node) => {
+            if (typeof node.id !== 'string' || typeof node.name !== 'string') {
+                logger.warn(`Dropping KG node with missing/invalid id or name: ${JSON.stringify(node).slice(0, 200)}`);
+                return false;
+            }
+            if (node.filePath !== undefined) {
+                if (typeof node.filePath !== 'string') {
+                    logger.warn(`Dropping KG node "${node.id}": filePath is not a string`);
+                    return false;
+                }
+                if (node.filePath.startsWith('/')) {
+                    logger.warn(`Dropping KG node "${node.id}": absolute filePath rejected`);
+                    return false;
+                }
+                if (node.filePath.includes('..')) {
+                    logger.warn(`Dropping KG node "${node.id}": path traversal in filePath rejected`);
+                    return false;
+                }
+                if (node.filePath.includes('\0')) {
+                    logger.warn(`Dropping KG node "${node.id}": null byte in filePath rejected`);
+                    return false;
+                }
+            }
+            return true;
+        });
+        // Truncate excessively long strings
+        for (const node of validNodes) {
+            if (node.name.length > MAX_STRING_LEN) {
+                node.name = node.name.slice(0, MAX_STRING_LEN);
+            }
+            if (node.description && node.description.length > MAX_STRING_LEN) {
+                node.description = node.description.slice(0, MAX_STRING_LEN);
+            }
+        }
+        raw.nodes = validNodes;
+        return raw;
+    }
+    catch (error) {
+        logger.warn(`Failed to load knowledge graph: ${error instanceof Error ? error.message : String(error)}`);
+        return null;
+    }
+}
+/**
+ * Classifies project type based on KG framework metadata.
+ */
+export function classifyProjectType(kg) {
+    const frameworks = kg.project.frameworks.map((f) => f.toLowerCase());
+    const hasFrontend = frameworks.some((f) => FRONTEND_FRAMEWORKS.has(f));
+    const hasBackend = frameworks.some((f) => BACKEND_FRAMEWORKS.has(f));
+    if (hasFrontend && hasBackend)
+        return 'fullstack';
+    if (hasBackend)
+        return 'backend';
+    return 'frontend';
+}
+/**
+ * Core bridge: transforms KG into a RouteFamilyManifest.
+ *
+ * Strategy:
+ * - Frontend: cluster UI-layer nodes into families by module/component groups
+ * - Backend: cluster API-layer nodes, follow calls edges into Service→Data layers
+ * - Priority: P0 = high fan-in nodes, P1 = moderate, P2 = leaf/utility
+ * - userFlows: derived from KG tour steps referencing family nodes
+ */
+export function transformKGToFamilies(kg) {
+    const projectType = classifyProjectType(kg);
+    const nodeMap = new Map(kg.nodes.map((n) => [n.id, n]));
+    const edgesByTarget = groupEdges(kg.edges, 'target');
+    // Build clusters based on project type
+    const clusters = buildClusters(kg, projectType, nodeMap);
+    // Transform clusters into route families
+    const families = [];
+    for (const [clusterId, nodeIds] of clusters) {
+        const nodes = nodeIds.map((id) => nodeMap.get(id)).filter((n) => n !== undefined);
+        if (nodes.length === 0)
+            continue;
+        const family = buildFamilyFromCluster(clusterId, nodes, projectType, nodeMap, edgesByTarget);
+        if (family) {
+            families.push(family);
+        }
+    }
+    // Derive userFlows from KG tour steps
+    if (kg.tour && kg.tour.length > 0) {
+        assignTourFlows(families, kg.tour, nodeMap);
+    }
+    // Sort by priority (P0 first) then alphabetically
+    families.sort((a, b) => {
+        const pOrder = { P0: 0, P1: 1, P2: 2 };
+        const pa = pOrder[a.priority || 'P2'];
+        const pb = pOrder[b.priority || 'P2'];
+        if (pa !== pb)
+            return pa - pb;
+        return a.id.localeCompare(b.id);
+    });
+    return {
+        families,
+        source: 'knowledge-graph',
+    };
+}
+/**
+ * Loads the diff overlay from .understand-anything/diff-overlay.json
+ */
+export function loadDiffOverlay(projectRoot) {
+    const overlayPath = join(projectRoot, UA_DIR, DIFF_FILE);
+    if (!existsSync(overlayPath)) {
+        return null;
+    }
+    try {
+        const raw = JSON.parse(readFileSync(overlayPath, 'utf-8'));
+        if (!raw.changes || !Array.isArray(raw.changes)) {
+            return null;
+        }
+        return raw;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Maps diff overlay changes to file paths using KG node resolution.
+ */
+export function diffOverlayToChangedFiles(overlay, kg) {
+    const nodeMap = new Map(kg.nodes.map((n) => [n.id, n]));
+    const files = new Set();
+    for (const change of overlay.changes) {
+        // Use filePath from change if available
+        if (change.filePath) {
+            files.add(change.filePath);
+            continue;
+        }
+        // Fall back to KG node's filePath
+        const node = nodeMap.get(change.nodeId);
+        if (node?.filePath) {
+            files.add(node.filePath);
+        }
+    }
+    return [...files];
+}
+// ---------------------------------------------------------------------------
+// Internal helpers
+// ---------------------------------------------------------------------------
+function groupEdges(edges, key) {
+    const map = new Map();
+    for (const edge of edges) {
+        const val = edge[key];
+        if (!map.has(val))
+            map.set(val, []);
+        map.get(val).push(edge);
+    }
+    return map;
+}
+/**
+ * Build clusters of related nodes to become families.
+ * Frontend: group by route/page/component modules
+ * Backend: group by API endpoint handlers + their service dependencies
+ */
+function buildClusters(kg, projectType, nodeMap) {
+    const clusters = new Map();
+    // Strategy 1: Use KG layers to find anchor nodes
+    const layerMap = new Map();
+    if (kg.layers) {
+        for (const layer of kg.layers) {
+            layerMap.set(layer.name, new Set(layer.nodeIds));
+        }
+    }
+    // Strategy 2: Group by module/component/route nodes
+    const anchorKinds = projectType === 'backend'
+        ? new Set(['module', 'route', 'class', 'function'])
+        : new Set(['component', 'route', 'module', 'class']);
+    const anchorLayers = projectType === 'backend'
+        ? new Set(['api', 'service'])
+        : new Set(['ui']);
+    for (const node of kg.nodes) {
+        // Skip test/infra nodes as cluster anchors
+        if (node.layer === 'test' || node.layer === 'infra')
+            continue;
+        const isAnchorKind = anchorKinds.has(node.kind);
+        const isAnchorLayer = !node.layer || anchorLayers.has(node.layer);
+        if (!isAnchorKind || !isAnchorLayer)
+            continue;
+        // Derive cluster ID from node path or name
+        const clusterId = deriveClusterId(node);
+        if (!clusterId)
+            continue;
+        if (!clusters.has(clusterId)) {
+            clusters.set(clusterId, []);
+        }
+        clusters.get(clusterId).push(node.id);
+    }
+    // If no clusters found, fall back to file-based grouping
+    if (clusters.size === 0) {
+        for (const node of kg.nodes) {
+            if (!node.filePath || node.layer === 'test' || node.layer === 'infra')
+                continue;
+            const clusterId = deriveClusterIdFromPath(node.filePath);
+            if (!clusterId)
+                continue;
+            if (!clusters.has(clusterId)) {
+                clusters.set(clusterId, []);
+            }
+            clusters.get(clusterId).push(node.id);
+        }
+    }
+    return clusters;
+}
+// deriveClusterId and deriveClusterIdFromPath imported from cluster_utils.ts
+function computePriority(nodes) {
+    const maxFanIn = Math.max(...nodes.map((n) => n.fanIn || 0));
+    if (maxFanIn >= 10)
+        return 'P0';
+    if (maxFanIn >= 4)
+        return 'P1';
+    return 'P2';
+}
+function buildFamilyFromCluster(clusterId, nodes, projectType, nodeMap, edgesByTarget) {
+    const webappPaths = new Set();
+    const serverPaths = new Set();
+    const routes = [];
+    const apiEndpoints = [];
+    for (const node of nodes) {
+        if (!node.filePath)
+            continue;
+        const layer = node.layer;
+        if (layer === 'api' || layer === 'service' || layer === 'data') {
+            serverPaths.add(`${node.filePath}*`);
+        }
+        else if (layer === 'ui') {
+            webappPaths.add(`${node.filePath}*`);
+        }
+        else {
+            // Auto-assign based on project type
+            if (projectType === 'backend') {
+                serverPaths.add(`${node.filePath}*`);
+            }
+            else {
+                webappPaths.add(`${node.filePath}*`);
+            }
+        }
+        // Extract routes from route nodes
+        if (node.kind === 'route') {
+            const routePath = node.metadata?.path;
+            if (routePath) {
+                routes.push(routePath);
+                // Extract API endpoint info
+                const method = node.metadata?.method || 'GET';
+                apiEndpoints.push({ method: method.toUpperCase(), path: routePath, description: node.description });
+            }
+            else {
+                routes.push(`/${clusterId}`);
+            }
+        }
+    }
+    // If no routes extracted, generate a default
+    if (routes.length === 0) {
+        routes.push(`/${clusterId}`);
+    }
+    // Collect related test file paths by following 'tests' edges
+    const specDirs = new Set();
+    for (const node of nodes) {
+        const testEdges = (edgesByTarget.get(node.id) || []).filter((e) => e.type === 'tests');
+        for (const edge of testEdges) {
+            const testNode = nodeMap.get(edge.source);
+            if (testNode?.filePath) {
+                // Use directory of test file
+                const dir = testNode.filePath.replace(/\\/g, '/').split('/').slice(0, -1).join('/');
+                if (dir)
+                    specDirs.add(`${dir}/*`);
+            }
+        }
+    }
+    const priority = computePriority(nodes);
+    // Determine test type based on content
+    let testType;
+    if (webappPaths.size > 0 && serverPaths.size > 0) {
+        testType = 'both';
+    }
+    else if (serverPaths.size > 0 && apiEndpoints.length > 0) {
+        testType = 'api';
+    }
+    else if (webappPaths.size > 0) {
+        testType = 'ui';
+    }
+    const family = {
+        id: clusterId,
+        routes: [...new Set(routes)],
+        priority,
+    };
+    if (webappPaths.size > 0)
+        family.webappPaths = [...webappPaths];
+    if (serverPaths.size > 0)
+        family.serverPaths = [...serverPaths];
+    if (specDirs.size > 0)
+        family.specDirs = [...specDirs];
+    if (apiEndpoints.length > 0)
+        family.apiEndpoints = apiEndpoints;
+    if (testType)
+        family.testType = testType;
+    return family;
+}
+function assignTourFlows(families, tour, nodeMap) {
+    if (!tour)
+        return;
+    // Build a map of nodeId → family for quick lookup
+    const nodeToFamily = new Map();
+    for (const family of families) {
+        // Resolve family nodes from paths
+        for (const [nodeId, node] of nodeMap) {
+            if (!node.filePath)
+                continue;
+            const matchesPaths = [
+                ...(family.webappPaths || []),
+                ...(family.serverPaths || []),
+            ];
+            for (const pattern of matchesPaths) {
+                const prefix = pattern.replace(/\*$/, '');
+                if (node.filePath.startsWith(prefix)) {
+                    nodeToFamily.set(nodeId, family);
+                    break;
+                }
+            }
+        }
+    }
+    // Assign tour steps as user flows
+    for (const step of tour.sort((a, b) => a.order - b.order)) {
+        for (const nodeId of step.nodeIds) {
+            const family = nodeToFamily.get(nodeId);
+            if (family) {
+                if (!family.userFlows)
+                    family.userFlows = [];
+                const flowDesc = `${step.title}: ${step.description}`;
+                if (!family.userFlows.includes(flowDesc)) {
+                    family.userFlows.push(flowDesc);
+                }
+            }
+        }
+    }
+}

package/dist/esm/knowledge/kg_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/knowledge/route_families.js

@@ -30,6 +30,17 @@ export function matchesGlob(filePath, pattern) {
 export function matchesAnyPattern(filePath, patterns) {
     return patterns.some((pattern) => matchesGlob(filePath, pattern));
 }
+function validateApiEndpoint(ep) {
+    if (!ep || typeof ep !== 'object')
+        return null;
+    const obj = ep;
+    if (typeof obj.method !== 'string' || typeof obj.path !== 'string')
+        return null;
+    const result = { method: obj.method, path: obj.path };
+    if (typeof obj.description === 'string')
+        result.description = obj.description;
+    return result;
+}
 function validateFamily(family) {
     if (!family || typeof family !== 'object') {
         return null;
@@ -38,6 +49,10 @@ function validateFamily(family) {
     if (typeof obj.id !== 'string' || !obj.id.trim()) {
         return null;
     }
+    // When testType is 'api', routes may contain API paths like "GET /api/users"
+    const testType = (obj.testType === 'ui' || obj.testType === 'api' || obj.testType === 'both')
+        ? obj.testType
+        : undefined;
     if (!Array.isArray(obj.routes) || obj.routes.length === 0) {
         return null;
     }
@@ -81,8 +96,32 @@ function validateFamily(family) {
             .map((f) => validateFeature(f))
             .filter((f) => f !== null);
     }
+    if (Array.isArray(obj.apiEndpoints)) {
+        const endpoints = obj.apiEndpoints
+            .map((ep) => validateApiEndpoint(ep))
+            .filter((ep) => ep !== null);
+        if (endpoints.length > 0)
+            result.apiEndpoints = endpoints;
+    }
+    if (testType) {
+        result.testType = testType;
+    }
+    if (Array.isArray(obj.assertionPatterns)) {
+        result.assertionPatterns = validateAssertionPatterns(obj.assertionPatterns);
+    }
     return result;
 }
+const VALID_ASSERTION_TYPES = [
+    'state-change', 'cross-user', 'persistence', 'negative',
+    'permission', 'data-integrity', 'error-handling',
+];
+function validateAssertionPatterns(patterns) {
+    return patterns
+        .filter((p) => p != null && typeof p === 'object')
+        .filter((p) => typeof p.type === 'string' && typeof p.pattern === 'string')
+        .filter((p) => VALID_ASSERTION_TYPES.includes(p.type))
+        .map((p) => ({ type: p.type, pattern: p.pattern }));
+}
 function validateFeature(feature) {
     if (!feature || typeof feature !== 'object') {
         return null;
@@ -116,6 +155,9 @@ function validateFeature(feature) {
     if (Array.isArray(obj.userFlows)) {
         result.userFlows = obj.userFlows.filter((v) => typeof v === 'string');
     }
+    if (Array.isArray(obj.assertionPatterns)) {
+        result.assertionPatterns = validateAssertionPatterns(obj.assertionPatterns);
+    }
     return result;
 }
 export function loadRouteFamilyManifest(testsRoot, config) {
@@ -269,6 +311,83 @@ export function getRoutesForBinding(manifest, binding) {
     }
     return family.routes;
 }
+export function getAssertionPatternsForBinding(manifest, binding) {
+    const family = getFamilyById(manifest, binding.family);
+    if (!family) {
+        return [];
+    }
+    if (binding.feature) {
+        const feature = getFeatureById(family, binding.feature);
+        if (feature?.assertionPatterns && feature.assertionPatterns.length > 0) {
+            return feature.assertionPatterns;
+        }
+    }
+    return family.assertionPatterns || [];
+}
 export function clearManifestCache() {
     manifestCache.clear();
 }
+/**
+ * Build heuristic route families from changed files when no manifest exists.
+ * Groups files by their top-level directory to create rough family groupings.
+ * Results are lower confidence but allow analysis to proceed without training.
+ */
+export function buildHeuristicFamilies(changedFiles, testsRoot) {
+    const dirGroups = new Map();
+    for (const file of changedFiles) {
+        const normalized = file.replace(/\\/g, '/');
+        const parts = normalized.split('/');
+        // Use the first meaningful directory segment as the family ID
+        // Skip common prefixes like 'src/', 'app/', 'lib/'
+        const skipDirs = new Set(['src', 'app', 'lib', 'packages', 'components']);
+        let familyDir = parts[0] || 'root';
+        if (skipDirs.has(familyDir) && parts.length > 1) {
+            familyDir = parts[1];
+        }
+        // Normalize to a clean family name
+        familyDir = familyDir.replace(/\.[^.]+$/, ''); // strip file extensions for single files
+        if (!dirGroups.has(familyDir)) {
+            dirGroups.set(familyDir, []);
+        }
+        dirGroups.get(familyDir).push(normalized);
+    }
+    const families = [];
+    for (const [dir, files] of dirGroups) {
+        families.push({
+            id: dir,
+            routes: [`/${dir}`],
+            webappPaths: files.map((f) => `${f}*`),
+        });
+    }
+    logger.info(`Built ${families.length} heuristic families from ${changedFiles.length} changed files (no route-families.json found)`);
+    logger.info('Tip: Run `e2e-ai-agents train` to generate a proper route-families manifest for better accuracy.');
+    return {
+        families,
+        source: 'heuristic',
+    };
+}
+/**
+ * Serialize a RouteFamilyManifest to clean JSON, stripping empty optional fields.
+ */
+export function serializeManifest(manifest) {
+    const output = {
+        families: manifest.families.map((f) => {
+            const cleaned = { ...f };
+            const optionalArrays = [
+                'pageObjects', 'components', 'webappPaths', 'serverPaths',
+                'specDirs', 'cypressSpecDirs', 'tags', 'userFlows', 'features', 'apiEndpoints', 'assertionPatterns',
+            ];
+            for (const key of optionalArrays) {
+                if (!cleaned[key] || (Array.isArray(cleaned[key]) && cleaned[key].length === 0)) {
+                    delete cleaned[key];
+                }
+            }
+            if (!cleaned.priority)
+                delete cleaned.priority;
+            if (!cleaned.testType)
+                delete cleaned.testType;
+            return cleaned;
+        }),
+    };
+    return JSON.stringify(output, null, 2) + '\n';
+}

package/dist/esm/mcp-server.js

@@ -370,8 +370,7 @@ export class E2EAgentsMCPServer {
             if (!validateGitRef(since)) {
                 return JSON.stringify({ error: 'Invalid git reference format' });
             }
-            // SECURITY: Use -- to separate git options from refs
-            const result = spawnSync('git', ['diff', '--name-only', '--', `${since}..HEAD`], {
+            const result = spawnSync('git', ['diff', '--name-only', `${since}..HEAD`], {
                 cwd: this.repoRoot,
                 encoding: 'utf-8',
                 timeout: 30000,
@@ -439,8 +438,7 @@ export class E2EAgentsMCPServer {
             if (!validateGitRef(since)) {
                 return [];
             }
-            // SECURITY: Use -- separator
-            const result = spawnSync('git', ['diff', '--name-only', '--', `${since}..HEAD`], {
+            const result = spawnSync('git', ['diff', '--name-only', `${since}..HEAD`], {
                 cwd: this.repoRoot,
                 encoding: 'utf-8',
                 timeout: 30000,