@yasserkhanorg/e2e-agents 0.3.2

package/dist/agent/utils.js

@@ -0,0 +1,152 @@
+"use strict";
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasGlobChars = hasGlobChars;
+exports.globToRegExp = globToRegExp;
+exports.matchGlob = matchGlob;
+exports.safeReadTextFile = safeReadTextFile;
+exports.normalizePath = normalizePath;
+exports.toRelativePosix = toRelativePosix;
+exports.isPathWithinRoot = isPathWithinRoot;
+exports.fileExtension = fileExtension;
+exports.baseNameWithoutExt = baseNameWithoutExt;
+exports.tokenize = tokenize;
+exports.uniqueTokens = uniqueTokens;
+exports.titleCase = titleCase;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const MAX_READ_BYTES = 1024 * 1024; // 1MB
+const STOP_WORDS = new Set([
+    'index',
+    'component',
+    'components',
+    'page',
+    'pages',
+    'screen',
+    'screens',
+    'view',
+    'views',
+    'route',
+    'routes',
+    'feature',
+    'features',
+    'module',
+    'modules',
+    'flow',
+    'flows',
+    'test',
+    'tests',
+    'spec',
+    'specs',
+    'hooks',
+    'hook',
+    'context',
+    'state',
+    'store',
+]);
+const GLOB_CHARS = /[*?[\]{}()!]/;
+function hasGlobChars(value) {
+    return GLOB_CHARS.test(value);
+}
+function globToRegExp(pattern) {
+    const normalized = normalizePath(pattern);
+    let regex = '^';
+    let i = 0;
+    while (i < normalized.length) {
+        const char = normalized[i];
+        if (char === '*') {
+            const next = normalized[i + 1];
+            if (next === '*') {
+                regex += '.*';
+                i += 2;
+                continue;
+            }
+            regex += '[^/]*';
+            i += 1;
+            continue;
+        }
+        if (char === '?') {
+            regex += '[^/]';
+            i += 1;
+            continue;
+        }
+        if ('\\.[]{}()+-^$|'.includes(char)) {
+            regex += `\\${char}`;
+        }
+        else {
+            regex += char;
+        }
+        i += 1;
+    }
+    regex += '$';
+    return new RegExp(regex);
+}
+function matchGlob(pathValue, pattern) {
+    const normalizedPath = normalizePath(pathValue);
+    const normalizedPattern = normalizePath(pattern);
+    if (!hasGlobChars(normalizedPattern)) {
+        if (normalizedPattern.endsWith('/')) {
+            return normalizedPath.startsWith(normalizedPattern);
+        }
+        return normalizedPath === normalizedPattern || normalizedPath.startsWith(`${normalizedPattern}/`);
+    }
+    const regex = globToRegExp(normalizedPattern);
+    return regex.test(normalizedPath);
+}
+function safeReadTextFile(path) {
+    try {
+        const stats = (0, fs_1.statSync)(path);
+        if (stats.size > MAX_READ_BYTES) {
+            return null;
+        }
+        return (0, fs_1.readFileSync)(path, 'utf-8');
+    }
+    catch {
+        return null;
+    }
+}
+function normalizePath(pathValue) {
+    return pathValue.split('\\').join('/');
+}
+function toRelativePosix(root, filePath) {
+    const relative = path_1.posix.relative(normalizePath(root), normalizePath(filePath));
+    return relative.startsWith('../') ? normalizePath(filePath) : relative;
+}
+function isPathWithinRoot(root, target) {
+    const rootAbs = (0, path_1.resolve)(root);
+    const targetAbs = (0, path_1.resolve)(target);
+    const rel = (0, path_1.relative)(rootAbs, targetAbs);
+    return rel === '' || (!rel.startsWith('..') && !rel.includes(`..${path_1.posix.sep}`) && !rel.includes('..\\'));
+}
+function fileExtension(pathValue) {
+    return (0, path_1.extname)(pathValue).replace('.', '').toLowerCase();
+}
+function baseNameWithoutExt(pathValue) {
+    const base = (0, path_1.basename)(pathValue);
+    const ext = (0, path_1.extname)(base);
+    return ext ? base.slice(0, -ext.length) : base;
+}
+function splitCamelCase(value) {
+    return value.replace(/([a-z])([A-Z])/g, '$1 $2');
+}
+function tokenize(value) {
+    const normalized = splitCamelCase(value)
+        .replace(/[_\-.]/g, ' ')
+        .replace(/[^a-zA-Z0-9\s]/g, ' ')
+        .toLowerCase();
+    return normalized
+        .split(/\s+/)
+        .map((token) => token.trim())
+        .filter((token) => token.length > 2 && !STOP_WORDS.has(token));
+}
+function uniqueTokens(tokens) {
+    return Array.from(new Set(tokens.filter(Boolean)));
+}
+function titleCase(value) {
+    return value
+        .split(/[\s_-]+/)
+        .filter(Boolean)
+        .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
+        .join(' ');
+}

