@yasserkhanorg/e2e-agents 1.9.5 → 1.10.0

package/dist/esm/pipeline/stage3_generation.js

@@ -101,10 +101,29 @@ export async function runGenerationStage(decisions, apiSurface, testsRoot, confi
                 skipped.push(`${decision.flowId}: invalid code returned`);
                 continue;
             }
-            // Hallucination detection
+            // Hallucination detection — block specs with hallucinated methods
             const hallucinationWarnings = detectHallucinatedMethods(parsed.code, apiSurface);
             if (hallucinationWarnings.length > 0) {
                 warnings.push(`Flow ${decision.flowId}: suspected hallucinated methods: ${hallucinationWarnings.join(', ')}`);
+                if (!config.warnOnHallucinations) {
+                    // Block: move to needs-review instead of writing to specs dir
+                    if (!dryRun) {
+                        const reviewDir = join(testsRoot, 'generated-needs-review');
+                        mkdirSync(reviewDir, { recursive: true });
+                        const safeName = decision.flowId.replace(/[^a-zA-Z0-9_-]/g, '_').toLowerCase();
+                        const reviewPath = join(reviewDir, `${safeName}-${Date.now().toString(36)}.spec.ts`);
+                        writeFileSync(reviewPath, `${parsed.code}\n`, 'utf-8');
+                        warnings.push(`Flow ${decision.flowId}: blocked — moved to ${reviewPath}`);
+                    }
+                    generated.push({
+                        flowId: decision.flowId,
+                        specPath,
+                        mode,
+                        written: false,
+                        hallucinationWarnings,
+                    });
+                    continue;
+                }
             }
             let written = false;
             if (!dryRun) {

package/dist/esm/prompts/coverage.js

@@ -40,6 +40,16 @@ export function buildCoveragePrompt(ctx) {
         '- For add_scenarios, specify which existing spec file to extend in targetSpec.',
         `- For create_spec, suggest a path following ${ctx.profile?.projectName || 'Mattermost'} conventions.`,
         '- Prefer adding scenarios to existing specs over creating new spec files.',
+        '',
+        'SEMANTIC MATCHING RULES (critical for accuracy):',
+        '- A happy-path test does NOT cover the negative/error path of the same feature.',
+        '  "user can edit post" does NOT cover "user without permission cannot edit post".',
+        '- A test for one user role does NOT cover a different role.',
+        '  "admin can delete channel" does NOT cover "member cannot delete channel".',
+        '- A test for creation does NOT cover editing or deletion of the same entity.',
+        '- "partial" means: same feature area but different specific scenario.',
+        '- "full" means: the exact user action sequence and outcome is tested.',
+        '- When in doubt between "full" and "partial", choose "partial".',
     ].join('\n');
 }
 export function parseCoverageResponse(text) {

package/dist/esm/prompts/generation.js

@@ -22,6 +22,18 @@ function resolveRelevantPageObjects(apiSurface, decision) {
     }
     return [...new Set(relevant)].slice(0, 10);
 }
