@yasserkhanorg/e2e-agents 0.3.2

package/dist/esm/custom_provider.js

@@ -0,0 +1,272 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+import { LLMProviderError, UnsupportedCapabilityError } from './provider_interface.js';
+import { sanitizeErrorMessage, validateAndSanitizeUrl } from './provider_utils.js';
+import { BaseProvider } from './base_provider.js';
+import { logger } from './logger.js';
+function normalizeUrl(baseUrl, pathSuffix) {
+    const trimmed = baseUrl.replace(/\/+$/, '');
+    if (trimmed.endsWith(pathSuffix)) {
+        return trimmed;
+    }
+    return `${trimmed}${pathSuffix}`;
+}
+async function postJson(url, headers, body, timeoutMs, context) {
+    const controller = new AbortController();
+    const timer = timeoutMs ? setTimeout(() => controller.abort(), timeoutMs) : undefined;
+    try {
+        const response = await fetch(url, {
+            method: 'POST',
+            headers: {
+                'content-type': 'application/json',
+                ...headers,
+            },
+            body: JSON.stringify(body),
+            signal: controller.signal,
+        });
+        if (!response.ok) {
+            throw new Error(`HTTP ${response.status}`);
+        }
+        return (await response.json());
+    }
+    catch (error) {
+        if (error instanceof Error && error.name === 'AbortError') {
+            throw new Error(`Request timeout (${context})`);
+        }
+        throw error;
+    }
+    finally {
+        if (timer) {
+            clearTimeout(timer);
+        }
+    }
+}
+export class CustomProvider extends BaseProvider {
+    constructor(config) {
+        super();
+        this.name = 'custom';
+        const validation = validateAndSanitizeUrl(config.baseUrl);
+        if (!validation.valid) {
+            throw new Error(`Invalid base URL: ${validation.warning}`);
+        }
+        if (validation.warning) {
+            logger.warn(`HTTPS required for remote URLs: ${validation.warning}`);
+        }
+        this.config = config;
+        this.capabilities = {
+            vision: config.requestFormat !== 'custom',
+            streaming: false,
+            maxTokens: 0,
+            costPer1MInputTokens: 0,
+            costPer1MOutputTokens: 0,
+            supportsTools: false,
+            supportsPromptCaching: false,
+            typicalResponseTimeMs: 0,
+        };
+    }
+    async generateText(prompt, options) {
+        const startTime = Date.now();
+        try {
+            if (prompt.length > 10 * 1024 * 1024) {
+                throw new Error('Prompt exceeds maximum size (10MB)');
+            }
+            const response = await this.dispatchRequest(prompt, options);
+            const responseTime = Date.now() - startTime;
+            const text = response.text;
+            const usage = response.usage;
+            const cost = response.cost;
+            this.updateStats(usage, responseTime, cost);
+            return {
+                text,
+                usage,
+                cost,
+                metadata: response.metadata,
+            };
+        }
+        catch (error) {
+            this.stats.failedRequests++;
+            throw new LLMProviderError(sanitizeErrorMessage(error, 'generateText'), this.name, undefined, error);
+        }
+    }
+    async analyzeImage(images, prompt, options) {
+        if (this.config.requestFormat === 'custom') {
+            throw new UnsupportedCapabilityError(this.name, 'vision');
+        }
+        const startTime = Date.now();
+        try {
+            if (images.length === 0 || images.length > 20) {
+                throw new Error('Image count must be between 1 and 20');
+            }
+            if (prompt.length > 10 * 1024 * 1024) {
+                throw new Error('Prompt exceeds maximum size (10MB)');
+            }
+            const response = await this.dispatchRequest(prompt, options, images);
+            const responseTime = Date.now() - startTime;
+            const text = response.text;
+            const usage = response.usage;
+            const cost = response.cost;
+            this.updateStats(usage, responseTime, cost);
+            return {
+                text,
+                usage,
+                cost,
+                metadata: response.metadata,
+            };
+        }
+        catch (error) {
+            this.stats.failedRequests++;
+            throw new LLMProviderError(sanitizeErrorMessage(error, 'analyzeImage'), this.name, undefined, error);
+        }
+    }
+    async dispatchRequest(prompt, options, images) {
+        switch (this.config.requestFormat) {
+            case 'openai':
+                return this.requestOpenAI(prompt, options, images);
+            case 'anthropic':
+                return this.requestAnthropic(prompt, options, images);
+            case 'custom':
+                return this.requestCustom(prompt, options);
+            default:
+                throw new Error(`Unsupported request format: ${this.config.requestFormat}`);
+        }
+    }
+    async requestOpenAI(prompt, options, images) {
+        const url = normalizeUrl(this.config.baseUrl, '/chat/completions');
+        const messages = [];
+        if (options?.systemPrompt) {
+            messages.push({ role: 'system', content: options.systemPrompt });
+        }
+        if (images && images.length > 0) {
+            const content = [
+                { type: 'text', text: prompt },
+            ];
+            for (const image of images) {
+                const mediaType = (image.mimeType || image.mediaType || 'image/png');
+                if (!['image/png', 'image/jpeg', 'image/webp'].includes(mediaType)) {
+                    throw new Error(`Unsupported image type: ${mediaType}`);
+                }
+                const data = image.data || image.base64 || '';
+                if (data.length > 20 * 1024 * 1024) {
+                    throw new Error('Image data exceeds maximum size (20MB)');
+                }
+                content.push({
+                    type: 'image_url',
+                    image_url: { url: `data:${mediaType};base64,${data}` },
+                });
+                if (image.description) {
+                    content.push({ type: 'text', text: `[Image: ${image.description}]` });
+                }
+            }
+            messages.push({ role: 'user', content });
+        }
+        else {
+            messages.push({ role: 'user', content: prompt });
+        }
+        const body = {
+            model: this.config.model,
+            messages,
+            max_tokens: options?.maxTokens,
+            temperature: options?.temperature,
+            top_p: options?.topP,
+            stop: options?.stopSequences,
+        };
+        const response = await postJson(url, this.config.auth, body, options?.timeout, 'openai');
+        const text = response.choices?.[0]?.message?.content || '';
+        const usage = {
+            inputTokens: response.usage?.prompt_tokens || 0,
+            outputTokens: response.usage?.completion_tokens || 0,
+            totalTokens: response.usage?.total_tokens || 0,
+        };
+        return {
+            text,
+            usage,
+            cost: 0,
+            metadata: {
+                finishReason: response.choices?.[0]?.finish_reason,
+            },
+        };
+    }
+    async requestAnthropic(prompt, options, images) {
+        const url = normalizeUrl(this.config.baseUrl, '/messages');
+        const content = [
+            { type: 'text', text: prompt },
+        ];
+        if (images && images.length > 0) {
+            for (const image of images) {
+                const mediaType = (image.mimeType || image.mediaType || 'image/png');
+                if (!['image/png', 'image/jpeg', 'image/webp', 'image/gif'].includes(mediaType)) {
+                    throw new Error(`Unsupported image type: ${mediaType}`);
+                }
+                const data = image.data || image.base64 || '';
+                if (data.length > 20 * 1024 * 1024) {
+                    throw new Error('Image data exceeds maximum size (20MB)');
+                }
+                content.push({
+                    type: 'image',
+                    source: {
+                        type: 'base64',
+                        media_type: mediaType,
+                        data,
+                    },
+                });
+                if (image.description) {
+                    content.push({ type: 'text', text: `[Image: ${image.description}]` });
+                }
+            }
+        }
+        const body = {
+            model: this.config.model,
+            max_tokens: options?.maxTokens || 4000,
+            temperature: options?.temperature,
+            top_p: options?.topP,
+            stop_sequences: options?.stopSequences,
+            system: options?.systemPrompt,
+            messages: [
+                {
+                    role: 'user',
+                    content,
+                },
+            ],
+        };
+        const response = await postJson(url, this.config.auth, body, options?.timeout, 'anthropic');
+        const text = (response.content || []).map((block) => block.text).join('\n');
+        const usage = {
+            inputTokens: response.usage?.input_tokens || 0,
+            outputTokens: response.usage?.output_tokens || 0,
+            totalTokens: (response.usage?.input_tokens || 0) + (response.usage?.output_tokens || 0),
+        };
+        return {
+            text,
+            usage,
+            cost: 0,
+            metadata: {
+                stopReason: response.stop_reason,
+            },
+        };
+    }
+    async requestCustom(prompt, options) {
+        if (!this.config.transformRequest || !this.config.transformResponse) {
+            throw new Error('Custom providers require transformRequest and transformResponse');
+        }
+        const body = this.config.transformRequest(prompt, options);
+        const response = await postJson(this.config.baseUrl, this.config.auth, body, options?.timeout, 'custom');
+        const transformed = this.config.transformResponse(response);
+        return {
+            text: transformed.text,
+            usage: transformed.usage,
+            cost: transformed.cost,
+            metadata: transformed.metadata,
+        };
+    }
+    // CustomProvider doesn't support streaming
+    async *streamText() {
+        throw new Error('Streaming not supported for custom providers');
+    }
+    // CustomProvider doesn't have built-in health checks
+    async checkHealth() {
+        return {
+            healthy: true,
+            message: 'Custom provider configured',
+        };
+    }
+}