package/dist/agent/validators/selector-validator.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Phase 3: Selector Enforcement
+ * Validates selectors against whitelist and comments out invalid ones
+ */
+export interface ValidationResult {
+    isValid: boolean;
+    confidence: number;
+    reason?: string;
+    suggestedComment?: string;
+}
+export interface ValidatedSelector {
+    selector: string;
+    isWhitelisted: boolean;
+    confidence: number;
+    originalCode: string;
+    validatedCode: string;
+}
+/**
+ * SelectorValidator: Enforces whitelist matching on generated selectors
+ * Comments out unobserved selectors instead of letting tests fail randomly
+ */
+export declare class SelectorValidator {
+    private whitelist;
+    private semanticWhitelist;
+    private minConfidence;
+    constructor(globalSelectors: {
+        [semantic: string]: Array<{
+            selector: string;
+            confidence: number;
+        }>;
+    }, minConfidence?: number);
+    /**
+     * Validate a selector against the whitelist
+     */
+    validateSelector(selector: string): ValidationResult;
+    /**
+     * Validate and comment out invalid selectors in generated test code
+     */
+    validateTestCode(code: string): ValidatedSelector[];
+    /**
+     * Apply validation to test code, commenting out unwhitelisted selectors
+     */
+    applyValidation(code: string): string;
+    /**
+     * Get validation summary
+     */
+    getSummary(code: string): {
+        total: number;
+        whitelisted: number;
+        coverage: number;
+        unobserved: string[];
+    };
+    private normalizeSelector;
+}
+/**
+ * APIFallbackResolver: Provides fallback strategies when UI selectors fail
+ * Converts test methods to API calls when UI elements aren't available
+ */
+export declare class APIFallbackResolver {
+    private apiMapping;
+    /**
+     * Check if a test should fall back to API testing
+     */
+    shouldFallback(selector: string, confidence: number): boolean;
+    /**
+     * Generate API-based fallback for unobserved selector
+     */
+    generateAPIFallback(selector: string, action: string): string;
+    /**
+     * Wrap unobserved test in try-catch with API fallback
+     */
+    wrapWithFallback(testCode: string): string;
+}
+//# sourceMappingURL=selector-validator.d.ts.map