+function buildAssertionPatternsBlock(patterns) {
+    if (!patterns || patterns.length === 0) {
+        return [];
+    }
+    return [
+        'REQUIRED ASSERTION PATTERNS:',
+        'Your tests MUST include assertions that verify each of these behaviors.',
+        'Do NOT just check element visibility — verify the actual business outcome.',
+        ...patterns.map((p) => `  - [${p.type}] ${p.pattern}`),
+        '',
+    ];
+}
 export function buildGenerationPrompt(ctx) {
     const profile = ctx.profile;
     const isMM = profile ? isMattermostProfile(profile) : true;
@@ -122,6 +134,7 @@ export function buildGenerationPrompt(ctx) {
         'USER ACTIONS:',
         ctx.decision.userActions.map((a) => `  - ${sanitizeForPrompt(a)}`).join('\n') || '  (none specified)',
         '',
+        ...buildAssertionPatternsBlock(ctx.decision.assertionPatterns),
         'AVAILABLE PAGE OBJECTS AND METHODS:',
         apiBlock,
         existingBlock,
@@ -157,6 +170,8 @@ function buildApiTestPrompt(ctx, profile, scenariosBlock, routeFamilyTag) {
         '',
         'USER ACTIONS:',
         ctx.decision.userActions.map((a) => `  - ${sanitizeForPrompt(a)}`).join('\n') || '  (none specified)',
+        '',
+        ...buildAssertionPatternsBlock(ctx.decision.assertionPatterns),
         existingBlock,
         '',
         'MANDATORY RULES:',
@@ -246,18 +261,37 @@ const BUILT_IN_METHODS = new Set([
 ]);
 /**
  * Returns method names that appear in generated code but do not exist in the API surface.
- * Used for logging; does not block generation.
+ * Detects all call patterns: await X.Y(), X.Y(), const z = X.Y(), chained calls.
  */
 export function detectHallucinatedMethods(code, apiSurface) {
     const allMethods = new Set(apiSurface.pageObjects.flatMap((po) => po.methods.map((m) => m.name)));
-    const suspected = [];
-    const callRe = /\bawait\s+\w+\.([a-zA-Z_]\w*)\s*\(/g;
+    const suspected = new Set();
+    const callPatterns = [
+        /\bawait\s+\w+\.([a-zA-Z_]\w*)\s*\(/g,
+        /\b(?:const|let|var)\s+\w+\s*=\s*\w+\.([a-zA-Z_]\w*)\s*\(/g,
+        /\b\w+Page\.([a-zA-Z_]\w*)\s*\(/g, // any *Page object (channelsPage, settingsPage, etc.)
+        /\b(?:pw|page|this)\.\w*\.?([a-zA-Z_]\w*)\s*\(/g,
+    ];
+    const generalCallRe = /\b[a-zA-Z_]\w*\.([a-zA-Z_]\w*)\s*\(/g;
+    for (const re of callPatterns) {
+        let match;
+        while ((match = re.exec(code)) !== null) {
+            const methodName = match[1];
+            if (!BUILT_IN_METHODS.has(methodName) && !allMethods.has(methodName) && methodName.length > 3) {
+                suspected.add(methodName);
+            }
+        }
+    }
     let match;
-    while ((match = callRe.exec(code)) !== null) {
+    while ((match = generalCallRe.exec(code)) !== null) {
         const methodName = match[1];
-        if (!BUILT_IN_METHODS.has(methodName) && !allMethods.has(methodName) && methodName.length > 3) {
-            suspected.push(methodName);
+        if (!BUILT_IN_METHODS.has(methodName) &&
+            !allMethods.has(methodName) &&
+            methodName.length > 3 &&
+            !methodName.startsWith('to') &&
+            !methodName.startsWith('get')) {
+            suspected.add(methodName);
         }
     }
-    return [...new Set(suspected)];
+    return [...suspected];
 }

package/dist/esm/validation/guardrails.js

@@ -23,6 +23,11 @@ export function computeConfidence(check) {
     if (check.hasExistingSpecCited) {
         score += 15;
     }
+    // Historical failure correlation: if this file historically causes test failures,
+    // we're more confident it needs testing now
+    if (check.historyBoost) {
+        score += check.historyBoost;
+    }
     return Math.min(100, score);
 }
 export function classifyConfidence(confidence) {

package/dist/knowledge/api_surface.d.ts

@@ -1,11 +1,21 @@
+export interface MethodParam {
+    name: string;
+    type?: string;
+    optional?: boolean;
+}
 export interface MethodSignature {
     name: string;
     kind: 'method' | 'property' | 'getter';
+    params?: MethodParam[];
+    returnType?: string;
+    async?: boolean;
 }
 export interface PageObjectSurface {
     className: string;
     file: string;
     methods: MethodSignature[];
+    /** Base class name if the class extends another */
+    extends?: string;
 }
 export interface ApiSurfaceCatalog {
     pageObjects: PageObjectSurface[];
@@ -16,6 +26,8 @@ export interface ApiSurfaceConfig {
     pageObjectsDir?: string;
     componentsDir?: string;
     cachePath?: string;
+    /** Use fast regex extraction instead of TypeScript AST (fallback mode) */
+    useRegexFallback?: boolean;
 }
 export declare function buildApiSurface(testsRoot: string, config?: ApiSurfaceConfig): ApiSurfaceCatalog;
 export declare function loadOrBuildApiSurface(testsRoot: string, config?: ApiSurfaceConfig): ApiSurfaceCatalog;

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

@@ -1 +1 @@
-{"version":3,"file":"api_surface.d.ts","sourceRoot":"","sources":["../../src/knowledge/api_surface.ts"],"names":[],"mappings":"AAMA,MAAM,WAAW,eAAe;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,QAAQ,GAAG,UAAU,GAAG,QAAQ,CAAC;CAC1C;AAED,MAAM,WAAW,iBAAiB;IAC9B,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,eAAe,EAAE,CAAC;CAC9B;AAED,MAAM,WAAW,iBAAiB;IAC9B,WAAW,EAAE,iBAAiB,EAAE,CAAC;IACjC,WAAW,EAAE,MAAM,CAAC;CACvB;AAED,MAAM,WAAW,gBAAgB;IAC7B,OAAO,EAAE,OAAO,CAAC;IACjB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,SAAS,CAAC,EAAE,MAAM,CAAC;CACtB;AA4GD,wBAAgB,eAAe,CAAC,SAAS,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,gBAAgB,GAAG,iBAAiB,CAiB/F;AAED,wBAAgB,qBAAqB,CAAC,SAAS,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,gBAAgB,GAAG,iBAAiB,CAgCrG;AAED,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,iBAAiB,EAAE,SAAS,EAAE,MAAM,GAAG,eAAe,EAAE,CAGxG;AAED,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,iBAAiB,EAAE,SAAS,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAG7G;AAED,wBAAgB,yBAAyB,CAAC,OAAO,EAAE,iBAAiB,EAAE,UAAU,EAAE,MAAM,EAAE,GAAG,MAAM,CAqBlG"}
+{"version":3,"file":"api_surface.d.ts","sourceRoot":"","sources":["../../src/knowledge/api_surface.ts"],"names":[],"mappings":"AAOA,MAAM,WAAW,WAAW;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,QAAQ,CAAC,EAAE,OAAO,CAAC;CACtB;AAED,MAAM,WAAW,eAAe;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,QAAQ,GAAG,UAAU,GAAG,QAAQ,CAAC;IACvC,MAAM,CAAC,EAAE,WAAW,EAAE,CAAC;IACvB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,KAAK,CAAC,EAAE,OAAO,CAAC;CACnB;AAED,MAAM,WAAW,iBAAiB;IAC9B,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,eAAe,EAAE,CAAC;IAC3B,mDAAmD;IACnD,OAAO,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,iBAAiB;IAC9B,WAAW,EAAE,iBAAiB,EAAE,CAAC;IACjC,WAAW,EAAE,MAAM,CAAC;CACvB;AAED,MAAM,WAAW,gBAAgB;IAC7B,OAAO,EAAE,OAAO,CAAC;IACjB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,0EAA0E;IAC1E,gBAAgB,CAAC,EAAE,OAAO,CAAC;CAC9B;AAgVD,wBAAgB,eAAe,CAAC,SAAS,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,gBAAgB,GAAG,iBAAiB,CAqC/F;AAED,wBAAgB,qBAAqB,CAAC,SAAS,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,gBAAgB,GAAG,iBAAiB,CAgCrG;AAED,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,iBAAiB,EAAE,SAAS,EAAE,MAAM,GAAG,eAAe,EAAE,CAGxG;AAED,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,iBAAiB,EAAE,SAAS,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAG7G;AAED,wBAAgB,yBAAyB,CAAC,OAAO,EAAE,iBAAiB,EAAE,UAAU,EAAE,MAAM,EAAE,GAAG,MAAM,CA0BlG"}

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/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"}