package/dist/esm/e2e-test-gen/index.js

@@ -0,0 +1,50 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+/**
+ * Autonomous E2E Testing System
+ *
+ * A specification-driven testing system that bridges PDF/Markdown specs
+ * with Playwright's native agents for test planning, generation, and healing.
+ *
+ * Quick Start:
+ * ```typescript
+ * import {SpecBridge, createAnthropicBridge} from '@mattermost/playwright-lib/autonomous';
+ *
+ * // Convert a specification to Playwright-compatible markdown
+ * const bridge = createAnthropicBridge(process.env.ANTHROPIC_API_KEY);
+ * const result = await bridge.convertToPlaywrightSpecs('spec.pdf', 'specs/');
+ *
+ * // Then use Playwright agents:
+ * // @planner explore http://localhost:8065
+ * // @generator create tests from specs/
+ * // @healer fix failing tests
+ * ```
+ *
+ * Architecture:
+ * - SpecificationParser: Parses PDF/MD/JSON specs into structured format
+ * - SpecBridge: Converts specs to Playwright Agent-compatible markdown
+ * - LLM Providers: Pluggable AI providers (Anthropic, Ollama, OpenAI)
+ *
+ * The heavy lifting (test generation, execution, healing) is delegated to
+ * Playwright's built-in agents which are production-ready and maintained
+ * by the Playwright team.
+ */
+// Core Components
+export { SpecificationParser } from './spec_parser.js';
+// LLM Providers (re-exported from parent package)
+export { LLMProviderFactory } from '../provider_factory.js';
+export { OllamaProvider } from '../ollama_provider.js';
+export { AnthropicProvider } from '../anthropic_provider.js';
+/**
+ * Version info
+ */
+export const VERSION = '2.0.0';
+export const SUPPORTED_PLAYWRIGHT_VERSION = '1.56.0';
+/**
+ * Feature flags
+ */
+export const FEATURES = {
+    LLM_AGNOSTIC: true,
+    SPECIFICATION_DRIVEN: true,
+    PLAYWRIGHT_AGENTS: true,
+};