@yasserkhanorg/e2e-agents 0.3.2 → 0.3.3

package/dist/esm/agent/spec-builder.js

@@ -1,267 +0,0 @@
-// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
-// See LICENSE.txt for license information.
-/**
- * Spec Bridge - Bridge between PDF specs and Playwright Agent workflow
- *
- * This module converts specification documents (PDF, Markdown, JSON) into
- * Playwright-compatible markdown files that can be consumed by Playwright's
- * native agents (Planner, Generator, Healer).
- *
- * Flow: PDF → SpecParser → Markdown specs → Playwright Planner
- *
- * The Playwright agents (available in Playwright 1.56+) provide production-ready:
- * - Test planning and exploration
- * - Test code generation
- * - Automatic test healing
- *
- * Usage:
- * ```typescript
- * const bridge = new SpecBridge({type: 'anthropic', apiKey: process.env.ANTHROPIC_API_KEY});
- * const specPaths = await bridge.convertToPlaywrightSpecs('spec.pdf', 'specs/');
- * // Now use Playwright agents: @planner, @generator, @healer
- * ```
- */
-import { writeFileSync, mkdirSync, existsSync } from 'fs';
-import { join, basename } from 'path';
-import { LLMProviderFactory } from '../provider_factory.js';
-import { SpecificationParser } from '../e2e-test-gen/spec_parser.js';
-/**
- * Bridge between PDF/JSON specs and Playwright Agent workflow
- *
- * Converts specification documents into Playwright-compatible markdown
- * that can be consumed by Playwright's native agents.
- */
-export class SpecBridge {
-    constructor(config) {
-        // Handle both single provider and hybrid config
-        let llmProvider;
-        if ('primary' in config.llmConfig) {
-            // It's a HybridConfig
-            llmProvider = LLMProviderFactory.createHybrid(config.llmConfig);
-        }
-        else {
-            // It's a ProviderConfig
-            llmProvider = LLMProviderFactory.create(config.llmConfig);
-        }
-        this.parser = new SpecificationParser(llmProvider);
-        this.outputDir = config.outputDir || 'specs';
-        this.overwrite = config.overwrite !== false;
-    }
-    /**
-     * Convert a specification file to Playwright-compatible markdown specs
-     *
-     * @param inputPath - Path to the input specification (PDF, MD, or JSON)
-     * @param outputDir - Optional override for output directory
-     * @returns Conversion result with paths and metadata
-     */
-    async convertToPlaywrightSpecs(inputPath, outputDir) {
-        /* eslint-disable no-console */
-        const targetDir = outputDir || this.outputDir;
-        const warnings = [];
-        console.log(`Converting specification: ${inputPath}`);
-        // Parse the specification
-        const specs = await this.parser.parse(inputPath, 'file');
-        if (specs.length === 0) {
-            warnings.push('No features extracted from specification');
-            return {
-                specPaths: [],
-                features: [],
-                totalScenarios: 0,
-                warnings,
-            };
-        }
-        // Create output directory
-        mkdirSync(targetDir, { recursive: true });
-        const specPaths = [];
-        let totalScenarios = 0;
-        for (const spec of specs) {
-            // Validate the spec
-            const validation = this.parser.validateSpec(spec);
-            if (!validation.valid) {
-                warnings.push(`Feature "${spec.name}": ${validation.errors.join(', ')}`);
-            }
-            // Convert to Playwright markdown format
-            const markdown = this.toPlaywrightMarkdown(spec);
-            // Generate output filename
-            const filename = `${spec.id}.md`;
-            const outputPath = join(targetDir, filename);
-            // Check for existing file
-            if (existsSync(outputPath) && !this.overwrite) {
-                warnings.push(`Skipping existing file: ${outputPath}`);
-                continue;
-            }
-            // Write the spec file
-            writeFileSync(outputPath, markdown, 'utf-8');
-            specPaths.push(outputPath);
-            totalScenarios += spec.scenarios.length;
-            console.log(`  Created: ${outputPath} (${spec.scenarios.length} scenarios)`);
-        }
-        console.log(`Converted ${specs.length} feature(s) with ${totalScenarios} scenario(s)`);
-        /* eslint-enable no-console */
-        return {
-            specPaths,
-            features: specs,
-            totalScenarios,
-            warnings,
-        };
-    }
-    /**
-     * Convert a FeatureSpecification to Playwright Agent markdown format
-     *
-     * The format is designed to be consumed by Playwright's Planner and Generator agents.
-     * It includes structured test scenarios in Given-When-Then format.
-     */
-    toPlaywrightMarkdown(spec) {
-        const lines = [];
-        // Header
-        lines.push(`# ${spec.name}`);
-        lines.push('');
-        // Metadata
-        lines.push(`**Priority**: ${spec.priority}`);
-        if (spec.targetUrls.length > 0) {
-            lines.push(`**Target URLs**: ${spec.targetUrls.join(', ')}`);
-        }
-        lines.push('');
-        // Description
-        if (spec.description) {
-            lines.push('## Description');
-            lines.push('');
-            lines.push(spec.description);
-            lines.push('');
-        }
-        // Test Scenarios
-        if (spec.scenarios.length > 0) {
-            lines.push('## Test Scenarios');
-            lines.push('');
-            for (const scenario of spec.scenarios) {
-                lines.push(this.formatScenario(scenario));
-                lines.push('');
-            }
-        }
-        // Acceptance Criteria
-        if (spec.acceptanceCriteria.length > 0) {
-            lines.push('## Acceptance Criteria');
-            lines.push('');
-            for (const criterion of spec.acceptanceCriteria) {
-                lines.push(`- ${criterion}`);
-            }
-            lines.push('');
-        }
-        // Screenshots reference (if any)
-        if (spec.screenshots.length > 0) {
-            lines.push('## Reference Screenshots');
-            lines.push('');
-            for (const screenshot of spec.screenshots) {
-                lines.push(`- ${screenshot.description}: \`${screenshot.path}\``);
-            }
-            lines.push('');
-        }
-        // Metadata footer
-        lines.push('---');
-        lines.push(`*Generated from: ${basename(spec.sourcePath)}*`);
-        lines.push(`*Feature ID: ${spec.id}*`);
-        return lines.join('\n');
-    }
-    /**
-     * Format a business scenario in Playwright-friendly markdown
-     */
-    formatScenario(scenario) {
-        const lines = [];
-        lines.push(`### ${scenario.name}`);
-        lines.push('');
-        lines.push(`**Priority**: ${scenario.priority}`);
-        lines.push('');
-        if (scenario.given) {
-            lines.push(`**Given**: ${scenario.given}`);
-        }
-        if (scenario.when) {
-            lines.push(`**When**: ${scenario.when}`);
-        }
-        if (scenario.then) {
-            lines.push(`**Then**: ${scenario.then}`);
-        }
-        return lines.join('\n');
-    }
-    /**
-     * Parse a spec file without writing output
-     * Useful for validation or inspection
-     */
-    async parseSpec(inputPath) {
-        return this.parser.parse(inputPath, 'file');
-    }
-    /**
-     * Validate a specification file
-     */
-    async validateSpec(inputPath) {
-        const specs = await this.parser.parse(inputPath, 'file');
-        const allErrors = [];
-        let totalScenarios = 0;
-        for (const spec of specs) {
-            const validation = this.parser.validateSpec(spec);
-            if (!validation.valid) {
-                allErrors.push(...validation.errors.map((e) => `${spec.name}: ${e}`));
-            }
-            totalScenarios += spec.scenarios.length;
-        }
-        return {
-            valid: allErrors.length === 0,
-            errors: allErrors,
-            features: specs.length,
-            scenarios: totalScenarios,
-        };
-    }
-    /**
-     * Get a summary of the specification
-     */
-    async getSpecSummary(inputPath) {
-        const specs = await this.parser.parse(inputPath, 'file');
-        const lines = [];
-        lines.push(`Specification Summary: ${basename(inputPath)}`);
-        lines.push('='.repeat(50));
-        lines.push('');
-        for (const spec of specs) {
-            const summary = this.parser.getSpecSummary(spec);
-            lines.push(`Feature: ${summary.name}`);
-            lines.push(`  Priority: ${summary.priority}`);
-            lines.push(`  Scenarios: ${summary.scenarioCount}`);
-            lines.push(`    - Must-have: ${summary.mustHaveScenarios}`);
-            lines.push(`    - Should-have: ${summary.shouldHaveScenarios}`);
-            lines.push(`    - Nice-to-have: ${summary.niceToHaveScenarios}`);
-            lines.push(`  Acceptance Criteria: ${summary.acceptanceCriteriaCount}`);
-            lines.push(`  Has Screenshots: ${summary.hasScreenshots ? 'Yes' : 'No'}`);
-            lines.push('');
-        }
-        return lines.join('\n');
-    }
-}
-/**
- * Create a SpecBridge with Anthropic provider
- * Convenience function for common use case
- */
-export function createAnthropicBridge(apiKey, outputDir) {
-    return new SpecBridge({
-        llmConfig: {
-            type: 'anthropic',
-            config: {
-                apiKey: apiKey || process.env.ANTHROPIC_API_KEY || '',
-            },
-        },
-        outputDir,
-    });
-}
-/**
- * Create a SpecBridge with Ollama provider (free, local)
- * Convenience function for local development
- */
-export function createOllamaBridge(model, outputDir) {
-    return new SpecBridge({
-        llmConfig: {
-            type: 'ollama',
-            config: {
-                model: model || 'deepseek-r1:7b',
-                baseUrl: process.env.OLLAMA_BASE_URL || 'http://localhost:11434',
-            },
-        },
-        outputDir,
-    });
-}

