@yasserkhanorg/e2e-agents 1.8.5 → 1.10.0

package/dist/knowledge/api_surface.js

@@ -1,6 +1,9 @@
 "use strict";
 // Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
 // See LICENSE.txt for license information.
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.buildApiSurface = buildApiSurface;
 exports.loadOrBuildApiSurface = loadOrBuildApiSurface;
@@ -9,39 +12,233 @@ exports.validateMethodCall = validateMethodCall;
 exports.formatApiSurfaceForPrompt = formatApiSurfaceForPrompt;
 const fs_1 = require("fs");
 const path_1 = require("path");
+const typescript_1 = __importDefault(require("typescript"));
+// ── TypeScript AST-based extraction ────────────────────────
+function extractMethodsFromAST(sourceFile, checker) {
+    const surfaces = [];
+    typescript_1.default.forEachChild(sourceFile, (node) => {
+        if (!typescript_1.default.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 === typescript_1.default.SyntaxKind.ExtendsKeyword && clause.types.length > 0) {
+                    const expr = clause.types[0].expression;
+                    if (typescript_1.default.isIdentifier(expr)) {
+                        extendsName = expr.text;
+                    }
+                }
+            }
+        }
+        for (const member of node.members) {
+            // Skip constructor
+            if (typescript_1.default.isConstructorDeclaration(member)) {
+                continue;
+            }
+            // Skip private/protected members
+            const modifiers = typescript_1.default.canHaveModifiers(member) ? typescript_1.default.getModifiers(member) : undefined;
+            if (modifiers?.some((m) => m.kind === typescript_1.default.SyntaxKind.PrivateKeyword || m.kind === typescript_1.default.SyntaxKind.ProtectedKeyword)) {
+                continue;
+            }
+            const name = member.name && typescript_1.default.isIdentifier(member.name) ? member.name.text : null;
+            if (!name || name.startsWith('_') || seen.has(name)) {
+                continue;
+            }
+            seen.add(name);
+            if (typescript_1.default.isMethodDeclaration(member)) {
+                const isAsync = modifiers?.some((m) => m.kind === typescript_1.default.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 (typescript_1.default.isGetAccessorDeclaration(member)) {
+                methods.push({ name, kind: 'getter' });
+            }
+            else if (typescript_1.default.isPropertyDeclaration(member)) {
+                // Check if it's an arrow function property (e.g., name = async () => {})
+                if (member.initializer && (typescript_1.default.isArrowFunction(member.initializer) || typescript_1.default.isFunctionExpression(member.initializer))) {
+                    const fn = member.initializer;
+                    const fnModifiers = typescript_1.default.canHaveModifiers(fn) ? typescript_1.default.getModifiers(fn) : undefined;
+                    const isAsync = fnModifiers?.some((m) => m.kind === typescript_1.default.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 = typescript_1.default.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 = (0, path_1.join)(files[0], '..');
+    const tsconfigPath = typescript_1.default.findConfigFile(firstDir, typescript_1.default.sys.fileExists, 'tsconfig.json');
+    let program;
+    if (tsconfigPath) {
+        const configFile = typescript_1.default.readConfigFile(tsconfigPath, typescript_1.default.sys.readFile);
+        const parsedConfig = typescript_1.default.parseJsonConfigFileContent(configFile.config, typescript_1.default.sys, (0, path_1.join)(tsconfigPath, '..'));
+        // Only compile the files we care about, using the config's compiler options
+        program = typescript_1.default.createProgram(files, parsedConfig.options);
+    }
+    else {
+        program = typescript_1.default.createProgram(files, {
+            target: typescript_1.default.ScriptTarget.ES2022,
+            module: typescript_1.default.ModuleKind.ESNext,
+            moduleResolution: typescript_1.default.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];
@@ -50,15 +247,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;
 }
@@ -66,7 +261,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 (!(0, fs_1.existsSync)(dir)) {
+        return files;
+    }
+    const entries = (0, fs_1.readdirSync)(dir, { withFileTypes: true });
+    for (const entry of entries) {
+        const fullPath = (0, path_1.join)(dir, entry.name);
+        if (entry.isDirectory()) {
+            files.push(...collectTypeScriptFiles(fullPath));
+            continue;
+        }
+        const ext = (0, path_1.extname)(entry.name);
+        if (ext === '.ts' || ext === '.tsx') {
+            files.push(fullPath);
+        }
+    }
+    return files;
+}
+function scanDirectoryWithRegex(dir) {
     const surfaces = [];
     if (!(0, fs_1.existsSync)(dir)) {
         return surfaces;
@@ -75,29 +290,22 @@ function scanDirectory(dir) {
     for (const entry of entries) {
         const fullPath = (0, path_1.join)(dir, entry.name);
         if (entry.isDirectory()) {
-            surfaces.push(...scanDirectory(fullPath));
+            surfaces.push(...scanDirectoryWithRegex(fullPath));
             continue;
         }
         const ext = (0, path_1.extname)(entry.name);
         if (ext !== '.ts' && ext !== '.tsx') {
             continue;
         }
-        if (entry.name === 'index.ts' || entry.name === 'index.tsx') {
-            continue;
-        }
         try {
             const content = (0, fs_1.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 {
@@ -106,6 +314,7 @@ function scanDirectory(dir) {
     }
     return surfaces;
 }
+// ── Public API ──────────────────────────────────────────────
 function buildApiSurface(testsRoot, config) {
     const pageObjectsDir = config?.pageObjectsDir
         ? (0, path_1.join)(testsRoot, config.pageObjectsDir)
@@ -113,10 +322,30 @@ function buildApiSurface(testsRoot, config) {
     const componentsDir = config?.componentsDir
         ? (0, path_1.join)(testsRoot, config.componentsDir)
         : (0, path_1.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(),
@@ -175,7 +404,12 @@ 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/knowledge/cluster_utils.d.ts

@@ -0,0 +1,28 @@
+/**
+ * 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. */
+declare const DEFAULT_SKIP_DIRS: Set<string>;
+/** Extended skip set that also excludes test directories. */
+declare const SKIP_DIRS_WITH_TESTS: Set<string>;
+/**
+ * Normalize a name to a snake_case cluster ID.
+ * Handles camelCase conversion, then strips non-alphanumeric characters.
+ */
+export declare function normalizeToClusterId(name: string): string;
+/**
+ * Derive a cluster ID from a node that has an optional filePath and name.
+ * Prefers file path grouping for consistency.
+ */
+export declare function deriveClusterId(node: {
+    filePath?: string;
+    name: string;
+}, skipDirs?: Set<string>): string | null;
+/**
+ * Derive a cluster ID from a file path by finding the first meaningful
+ * directory segment after skipping common structural prefixes.
+ */
+export declare function deriveClusterIdFromPath(filePath: string, skipDirs?: Set<string>): string | null;
+export { DEFAULT_SKIP_DIRS, SKIP_DIRS_WITH_TESTS };
+//# sourceMappingURL=cluster_utils.d.ts.map

package/dist/knowledge/cluster_utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cluster_utils.d.ts","sourceRoot":"","sources":["../../src/knowledge/cluster_utils.ts"],"names":[],"mappings":"AAGA;;;GAGG;AAEH,6EAA6E;AAC7E,QAAA,MAAM,iBAAiB,aAGrB,CAAC;AAEH,6DAA6D;AAC7D,QAAA,MAAM,oBAAoB,aAGxB,CAAC;AAEH;;;GAGG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAMzD;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAC3B,IAAI,EAAE;IAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAC,EACvC,QAAQ,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,GACvB,MAAM,GAAG,IAAI,CAMf;AAED;;;GAGG;AACH,wBAAgB,uBAAuB,CACnC,QAAQ,EAAE,MAAM,EAChB,QAAQ,GAAE,GAAG,CAAC,MAAM,CAAqB,GAC1C,MAAM,GAAG,IAAI,CAef;AAED,OAAO,EAAC,iBAAiB,EAAE,oBAAoB,EAAC,CAAC"}

package/dist/knowledge/cluster_utils.js

@@ -0,0 +1,67 @@
+"use strict";
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SKIP_DIRS_WITH_TESTS = exports.DEFAULT_SKIP_DIRS = void 0;
+exports.normalizeToClusterId = normalizeToClusterId;
+exports.deriveClusterId = deriveClusterId;
+exports.deriveClusterIdFromPath = deriveClusterIdFromPath;
+/**
+ * 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',
+]);
+exports.DEFAULT_SKIP_DIRS = DEFAULT_SKIP_DIRS;
+/** Extended skip set that also excludes test directories. */
+const SKIP_DIRS_WITH_TESTS = new Set([
+    ...DEFAULT_SKIP_DIRS,
+    'test', 'tests', 'e2e', 'spec', 'specs',
+]);
+exports.SKIP_DIRS_WITH_TESTS = SKIP_DIRS_WITH_TESTS;
+/**
+ * Normalize a name to a snake_case cluster ID.
+ * Handles camelCase conversion, then strips non-alphanumeric characters.
+ */
+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.
+ */
+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.
+ */
+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;
+}

package/dist/knowledge/failure_history.d.ts

@@ -0,0 +1,39 @@
+export interface FailureCorrelation {
+    /** Source file that was changed */
+    changedFile: string;
+    /** Spec file that failed */
+    specFile: string;
+    /** Number of times this correlation has been observed */
+    count: number;
+    /** ISO timestamp of last observation */
+    lastSeen: string;
+}
+export interface FailureHistory {
+    correlations: FailureCorrelation[];
+    /** Total runs recorded */
+    totalRuns: number;
+    /** ISO timestamp of last update */
+    updatedAt: string;
+}
+export declare function loadFailureHistory(testsRoot: string): FailureHistory;
+export declare function saveFailureHistory(testsRoot: string, history: FailureHistory): void;
+/**
+ * Record that a set of changed files caused a set of spec failures.
+ * Call this after a test run where failures were observed.
+ */
+export declare function recordFailures(history: FailureHistory, changedFiles: string[], failedSpecs: string[]): FailureHistory;
+/**
+ * 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 declare function getConfidenceBoost(history: FailureHistory, changedFile: string): number;
+/**
+ * Get the most likely failing specs for a set of changed files, based on history.
+ * Returns specs sorted by correlation strength (count * recency).
+ */
+export declare function getPredictedFailures(history: FailureHistory, changedFiles: string[], limit?: number): Array<{
+    specFile: string;
+    score: number;
+}>;
+//# sourceMappingURL=failure_history.d.ts.map

package/dist/knowledge/failure_history.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"failure_history.d.ts","sourceRoot":"","sources":["../../src/knowledge/failure_history.ts"],"names":[],"mappings":"AAcA,MAAM,WAAW,kBAAkB;IAC/B,mCAAmC;IACnC,WAAW,EAAE,MAAM,CAAC;IACpB,4BAA4B;IAC5B,QAAQ,EAAE,MAAM,CAAC;IACjB,yDAAyD;IACzD,KAAK,EAAE,MAAM,CAAC;IACd,wCAAwC;IACxC,QAAQ,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,cAAc;IAC3B,YAAY,EAAE,kBAAkB,EAAE,CAAC;IACnC,0BAA0B;IAC1B,SAAS,EAAE,MAAM,CAAC;IAClB,mCAAmC;IACnC,SAAS,EAAE,MAAM,CAAC;CACrB;AAQD,wBAAgB,kBAAkB,CAAC,SAAS,EAAE,MAAM,GAAG,cAAc,CAcpE;AAED,wBAAgB,kBAAkB,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,cAAc,GAAG,IAAI,CAYnF;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAC1B,OAAO,EAAE,cAAc,EACvB,YAAY,EAAE,MAAM,EAAE,EACtB,WAAW,EAAE,MAAM,EAAE,GACtB,cAAc,CA8BhB;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,GAAG,MAAM,CAevF;AAED;;;GAGG;AACH,wBAAgB,oBAAoB,CAChC,OAAO,EAAE,cAAc,EACvB,YAAY,EAAE,MAAM,EAAE,EACtB,KAAK,SAAK,GACX,KAAK,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAC,CAAC,CAoB1C"}

package/dist/knowledge/failure_history.js

@@ -0,0 +1,128 @@
+"use strict";
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadFailureHistory = loadFailureHistory;
+exports.saveFailureHistory = saveFailureHistory;
+exports.recordFailures = recordFailures;
+exports.getConfidenceBoost = getConfidenceBoost;
+exports.getPredictedFailures = getPredictedFailures;
+/**
+ * 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.
+ */
+const fs_1 = require("fs");
+const path_1 = require("path");
+const DEFAULT_HISTORY = {
+    correlations: [],
+    totalRuns: 0,
+    updatedAt: new Date().toISOString(),
+};
+function loadFailureHistory(testsRoot) {
+    const historyPath = (0, path_1.join)(testsRoot, '.e2e-ai-agents', 'failure-history.json');
+    if (!(0, fs_1.existsSync)(historyPath)) {
+        return { ...DEFAULT_HISTORY };
+    }
+    try {
+        const raw = JSON.parse((0, fs_1.readFileSync)(historyPath, 'utf-8'));
+        if (!Array.isArray(raw.correlations)) {
+            return { ...DEFAULT_HISTORY };
+        }
+        return raw;
+    }
+    catch {
+        return { ...DEFAULT_HISTORY };
+    }
+}
+function saveFailureHistory(testsRoot, history) {
+    const historyPath = (0, path_1.join)(testsRoot, '.e2e-ai-agents', 'failure-history.json');
+    try {
+        const dir = (0, path_1.dirname)(historyPath);
+        if (!(0, fs_1.existsSync)(dir)) {
+            (0, fs_1.mkdirSync)(dir, { recursive: true });
+        }
+        history.updatedAt = new Date().toISOString();
+        (0, fs_1.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.
+ */
+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.
+ */
+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).
+ */
+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);
+}