package/dist/agent/validators/selector-validator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"selector-validator.d.ts","sourceRoot":"","sources":["../../../src/agent/validators/selector-validator.ts"],"names":[],"mappings":"AAGA;;;GAGG;AAEH,MAAM,WAAW,gBAAgB;IAC7B,OAAO,EAAE,OAAO,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC7B;AAED,MAAM,WAAW,iBAAiB;IAC9B,QAAQ,EAAE,MAAM,CAAC;IACjB,aAAa,EAAE,OAAO,CAAC;IACvB,UAAU,EAAE,MAAM,CAAC;IACnB,YAAY,EAAE,MAAM,CAAC;IACrB,aAAa,EAAE,MAAM,CAAC;CACzB;AAED;;;GAGG;AACH,qBAAa,iBAAiB;IAC1B,OAAO,CAAC,SAAS,CAA0B;IAC3C,OAAO,CAAC,iBAAiB,CAAoC;IAC7D,OAAO,CAAC,aAAa,CAAS;gBAG1B,eAAe,EAAE;QAAC,CAAC,QAAQ,EAAE,MAAM,GAAG,KAAK,CAAC;YAAC,QAAQ,EAAE,MAAM,CAAC;YAAC,UAAU,EAAE,MAAM,CAAA;SAAC,CAAC,CAAA;KAAC,EACpF,aAAa,GAAE,MAAW;IAkB9B;;OAEG;IACH,gBAAgB,CAAC,QAAQ,EAAE,MAAM,GAAG,gBAAgB;IA6BpD;;OAEG;IACH,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,iBAAiB,EAAE;IAuBnD;;OAEG;IACH,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM;IAcrC;;OAEG;IACH,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG;QACtB,KAAK,EAAE,MAAM,CAAC;QACd,WAAW,EAAE,MAAM,CAAC;QACpB,QAAQ,EAAE,MAAM,CAAC;QACjB,UAAU,EAAE,MAAM,EAAE,CAAC;KACxB;IAeD,OAAO,CAAC,iBAAiB;CAI5B;AAED;;;GAGG;AACH,qBAAa,mBAAmB;IAC5B,OAAO,CAAC,UAAU,CAOf;IAEH;;OAEG;IACH,cAAc,CAAC,QAAQ,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO;IAI7D;;OAEG;IACH,mBAAmB,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM;IAmB7D;;OAEG;IACH,gBAAgB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM;CAS7C"}

package/dist/agent/validators/selector-validator.js