package/dist/esm/agent/telemetry.js

@@ -1,216 +0,0 @@
-// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
-// See LICENSE.txt for license information.
-/**
- * Telemetry Collection System (Phase A2)
- *
- * Tracks costs, performance, and success metrics for test generation operations.
- * Provides visibility into:
- * - Cost per operation (input/output tokens * model rate)
- * - Model usage breakdown (Haiku, Sonnet, Opus)
- * - Success rate by operation
- * - Performance metrics (duration, tokens used)
- *
- * Data stored in: `.e2e-ai-agents/metrics/YYYY-MM-DD.json`
- */
-import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
-import { join } from 'path';
-import { randomUUID } from 'crypto';
-const MODEL_RATES = {
-    'claude-haiku-4-0-20250430': 0.25 / 1000000, // per input token
-    'claude-sonnet-4-5-20250929': 3 / 1000000,
-    'claude-opus-4-6-20250820': 15 / 1000000,
-};
-export class TelemetryCollector {
-    constructor(metricsDir = '.e2e-ai-agents/metrics') {
-        this.metrics = new Map();
-        this.metricsDir = metricsDir;
-        this.ensureMetricsDir();
-        this.loadTodayMetrics();
-    }
-    /**
-     * Ensure metrics directory exists
-     */
-    ensureMetricsDir() {
-        if (!existsSync(this.metricsDir)) {
-            mkdirSync(this.metricsDir, { recursive: true });
-        }
-    }
-    /**
-     * Get today's metrics file path
-     */
-    getTodayPath() {
-        const now = new Date();
-        const date = now.toISOString().split('T')[0]; // YYYY-MM-DD
-        return join(this.metricsDir, `${date}.json`);
-    }
-    /**
-     * Load metrics from disk
-     */
-    loadTodayMetrics() {
-        const path = this.getTodayPath();
-        if (existsSync(path)) {
-            try {
-                const data = JSON.parse(readFileSync(path, 'utf-8'));
-                this.metrics.set(path, data);
-            }
-            catch (error) {
-                console.error(`Failed to load metrics from ${path}:`, error);
-            }
-        }
-    }
-    /**
-     * Track a metric
-     */
-    track(metric) {
-        const fullMetric = {
-            id: randomUUID().substring(0, 8),
-            ...metric,
-        };
-        const path = this.getTodayPath();
-        const metrics = this.metrics.get(path) || [];
-        metrics.push(fullMetric);
-        this.metrics.set(path, metrics);
-        // Persist to disk
-        this.saveMetrics();
-    }
-    /**
-     * Save metrics to disk
-     */
-    saveMetrics() {
-        this.metrics.forEach((metrics, path) => {
-            writeFileSync(path, JSON.stringify(metrics, null, 2), 'utf-8');
-        });
-    }
-    /**
-     * Calculate cost for a metric
-     */
-    static calculateCost(model, tokensInput, tokensOutput) {
-        const inputRate = MODEL_RATES[model] || 0.003 / 1000000; // Default estimate
-        const outputRate = inputRate * 3; // Output usually 3x input cost
-        return tokensInput * inputRate + tokensOutput * outputRate;
-    }
-    /**
-     * Generate report for a date range
-     */
-    generateReport(since, until) {
-        const start = since || new Date(new Date().setDate(new Date().getDate() - 7)); // Default: last 7 days
-        const end = until || new Date();
-        // Collect all metrics in date range
-        const allMetrics = [];
-        this.metrics.forEach((metrics) => {
-            metrics.forEach((m) => {
-                const metricDate = new Date(m.timestamp);
-                if (metricDate >= start && metricDate <= end) {
-                    allMetrics.push(m);
-                }
-            });
-        });
-        // Calculate summary
-        const successCount = allMetrics.filter((m) => m.success).length;
-        const failureCount = allMetrics.length - successCount;
-        const totalCost = allMetrics.reduce((sum, m) => sum + m.costUsd, 0);
-        const avgCost = allMetrics.length > 0 ? totalCost / allMetrics.length : 0;
-        const totalTokens = allMetrics.reduce((sum, m) => sum + (m.tokensInput + m.tokensOutput), 0);
-        const avgDuration = allMetrics.length > 0 ? allMetrics.reduce((sum, m) => sum + m.durationMs, 0) / allMetrics.length / 1000 : 0;
-        // By model
-        const byModel = {};
-        allMetrics.forEach((m) => {
-            if (!byModel[m.model]) {
-                byModel[m.model] = { count: 0, totalCost: 0, successCount: 0 };
-            }
-            byModel[m.model].count += 1;
-            byModel[m.model].totalCost += m.costUsd;
-            if (m.success)
-                byModel[m.model].successCount += 1;
-        });
-        Object.keys(byModel).forEach((model) => {
-            const data = byModel[model];
-            byModel[model] = {
-                count: data.count,
-                totalCost: data.totalCost,
-                avgCost: data.totalCost / data.count,
-                successRate: (data.successCount / data.count) * 100,
-            };
-        });
-        // By operation
-        const byOperation = {};
-        allMetrics.forEach((m) => {
-            if (!byOperation[m.operation]) {
-                byOperation[m.operation] = { count: 0, totalCost: 0, totalDuration: 0, successCount: 0 };
-            }
-            byOperation[m.operation].count += 1;
-            byOperation[m.operation].totalCost += m.costUsd;
-            byOperation[m.operation].totalDuration += m.durationMs;
-            if (m.success)
-                byOperation[m.operation].successCount += 1;
-        });
-        Object.keys(byOperation).forEach((op) => {
-            const data = byOperation[op];
-            byOperation[op] = {
-                count: data.count,
-                totalCost: data.totalCost,
-                avgDuration: data.totalDuration / data.count / 1000,
-                successRate: (data.successCount / data.count) * 100,
-            };
-        });
-        return {
-            period: {
-                start: start.toISOString().split('T')[0],
-                end: end.toISOString().split('T')[0],
-            },
-            summary: {
-                totalOperations: allMetrics.length,
-                successCount,
-                failureCount,
-                successRate: allMetrics.length > 0 ? (successCount / allMetrics.length) * 100 : 0,
-                totalCost,
-                avgCost,
-                totalTokens,
-                avgDuration,
-            },
-            byModel,
-            byOperation,
-        };
-    }
-    /**
-     * Format report for console output
-     */
-    static formatReport(report) {
-        const lines = [
-            '',
-            '📊 Test Generation Metrics',
-            `Period: ${report.period.start} to ${report.period.end}`,
-            '═'.repeat(50),
-            '',
-            `Total Operations: ${report.summary.totalOperations}`,
-            `Success Rate: ${report.summary.successRate.toFixed(1)}% (${report.summary.successCount}/${report.summary.totalOperations})`,
-            `Total Cost: $${report.summary.totalCost.toFixed(2)}`,
-            `Avg Cost/Op: $${report.summary.avgCost.toFixed(4)}`,
-            `Avg Duration: ${report.summary.avgDuration.toFixed(1)}s`,
-            `Total Tokens: ${report.summary.totalTokens.toLocaleString()}`,
-            '',
-            'Model Usage:',
-        ];
-        Object.entries(report.byModel).forEach(([model, data]) => {
-            const shortName = model.includes('haiku') ? 'Haiku' : model.includes('sonnet') ? 'Sonnet' : 'Opus';
-            lines.push(`  ${shortName}: ${data.count} ops - $${data.totalCost.toFixed(2)} (avg $${data.avgCost.toFixed(4)}, ${data.successRate.toFixed(0)}% success)`);
-        });
-        lines.push('', 'By Operation:');
-        Object.entries(report.byOperation).forEach(([op, data]) => {
-            lines.push(`  ${op}: ${data.count} ops - $${data.totalCost.toFixed(2)} (${data.avgDuration.toFixed(1)}s avg, ${data.successRate.toFixed(0)}% success)`);
-        });
-        lines.push('');
-        return lines.join('\n');
-    }
-    /**
-     * Export metrics as JSON
-     */
-    exportJson(filepath) {
-        const allMetrics = [];
-        this.metrics.forEach((metrics) => {
-            allMetrics.push(...metrics);
-        });
-        writeFileSync(filepath, JSON.stringify(allMetrics, null, 2), 'utf-8');
-        console.log(`  ✓ Exported ${allMetrics.length} metrics to ${filepath}`);
-    }
-}

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

@@ -1,160 +0,0 @@
-// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
-// See LICENSE.txt for license information.
-/**
- * SelectorValidator: Enforces whitelist matching on generated selectors
- * Comments out unobserved selectors instead of letting tests fail randomly
- */
-export 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, '');
-    }
-}
-/**
- * APIFallbackResolver: Provides fallback strategies when UI selectors fail
- * Converts test methods to API calls when UI elements aren't available
- */
-export 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)}
-    }`;
-    }
-}

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

@@ -1,50 +0,0 @@
-// 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,
-};