@yasserkhanorg/e2e-agents 1.8.5 → 1.10.0

package/dist/esm/custom_provider.js

@@ -65,6 +65,7 @@ export class CustomProvider extends BaseProvider {
         };
     }
     async generateText(prompt, options) {
+        this.checkBudget();
         const startTime = Date.now();
         try {
             if (prompt.length > 10 * 1024 * 1024) {

package/dist/esm/engine/diff_loader.js

@@ -1,20 +1,9 @@
 // Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
 // See LICENSE.txt for license information.
-import { spawnSync } from 'child_process';
+import { runGitRaw } from '../agent/git.js';
 const MAX_DIFF_CHARS = 8000;
 const MAX_TOTAL_CHARS = 60000;
 const TRUNCATION_NOTICE = '\n... (diff truncated)';
-function runGitRaw(args, cwd) {
-    const result = spawnSync('git', args, {
-        cwd,
-        encoding: 'utf-8',
-        timeout: 30000,
-    });
-    if (result.error || result.status !== 0) {
-        return null;
-    }
-    return result.stdout;
-}
 /**
  * Loads git diffs for the given changed files relative to the given since ref.
  * Uses `git merge-base` to find the accurate base ref first.

package/dist/esm/engine/impact_engine.js

@@ -2,7 +2,8 @@
 // See LICENSE.txt for license information.
 import { existsSync, readdirSync, readFileSync } from 'fs';
 import { join } from 'path';
-import { loadRouteFamilyManifest, bindFilesToFamilies, getSpecDirsForBinding, getCypressSpecDirsForBinding, getPriorityForBinding, getUserFlowsForBinding, } from '../knowledge/route_families.js';
+import { loadRouteFamilyManifest, buildHeuristicFamilies, bindFilesToFamilies, getSpecDirsForBinding, getCypressSpecDirsForBinding, getPriorityForBinding, getUserFlowsForBinding, } from '../knowledge/route_families.js';
+import { isTestFile } from '../agent/git.js';
 function scanDirForSpecs(baseDir, specDir, extension) {
     const fullDir = join(baseDir, specDir);
     if (!existsSync(fullDir)) {
@@ -125,7 +126,8 @@ function groupBindings(fileBindings) {
             const key = binding.feature || binding.family;
             const existing = groups.get(key);
             if (existing) {
-                if (!existing.files.includes(fb.file)) {
+                if (!existing._seen.has(fb.file)) {
+                    existing._seen.add(fb.file);
                     existing.files.push(fb.file);
                 }
             }
@@ -134,23 +136,13 @@ function groupBindings(fileBindings) {
                     familyId: binding.family,
                     featureId: binding.feature,
                     files: [fb.file],
+                    _seen: new Set([fb.file]),
                 });
             }
         }
     }
     return groups;
 }
-/** Filter out test files that should not be treated as application changes. */
-function isTestFile(file) {
-    const normalized = file.replace(/\\/g, '/');
-    return /\.(spec|test)\.(ts|tsx|js|jsx)$/.test(normalized) ||
-        /\.snap$/.test(normalized) ||
-        /_test\.go$/.test(normalized) ||
-        normalized.includes('__tests__/') ||
-        normalized.includes('__snapshots__/') ||
-        normalized.includes('/tests/') ||
-        normalized.includes('/test/');
-}
 /** Classify filtered test files by type for downstream decision-making. */
 function classifyPrTestFiles(allFiles, sourceFiles) {
     const sourceSet = new Set(sourceFiles);
@@ -180,17 +172,11 @@ export function analyzeImpact(changedFiles, options) {
     const allOriginalFiles = [...new Set([...changedFiles, ...preFilteredTests])];
     changedFiles = changedFiles.filter((f) => !isTestFile(f));
     const prIncludedTestFiles = classifyPrTestFiles(allOriginalFiles, changedFiles);
-    // Load manifest
-    const manifest = loadRouteFamilyManifest(testsRoot, routeFamilies);
+    // Load manifest, fall back to heuristic families if not found
+    let manifest = loadRouteFamilyManifest(testsRoot, routeFamilies);
     if (!manifest) {
-        return {
-            changedFiles,
-            expandedFiles: options.expandedFiles || [],
-            impactedFeatures: [],
-            unboundFiles: [...changedFiles],
-            warnings: ['Route family manifest not found. All files are unbound.'],
-            prIncludedTestFiles,
-        };
+        manifest = buildHeuristicFamilies(changedFiles, testsRoot);
+        warnings.push('Route family manifest not found. Using directory-based heuristics (lower accuracy).', 'Tip: Run `e2e-ai-agents train` to generate a proper manifest.');
     }
     // Combine original + expanded files
     const allFiles = [...new Set([...changedFiles, ...(options.expandedFiles || [])])];

package/dist/esm/index.js

@@ -44,8 +44,29 @@ export { StrategistAgent } from './agents/strategist.js';
 export { TestDesignerAgent } from './agents/test-designer.js';
 export { CrossImpactAgent } from './agents/cross-impact.js';
 export { RegressionAdvisorAgent } from './agents/regression-advisor.js';
+// Base provider (for extending with custom providers)
+export { BaseProvider, BudgetExceededError } from './base_provider.js';
+// Budget tracking
+export { BudgetLedger } from './budget_ledger.js';
+// Model routing
+export { ModelRouter } from './model_router.js';
+// Resilience
+export { withRetry } from './resilience/retry.js';
+export { CircuitBreaker } from './resilience/circuit_breaker.js';
+// Metrics
+export { PrometheusMetrics } from './metrics/prometheus.js';
+// Secret scanning
+export { sanitizeSecrets, containsSecrets, sanitizeObject } from './sanitize.js';
+// CLI errors
+export { CliError, classifyError, EXIT_CODES } from './cli/errors.js';
 // Training (route-families bootstrap and maintenance)
 export { scanProject } from './training/scanner.js';
 export { mergeFamilies, detectStaleFamilies } from './training/merger.js';
 export { enrichFamilies } from './training/enricher.js';
 export { getCommitFiles, validateCommit, buildValidationReport, formatValidationReport } from './training/validator.js';
+export { loadKnowledgeGraph, classifyProjectType, transformKGToFamilies, loadDiffOverlay } from './knowledge/kg_bridge.js';
+export { scanFromKnowledgeGraph } from './training/kg_scanner.js';
+export { resolveGenerationProfile, isMattermostProfile } from './prompts/generation_profile.js';
+export { detectFramework, detectTestMode } from './adapters/framework_adapter.js';
+// Route families (additional)
+export { serializeManifest } from './knowledge/route_families.js';

package/dist/esm/knowledge/api_surface.js

@@ -2,39 +2,233 @@
 // See LICENSE.txt for license information.
 import { existsSync, readFileSync, readdirSync, writeFileSync } from 'fs';
 import { join, extname } from 'path';
+import ts from 'typescript';
+// ── TypeScript AST-based extraction ────────────────────────
+function extractMethodsFromAST(sourceFile, checker) {
+    const surfaces = [];
+    ts.forEachChild(sourceFile, (node) => {
+        if (!ts.isClassDeclaration(node) || !node.name) {
+            return;
+        }
+        const className = node.name.text;
+        const methods = [];
+        const seen = new Set();
+        // Get base class name if extends
+        let extendsName;
+        if (node.heritageClauses) {
+            for (const clause of node.heritageClauses) {
+                if (clause.token === ts.SyntaxKind.ExtendsKeyword && clause.types.length > 0) {
+                    const expr = clause.types[0].expression;
+                    if (ts.isIdentifier(expr)) {
+                        extendsName = expr.text;
+                    }
+                }
+            }
+        }
+        for (const member of node.members) {
+            // Skip constructor
+            if (ts.isConstructorDeclaration(member)) {
+                continue;
+            }
+            // Skip private/protected members
+            const modifiers = ts.canHaveModifiers(member) ? ts.getModifiers(member) : undefined;
+            if (modifiers?.some((m) => m.kind === ts.SyntaxKind.PrivateKeyword || m.kind === ts.SyntaxKind.ProtectedKeyword)) {
+                continue;
+            }
+            const name = member.name && ts.isIdentifier(member.name) ? member.name.text : null;
+            if (!name || name.startsWith('_') || seen.has(name)) {
+                continue;
+            }
+            seen.add(name);
+            if (ts.isMethodDeclaration(member)) {
+                const isAsync = modifiers?.some((m) => m.kind === ts.SyntaxKind.AsyncKeyword) ?? false;
+                const params = extractParams(member.parameters, checker);
+                const returnType = extractReturnType(member, checker);
+                methods.push({
+                    name,
+                    kind: 'method',
+                    async: isAsync ? true : undefined,
+                    params: params.length > 0 ? params : undefined,
+                    returnType: returnType || undefined,
+                });
+            }
+            else if (ts.isGetAccessorDeclaration(member)) {
+                methods.push({ name, kind: 'getter' });
+            }
+            else if (ts.isPropertyDeclaration(member)) {
+                // Check if it's an arrow function property (e.g., name = async () => {})
+                if (member.initializer && (ts.isArrowFunction(member.initializer) || ts.isFunctionExpression(member.initializer))) {
+                    const fn = member.initializer;
+                    const fnModifiers = ts.canHaveModifiers(fn) ? ts.getModifiers(fn) : undefined;
+                    const isAsync = fnModifiers?.some((m) => m.kind === ts.SyntaxKind.AsyncKeyword) ?? false;
+                    const params = extractParams(fn.parameters, checker);
+                    methods.push({
+                        name,
+                        kind: 'method',
+                        async: isAsync ? true : undefined,
+                        params: params.length > 0 ? params : undefined,
+                    });
+                }
+                else {
+                    methods.push({ name, kind: 'property' });
+                }
+            }
+        }
+        if (methods.length > 0) {
+            surfaces.push({
+                className,
+                file: sourceFile.fileName,
+                methods,
+                extends: extendsName,
+            });
+        }
+    });
+    return surfaces;
+}
+function extractParams(params, checker) {
+    return params.map((p) => {
+        const name = ts.isIdentifier(p.name) ? p.name.text : p.name.getText();
+        const optional = p.questionToken !== undefined || p.initializer !== undefined;
+        let type;
+        if (p.type) {
+            type = p.type.getText();
+        }
+        else if (checker) {
+            try {
+                const symbol = checker.getSymbolAtLocation(p.name);
+                if (symbol) {
+                    const t = checker.getTypeOfSymbolAtLocation(symbol, p);
+                    type = checker.typeToString(t);
+                }
+            }
+            catch {
+                // Type inference failure is non-fatal
+            }
+        }
+        return { name, type, optional: optional || undefined };
+    });
+}
+function extractReturnType(method, checker) {
+    if (method.type) {
+        return method.type.getText();
+    }
+    if (checker) {
+        try {
+            const signature = checker.getSignatureFromDeclaration(method);
+            if (signature) {
+                const returnType = checker.getReturnTypeOfSignature(signature);
+                const typeStr = checker.typeToString(returnType);
+                // Skip overly verbose inferred types
+                if (typeStr.length < 100) {
+                    return typeStr;
+                }
+            }
+        }
+        catch {
+            // Type inference failure is non-fatal
+        }
+    }
+    return null;
+}
+/**
+ * Extract page objects using the TypeScript Compiler API.
+ * Falls back to regex if compilation fails.
+ */
+function extractWithAST(files) {
+    if (files.length === 0) {
+        return [];
+    }
+    // Find the nearest tsconfig.json
+    const firstDir = join(files[0], '..');
+    const tsconfigPath = ts.findConfigFile(firstDir, ts.sys.fileExists, 'tsconfig.json');
+    let program;
+    if (tsconfigPath) {
+        const configFile = ts.readConfigFile(tsconfigPath, ts.sys.readFile);
+        const parsedConfig = ts.parseJsonConfigFileContent(configFile.config, ts.sys, join(tsconfigPath, '..'));
+        // Only compile the files we care about, using the config's compiler options
+        program = ts.createProgram(files, parsedConfig.options);
+    }
+    else {
+        program = ts.createProgram(files, {
+            target: ts.ScriptTarget.ES2022,
+            module: ts.ModuleKind.ESNext,
+            moduleResolution: ts.ModuleResolutionKind.Bundler,
+            strict: true,
+            allowJs: false,
+            noEmit: true,
+        });
+    }
+    const checker = program.getTypeChecker();
+    const surfaces = [];
+    for (const filePath of files) {
+        const sourceFile = program.getSourceFile(filePath);
+        if (!sourceFile) {
+            continue;
+        }
+        surfaces.push(...extractMethodsFromAST(sourceFile, checker));
+    }
+    // Resolve inherited methods: if class extends another class in the catalog,
+    // merge parent methods that the child doesn't override
+    resolveInheritance(surfaces);
+    return surfaces;
+}
+/**
+ * Merge parent class methods into child classes that extend them.
+ */
+function resolveInheritance(surfaces) {
+    const byName = new Map(surfaces.map((s) => [s.className, s]));
+    for (const surface of surfaces) {
+        if (!surface.extends) {
+            continue;
+        }
+        const parent = byName.get(surface.extends);
+        if (!parent) {
+            continue;
+        }
+        const childMethodNames = new Set(surface.methods.map((m) => m.name));
+        for (const parentMethod of parent.methods) {
+            if (!childMethodNames.has(parentMethod.name)) {
+                surface.methods.push({ ...parentMethod });
+            }
+        }
+    }
+}
+// ── Regex-based extraction (fallback) ──────────────────────
 const RESERVED_WORDS = new Set([
     'private', 'protected', 'static', 'abstract', 'override',
     'if', 'for', 'while', 'switch', 'return',
     'const', 'let', 'var', 'import', 'export',
     'class', 'type', 'interface', 'constructor',
 ]);
-function extractMethodsFromSource(content) {
+function extractMethodsFromRegex(content) {
     const methods = [];
     const seen = new Set();
-    // Match async method declarations: async methodName(
     const asyncMethodRe = /(?:async\s+)([a-zA-Z_]\w*)\s*\(/g;
     let match;
     while ((match = asyncMethodRe.exec(content)) !== null) {
         const name = match[1];
-        if (RESERVED_WORDS.has(name)) {
-            continue;
-        }
-        if (!seen.has(name)) {
+        if (!RESERVED_WORDS.has(name) && !seen.has(name)) {
             seen.add(name);
-            methods.push({ name, kind: 'method' });
+            methods.push({ name, kind: 'method', async: true });
         }
     }
-    // Match non-async public method patterns
     const methodRe = /^\s+(?:readonly\s+)?([a-zA-Z_]\w*)\s*(?:\(|=\s*(?:async\s*)?\()/gm;
     while ((match = methodRe.exec(content)) !== null) {
         const name = match[1];
-        if (RESERVED_WORDS.has(name) || seen.has(name)) {
-            continue;
+        if (!RESERVED_WORDS.has(name) && !seen.has(name)) {
+            seen.add(name);
+            const isAsync = match[0].includes('async');
+            methods.push({ name, kind: 'method', async: isAsync ? true : undefined });
+        }
+    }
+    const arrowRe = /^\s+([a-zA-Z_]\w*)\s*=\s*(async\s+)?(?:\([^)]*\)|[a-zA-Z_]\w*)\s*=>/gm;
+    while ((match = arrowRe.exec(content)) !== null) {
+        const name = match[1];
+        if (!RESERVED_WORDS.has(name) && !seen.has(name)) {
+            seen.add(name);
+            methods.push({ name, kind: 'method', async: match[2] ? true : undefined });
         }
-        seen.add(name);
-        methods.push({ name, kind: 'method' });
     }
-    // Match getter patterns: get propertyName()
     const getterRe = /\bget\s+([a-zA-Z_]\w*)\s*\(\)/g;
     while ((match = getterRe.exec(content)) !== null) {
         const name = match[1];
@@ -43,15 +237,13 @@ function extractMethodsFromSource(content) {
             methods.push({ name, kind: 'getter' });
         }
     }
-    // Match readonly property declarations
     const propRe = /^\s+(?:readonly\s+)?([a-zA-Z_]\w*)\s*[:=]/gm;
     while ((match = propRe.exec(content)) !== null) {
         const name = match[1];
-        if (RESERVED_WORDS.has(name) || seen.has(name)) {
-            continue;
+        if (!RESERVED_WORDS.has(name) && !seen.has(name)) {
+            seen.add(name);
+            methods.push({ name, kind: 'property' });
         }
-        seen.add(name);
-        methods.push({ name, kind: 'property' });
     }
     return methods;
 }
@@ -59,7 +251,27 @@ function extractClassName(content) {
     const match = content.match(/(?:export\s+)?class\s+(\w+)/);
     return match ? match[1] : null;
 }
-function scanDirectory(dir) {
+// ── Directory scanning ─────────────────────────────────────
+function collectTypeScriptFiles(dir) {
+    const files = [];
+    if (!existsSync(dir)) {
+        return files;
+    }
+    const entries = readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+        const fullPath = join(dir, entry.name);
+        if (entry.isDirectory()) {
+            files.push(...collectTypeScriptFiles(fullPath));
+            continue;
+        }
+        const ext = extname(entry.name);
+        if (ext === '.ts' || ext === '.tsx') {
+            files.push(fullPath);
+        }
+    }
+    return files;
+}
+function scanDirectoryWithRegex(dir) {
     const surfaces = [];
     if (!existsSync(dir)) {
         return surfaces;
@@ -68,29 +280,22 @@ function scanDirectory(dir) {
     for (const entry of entries) {
         const fullPath = join(dir, entry.name);
         if (entry.isDirectory()) {
-            surfaces.push(...scanDirectory(fullPath));
+            surfaces.push(...scanDirectoryWithRegex(fullPath));
             continue;
         }
         const ext = extname(entry.name);
         if (ext !== '.ts' && ext !== '.tsx') {
             continue;
         }
-        if (entry.name === 'index.ts' || entry.name === 'index.tsx') {
-            continue;
-        }
         try {
             const content = readFileSync(fullPath, 'utf-8');
             const className = extractClassName(content);
             if (!className) {
                 continue;
             }
-            const extractedMethods = extractMethodsFromSource(content);
+            const extractedMethods = extractMethodsFromRegex(content);
             if (extractedMethods.length > 0) {
-                surfaces.push({
-                    className,
-                    file: fullPath,
-                    methods: extractedMethods,
-                });
+                surfaces.push({ className, file: fullPath, methods: extractedMethods });
             }
         }
         catch {
@@ -99,6 +304,7 @@ function scanDirectory(dir) {
     }
     return surfaces;
 }
+// ── Public API ──────────────────────────────────────────────
 export function buildApiSurface(testsRoot, config) {
     const pageObjectsDir = config?.pageObjectsDir
         ? join(testsRoot, config.pageObjectsDir)
@@ -106,10 +312,30 @@ export function buildApiSurface(testsRoot, config) {
     const componentsDir = config?.componentsDir
         ? join(testsRoot, config.componentsDir)
         : join(testsRoot, 'lib', 'src', 'ui', 'components');
-    const pageObjects = [
-        ...scanDirectory(pageObjectsDir),
-        ...scanDirectory(componentsDir),
-    ];
+    let pageObjects;
+    if (config?.useRegexFallback) {
+        pageObjects = [
+            ...scanDirectoryWithRegex(pageObjectsDir),
+            ...scanDirectoryWithRegex(componentsDir),
+        ];
+    }
+    else {
+        // Use TypeScript AST — full type info, inheritance, params
+        const allFiles = [
+            ...collectTypeScriptFiles(pageObjectsDir),
+            ...collectTypeScriptFiles(componentsDir),
+        ];
+        try {
+            pageObjects = extractWithAST(allFiles);
+        }
+        catch {
+            // Fall back to regex if AST extraction fails
+            pageObjects = [
+                ...scanDirectoryWithRegex(pageObjectsDir),
+                ...scanDirectoryWithRegex(componentsDir),
+            ];
+        }
+    }
     return {
         pageObjects,
         generatedAt: new Date().toISOString(),
@@ -168,7 +394,12 @@ export function formatApiSurfaceForPrompt(catalog, classNames) {
             if (m.kind === 'getter') {
                 return `  get ${m.name}()`;
             }
-            return `  ${m.name}()`;
+            const prefix = m.async ? 'async ' : '';
+            const paramStr = m.params
+                ? m.params.map((p) => `${p.name}${p.optional ? '?' : ''}${p.type ? `: ${p.type}` : ''}`).join(', ')
+                : '';
+            const retStr = m.returnType ? `: ${m.returnType}` : '';
+            return `  ${prefix}${m.name}(${paramStr})${retStr}`;
         })
             .join('\n');
         sections.push(`${name}:\n${methodList}`);

package/dist/esm/knowledge/cluster_utils.js

@@ -0,0 +1,60 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+/**
+ * Shared cluster ID derivation for knowledge graph processing.
+ * Used by both kg_bridge.ts and kg_scanner.ts.
+ */
+/** Default directories to skip when deriving cluster IDs from file paths. */
+const DEFAULT_SKIP_DIRS = new Set([
+    'src', 'app', 'lib', 'packages', 'server', 'api', 'pages',
+    'components', 'features', 'modules',
+]);
+/** Extended skip set that also excludes test directories. */
+const SKIP_DIRS_WITH_TESTS = new Set([
+    ...DEFAULT_SKIP_DIRS,
+    'test', 'tests', 'e2e', 'spec', 'specs',
+]);
+/**
+ * Normalize a name to a snake_case cluster ID.
+ * Handles camelCase conversion, then strips non-alphanumeric characters.
+ */
+export function normalizeToClusterId(name) {
+    return name
+        .replace(/[A-Z]/g, (c, idx) => (idx > 0 ? `_${c.toLowerCase()}` : c.toLowerCase()))
+        .replace(/[^a-z0-9_]/g, '_')
+        .replace(/_+/g, '_')
+        .replace(/^_|_$/g, '');
+}
+/**
+ * Derive a cluster ID from a node that has an optional filePath and name.
+ * Prefers file path grouping for consistency.
+ */
+export function deriveClusterId(node, skipDirs) {
+    if (node.filePath) {
+        return deriveClusterIdFromPath(node.filePath, skipDirs);
+    }
+    const name = normalizeToClusterId(node.name);
+    return name && name.length > 1 ? name : null;
+}
+/**
+ * Derive a cluster ID from a file path by finding the first meaningful
+ * directory segment after skipping common structural prefixes.
+ */
+export function deriveClusterIdFromPath(filePath, skipDirs = DEFAULT_SKIP_DIRS) {
+    const parts = filePath.replace(/\\/g, '/').split('/').filter(Boolean);
+    for (const part of parts) {
+        if (skipDirs.has(part))
+            continue;
+        if (part.includes('.'))
+            continue; // skip files
+        const normalized = part.toLowerCase()
+            .replace(/[^a-z0-9_]/g, '_')
+            .replace(/_+/g, '_')
+            .replace(/^_|_$/g, '');
+        if (normalized && normalized.length > 1) {
+            return normalized;
+        }
+    }
+    return null;
+}
+export { DEFAULT_SKIP_DIRS, SKIP_DIRS_WITH_TESTS };