@@ -0,0 +1,165 @@
+"use strict";
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.APIFallbackResolver = exports.SelectorValidator = void 0;
+/**
+ * SelectorValidator: Enforces whitelist matching on generated selectors
+ * Comments out unobserved selectors instead of letting tests fail randomly
+ */
+class SelectorValidator {
+    constructor(globalSelectors, minConfidence = 50) {
+        this.whitelist = new Set();
+        this.semanticWhitelist = new Map();
+        this.minConfidence = minConfidence;
+        // Build flat whitelist from semantic map
+        for (const [semantic, elements] of Object.entries(globalSelectors)) {
+            for (const elem of elements) {
+                if (elem.confidence >= minConfidence) {
+                    this.whitelist.add(elem.selector);
+                }
+            }
+            this.semanticWhitelist.set(semantic, elements.map((e) => e.selector));
+        }
+    }
+    /**
+     * Validate a selector against the whitelist
+     */
+    validateSelector(selector) {
+        if (this.whitelist.has(selector)) {
+            return {
+                isValid: true,
+                confidence: 100,
+                reason: 'Found in whitelist',
+            };
+        }
+        // Check for similar selectors (lenient matching)
+        const normalized = this.normalizeSelector(selector);
+        for (const whitelisted of this.whitelist) {
+            if (this.normalizeSelector(whitelisted).includes(normalized)) {
+                return {
+                    isValid: true,
+                    confidence: 75,
+                    reason: 'Found similar whitelisted selector',
+                };
+            }
+        }
+        return {
+            isValid: false,
+            confidence: 0,
+            reason: 'Not found in whitelist',
+            suggestedComment: `// UNOBSERVED SELECTOR - Not found in UI map. Use test.fixme() if needed.`,
+        };
+    }
+    /**
+     * Validate and comment out invalid selectors in generated test code
+     */
+    validateTestCode(code) {
+        const results = [];
+        const selectorRegex = /page\.(getByTestId|getByLabel|getByRole|locator)\(['"`]([^'"`]+)['"`]\)/g;
+        let match;
+        while ((match = selectorRegex.exec(code)) !== null) {
+            const [fullMatch, , selector] = match;
+            const validation = this.validateSelector(selector);
+            results.push({
+                selector,
+                isWhitelisted: validation.isValid,
+                confidence: validation.confidence,
+                originalCode: fullMatch,
+                validatedCode: validation.isValid
+                    ? fullMatch
+                    : `// ${validation.suggestedComment}\n    // ${fullMatch}`,
+            });
+        }
+        return results;
+    }
+    /**
+     * Apply validation to test code, commenting out unwhitelisted selectors
+     */
+    applyValidation(code) {
+        let validated = code;
+        const results = this.validateTestCode(code);
+        // Apply in reverse order to preserve indices
+        for (const result of results.reverse()) {
+            if (!result.isWhitelisted) {
+                validated = validated.replace(result.originalCode, result.validatedCode);
+            }
+        }
+        return validated;
+    }
+    /**
+     * Get validation summary
+     */
+    getSummary(code) {
+        const results = this.validateTestCode(code);
+        const unobserved = results.filter((r) => !r.isWhitelisted).map((r) => r.selector);
+        return {
+            total: results.length,
+            whitelisted: results.filter((r) => r.isWhitelisted).length,
+            coverage: results.length > 0
+                ? Math.round((results.filter((r) => r.isWhitelisted).length / results.length) * 100)
+                : 100,
+            unobserved,
+        };
+    }
+    normalizeSelector(selector) {
+        // Normalize selector for lenient matching
+        return selector.toLowerCase().replace(/[^a-z0-9-_]/g, '');
+    }
+}
+exports.SelectorValidator = SelectorValidator;
+/**
+ * APIFallbackResolver: Provides fallback strategies when UI selectors fail
+ * Converts test methods to API calls when UI elements aren't available
+ */
+class APIFallbackResolver {
+    constructor() {
+        this.apiMapping = new Map([
+            // UI action -> API endpoint mapping
+            ['click.*button.*submit', 'POST /api/v4/posts'],
+            ['fill.*search', 'GET /api/v4/users'],
+            ['click.*profile', 'GET /api/v4/users/me'],
+            ['navigate.*channel', 'GET /api/v4/channels'],
+            ['click.*settings', 'PATCH /api/v4/users/me'],
+        ]);
+    }
+    /**
+     * Check if a test should fall back to API testing
+     */
+    shouldFallback(selector, confidence) {
+        return confidence < 50;
+    }
+    /**
+     * Generate API-based fallback for unobserved selector
+     */
+    generateAPIFallback(selector, action) {
+        // Find matching API endpoint
+        let endpoint = 'GET /api/v4/';
+        for (const [pattern, api] of this.apiMapping) {
+            if (new RegExp(pattern, 'i').test(action)) {
+                endpoint = api;
+                break;
+            }
+        }
+        return `
+    // UI selector not found - falling back to API
+    const response = await fetch(\`\${baseUrl}${endpoint.split(' ')[1]}\`, {
+        method: '${endpoint.split(' ')[0]}',
+        headers: {'Authorization': \`Bearer \${token}\`},
+    });
+    expect(response.ok).toBe(true);`;
+    }
+    /**
+     * Wrap unobserved test in try-catch with API fallback
+     */
+    wrapWithFallback(testCode) {
+        return `
+    try {
+        ${testCode}
+    } catch (error) {
+        // UI element not found - using API fallback
+        ${this.generateAPIFallback('unknown', testCode)}
+    }`;
+    }
+}
+exports.APIFallbackResolver = APIFallbackResolver;

package/dist/anthropic_provider.d.ts

@@ -0,0 +1,65 @@
+import type { AnthropicConfig, GenerateOptions, ImageInput, LLMResponse, ProviderCapabilities } from './provider_interface.js';
+import { BaseProvider } from './base_provider.js';
+/**
+ * Anthropic Provider - Claude AI models
+ *
+ * Features:
+ * - Highest quality AI (98% accuracy in testing)
+ * - Vision support (analyze screenshots, compare UI)
+ * - Fast response times (<1 second)
+ * - 200K token context window
+ * - Prompt caching (reduces costs by 90% on repeated prompts)
+ *
+ * Costs (Claude Sonnet 4.5):
+ * - Input: $3 per 1M tokens
+ * - Output: $15 per 1M tokens
+ * - Cached input: $0.30 per 1M tokens
+ * - Estimated: ~$30-80/month for autonomous testing
+ *
+ * Use cases:
+ * - Vision tasks (screenshot comparison)
+ * - Complex failure diagnosis
+ * - High-stakes production testing
+ * - When quality is paramount
+ *
+ * Models:
+ * - claude-sonnet-4-5-20250929 (recommended - best balance)
+ * - claude-opus-4-5-20251101 (highest quality, slower, more expensive)
+ * - claude-haiku-4-0-20250430 (fastest, cheapest, lower quality)
+ */
+export declare class AnthropicProvider extends BaseProvider {
+    name: string;
+    private client;
+    private model;
+    capabilities: ProviderCapabilities;
+    constructor(config: AnthropicConfig);
+    generateText(prompt: string, options?: GenerateOptions): Promise<LLMResponse>;
+    analyzeImage(images: ImageInput[], prompt: string, options?: GenerateOptions): Promise<LLMResponse>;
+    streamText(prompt: string, options?: GenerateOptions): AsyncGenerator<string, void, unknown>;
+    private extractTextFromResponse;
+    /**
+     * SECURITY: Type-safe usage extraction
+     * Avoids unsafe `as any` casts
+     */
+    private extractUsageFromResponse;
+    /**
+     * SECURITY: Extract status code safely
+     */
+    private extractStatusCode;
+    /**
+     * Check if API key is valid and service is accessible
+     */
+    checkHealth(): Promise<{
+        healthy: boolean;
+        message: string;
+    }>;
+}
+/**
+ * Helper to check Anthropic setup
+ */
+export declare function checkAnthropicSetup(apiKey: string): Promise<{
+    valid: boolean;
+    message: string;
+    estimatedMonthlyCost: string;
+}>;
+//# sourceMappingURL=anthropic_provider.d.ts.map

package/dist/anthropic_provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"anthropic_provider.d.ts","sourceRoot":"","sources":["../src/anthropic_provider.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EACR,eAAe,EACf,eAAe,EACf,UAAU,EACV,WAAW,EACX,oBAAoB,EACvB,MAAM,yBAAyB,CAAC;AAGjC,OAAO,EAAC,YAAY,EAAC,MAAM,oBAAoB,CAAC;AAehD;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,qBAAa,iBAAkB,SAAQ,YAAY;IAC/C,IAAI,SAAe;IACnB,OAAO,CAAC,MAAM,CAAY;IAC1B,OAAO,CAAC,KAAK,CAAS;IAEtB,YAAY,EAAE,oBAAoB,CAShC;gBAEU,MAAM,EAAE,eAAe;IA2B7B,YAAY,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,eAAe,GAAG,OAAO,CAAC,WAAW,CAAC;IA4D7E,YAAY,CAAC,MAAM,EAAE,UAAU,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,eAAe,GAAG,OAAO,CAAC,WAAW,CAAC;IAgHlG,UAAU,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,eAAe,GAAG,cAAc,CAAC,MAAM,EAAE,IAAI,EAAE,OAAO,CAAC;IA4CnG,OAAO,CAAC,uBAAuB;IAU/B;;;OAGG;IACH,OAAO,CAAC,wBAAwB;IAchC;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAWzB;;OAEG;IACG,WAAW,IAAI,OAAO,CAAC;QAAC,OAAO,EAAE,OAAO,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAC,CAAC;CAyBpE;AAED;;GAEG;AACH,wBAAsB,mBAAmB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC;IAC/D,KAAK,EAAE,OAAO,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,oBAAoB,EAAE,MAAM,CAAC;CAChC,CAAC,CAyBD"}