@yasserkhanorg/e2e-agents 0.3.2

package/dist/ollama_provider.js

@@ -0,0 +1,308 @@
+"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.OllamaProvider = void 0;
+exports.checkOllamaSetup = checkOllamaSetup;
+const openai_1 = __importDefault(require("openai"));
+const provider_interface_js_1 = require("./provider_interface.js");
+const provider_utils_js_1 = require("./provider_utils.js");
+const base_provider_js_1 = require("./base_provider.js");
+const logger_js_1 = require("./logger.js");
+/**
+ * SECURITY: Validate Ollama base URL and enforce HTTPS for remote connections
+ */
+function normalizeOllamaBaseUrl(baseUrl) {
+    const raw = baseUrl || 'http://localhost:11434';
+    try {
+        const parsed = new URL(raw);
+        if (!parsed.pathname || parsed.pathname === '/') {
+            parsed.pathname = '/v1';
+        }
+        return parsed.toString().replace(/\/$/, '');
+    }
+    catch {
+        return 'http://localhost:11434/v1';
+    }
+}
+function validateOllamaUrl(baseUrl) {
+    const url = normalizeOllamaBaseUrl(baseUrl);
+    try {
+        const parsed = new URL(url);
+        // For non-localhost URLs, warn about HTTP risks
+        const isLocalhost = parsed.hostname === 'localhost' || parsed.hostname === '127.0.0.1' || parsed.hostname === '::1';
+        if (!isLocalhost && parsed.protocol === 'http:') {
+            logger_js_1.logger.warn('Ollama connection over plaintext HTTP to remote server. ' +
+                'Prompts and responses will be transmitted unencrypted. Consider using HTTPS proxy or local Ollama.');
+        }
+        return { valid: true, url };
+    }
+    catch {
+        return {
+            valid: false,
+            url: 'http://localhost:11434/v1',
+            warning: `Invalid Ollama URL: ${baseUrl}. Using default: http://localhost:11434/v1`,
+        };
+    }
+}
+/**
+ * SECURITY: Validate model name to prevent injection issues
+ */
+function validateModelName(model) {
+    // Allow alphanumeric, dash, colon, underscore
+    // Typical format: deepseek-r1:7b, llama4:13b, etc.
+    return /^[a-z0-9_:.\-]+$/i.test(model) && model.length < 256;
+}
+/**
+ * SECURITY: Validate timeout value
+ */
+function validateTimeout(timeout) {
+    if (!timeout)
+        return 60000;
+    if (timeout < 1000 || timeout > 600000) {
+        logger_js_1.logger.warn('Timeout out of valid range (1s-10m). Using 60 second default.');
+        return 60000;
+    }
+    return timeout;
+}
+/**
+ * Ollama Provider - Free, local LLM execution
+ *
+ * Features:
+ * - Zero cost (runs locally)
+ * - Full privacy (no data leaves your machine)
+ * - OpenAI-compatible API
+ * - Supports DeepSeek-R1, Llama 4, and other open models
+ *
+ * Limitations:
+ * - No vision support (most models)
+ * - Slower inference than cloud APIs (~2-5 sec vs <1 sec)
+ * - Requires local installation and model downloads
+ *
+ * Recommended models:
+ * - deepseek-r1:7b - Fast, good quality, low memory (4GB)
+ * - deepseek-r1:14b - Better quality, medium memory (8GB)
+ * - llama4:13b - High quality, medium memory (8GB)
+ * - deepseek-r1:7b-q4 - Quantized for speed, lower quality
+ *
+ * Setup:
+ * 1. Install Ollama: curl -fsSL https://ollama.com/install.sh | sh
+ * 2. Pull model: ollama pull deepseek-r1:7b
+ * 3. Start: ollama serve (runs on localhost:11434)
+ */
+class OllamaProvider extends base_provider_js_1.BaseProvider {
+    constructor(config) {
+        super();
+        this.name = 'ollama';
+        this.capabilities = {
+            vision: false, // Most Ollama models don't support vision
+            streaming: true,
+            maxTokens: 8000, // Varies by model
+            costPer1MInputTokens: 0, // Free!
+            costPer1MOutputTokens: 0, // Free!
+            supportsTools: true, // DeepSeek, Llama 4 support function calling
+            supportsPromptCaching: false,
+            typicalResponseTimeMs: 3000, // ~2-5 seconds on decent hardware
+        };
+        // SECURITY: Validate and sanitize URL
+        const urlValidation = validateOllamaUrl(config.baseUrl);
+        if (!urlValidation.valid && urlValidation.warning) {
+            console.warn(urlValidation.warning);
+        }
+        // SECURITY: Validate timeout
+        const timeout = validateTimeout(config.timeout);
+        // Ollama uses OpenAI-compatible API
+        this.client = new openai_1.default({
+            baseURL: urlValidation.url,
+            apiKey: 'ollama', // Ollama doesn't require real API key
+            timeout,
+            maxRetries: 0, // Don't retry to avoid hanging on connection issues
+        });
+        const model = config.model || 'deepseek-r1:7b';
+        // SECURITY: Validate model name format
+        if (!validateModelName(model)) {
+            throw new Error('Invalid model name format');
+        }
+        this.model = model;
+    }
+    async generateText(prompt, options) {
+        const startTime = Date.now();
+        try {
+            // SECURITY: Validate prompt length
+            if (prompt.length > 10 * 1024 * 1024) {
+                throw new Error('Prompt exceeds maximum size (10MB)');
+            }
+            const messages = [];
+            // Add system message if provided
+            if (options?.systemPrompt) {
+                messages.push({
+                    role: 'system',
+                    content: options.systemPrompt,
+                });
+            }
+            // Add user prompt
+            messages.push({
+                role: 'user',
+                content: prompt,
+            });
+            const response = await (0, provider_utils_js_1.withTimeout)(this.client.chat.completions.create({
+                model: this.model,
+                messages,
+                max_tokens: options?.maxTokens,
+                temperature: options?.temperature,
+                top_p: options?.topP,
+                stop: options?.stopSequences,
+            }), options?.timeout, 'generateText');
+            const responseTime = Date.now() - startTime;
+            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,
+            };
+            // Update stats
+            this.updateStats(usage, responseTime, 0); // Cost is always 0 for Ollama
+            return {
+                text,
+                usage,
+                cost: 0, // Free!
+                metadata: {
+                    model: this.model,
+                    responseTimeMs: responseTime,
+                    finishReason: response.choices[0]?.finish_reason,
+                },
+            };
+        }
+        catch (error) {
+            this.stats.failedRequests++;
+            throw new provider_interface_js_1.LLMProviderError((0, provider_utils_js_1.sanitizeErrorMessage)(error, 'generateText'), this.name, undefined, error);
+        }
+    }
+    /**
+     * Ollama does not support vision by default
+     * This method throws an error to help users understand the limitation
+     */
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    async analyzeImage(images, prompt, options) {
+        throw new provider_interface_js_1.UnsupportedCapabilityError(this.name, 'vision');
+    }
+    /**
+     * Stream text generation for real-time feedback
+     */
+    async *streamText(prompt, options) {
+        try {
+            // SECURITY: Validate prompt length
+            if (prompt.length > 10 * 1024 * 1024) {
+                throw new Error('Prompt exceeds maximum size (10MB)');
+            }
+            const messages = [];
+            if (options?.systemPrompt) {
+                messages.push({
+                    role: 'system',
+                    content: options.systemPrompt,
+                });
+            }
+            messages.push({
+                role: 'user',
+                content: prompt,
+            });
+            const stream = await (0, provider_utils_js_1.withTimeout)(this.client.chat.completions.create({
+                model: this.model,
+                messages,
+                max_tokens: options?.maxTokens,
+                temperature: options?.temperature,
+                top_p: options?.topP,
+                stop: options?.stopSequences,
+                stream: true,
+            }), options?.timeout, 'streamText');
+            for await (const chunk of stream) {
+                const content = chunk.choices[0]?.delta?.content;
+                if (content) {
+                    yield content;
+                }
+            }
+            // Note: Streaming doesn't provide detailed usage stats
+            // We increment request count but can't track exact tokens
+            this.stats.requestCount++;
+            this.stats.lastUpdated = new Date();
+        }
+        catch (error) {
+            this.stats.failedRequests++;
+            throw new provider_interface_js_1.LLMProviderError((0, provider_utils_js_1.sanitizeErrorMessage)(error, 'streamText'), this.name, undefined, error);
+        }
+    }
+    /**
+     * Check if Ollama is running and accessible
+     */
+    async checkHealth() {
+        try {
+            // Try a simple request
+            await (0, provider_utils_js_1.withTimeout)(this.client.models.list(), 5000, 'health check');
+            return {
+                healthy: true,
+                message: `Ollama is running with model: ${this.model}`,
+            };
+        }
+        catch (error) {
+            return {
+                healthy: false,
+                message: `Ollama not accessible: ${(0, provider_utils_js_1.sanitizeErrorMessage)(error, 'health check')}`,
+            };
+        }
+    }
+    /**
+     * List available models in Ollama
+     */
+    async listModels() {
+        try {
+            const response = await (0, provider_utils_js_1.withTimeout)(this.client.models.list(), 5000, 'listModels');
+            return response.data.map((model) => model.id);
+        }
+        catch (error) {
+            throw new provider_interface_js_1.LLMProviderError((0, provider_utils_js_1.sanitizeErrorMessage)(error, 'listModels'), this.name, undefined, error);
+        }
+    }
+}
+exports.OllamaProvider = OllamaProvider;
+/**
+ * Helper function to check if Ollama is installed and suggest setup
+ */
+async function checkOllamaSetup() {
+    const provider = new OllamaProvider({});
+    try {
+        const health = await provider.checkHealth();
+        const models = await provider.listModels();
+        return {
+            installed: true,
+            running: health.healthy,
+            modelAvailable: models.length > 0,
+            setupInstructions: health.healthy ? 'Ollama is ready to use!' : 'Run: ollama serve',
+        };
+    }
+    catch {
+        return {
+            installed: false,
+            running: false,
+            modelAvailable: false,
+            setupInstructions: `
+Ollama is not installed. To set up:
+
+1. Install Ollama:
+   curl -fsSL https://ollama.com/install.sh | sh
+
+2. Pull a model (choose one):
+   ollama pull deepseek-r1:7b          # Recommended: Fast, 4GB RAM
+   ollama pull deepseek-r1:14b         # Better quality, 8GB RAM
+   ollama pull llama4:13b              # Alternative, 8GB RAM
+
+3. Start Ollama:
+   ollama serve
+
+For more info: https://ollama.com
+            `.trim(),
+        };
+    }
+}

package/dist/openai_provider.d.ts

@@ -0,0 +1,23 @@
+import type { GenerateOptions, ImageInput, LLMResponse, OpenAIConfig, ProviderCapabilities } from './provider_interface.js';
+import { BaseProvider } from './base_provider.js';
+export declare class OpenAIProvider extends BaseProvider {
+    name: string;
+    private client;
+    private model;
+    capabilities: ProviderCapabilities;
+    constructor(config: OpenAIConfig);
+    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 extractUsage;
+    private extractStatusCode;
+    checkHealth(): Promise<{
+        healthy: boolean;
+        message: string;
+    }>;
+}
+export declare function checkOpenAISetup(apiKey: string): Promise<{
+    valid: boolean;
+    message: string;
+}>;
+//# sourceMappingURL=openai_provider.d.ts.map

package/dist/openai_provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"openai_provider.d.ts","sourceRoot":"","sources":["../src/openai_provider.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EACR,eAAe,EACf,UAAU,EACV,WAAW,EACX,YAAY,EACZ,oBAAoB,EACvB,MAAM,yBAAyB,CAAC;AAGjC,OAAO,EAAC,YAAY,EAAC,MAAM,oBAAoB,CAAC;AAehD,qBAAa,cAAe,SAAQ,YAAY;IAC5C,IAAI,SAAY;IAChB,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,KAAK,CAAS;IAEtB,YAAY,EAAE,oBAAoB,CAAC;gBAEvB,MAAM,EAAE,YAAY;IAyC1B,YAAY,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,eAAe,GAAG,OAAO,CAAC,WAAW,CAAC;IA2D7E,YAAY,CAAC,MAAM,EAAE,UAAU,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,eAAe,GAAG,OAAO,CAAC,WAAW,CAAC;IAgGlG,UAAU,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,eAAe,GAAG,cAAc,CAAC,MAAM,EAAE,IAAI,EAAE,OAAO,CAAC;IA8CnG,OAAO,CAAC,YAAY;IAYpB,OAAO,CAAC,iBAAiB;IAWnB,WAAW,IAAI,OAAO,CAAC;QAAC,OAAO,EAAE,OAAO,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAC,CAAC;CAuBpE;AAED,wBAAsB,gBAAgB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC;IAC5D,KAAK,EAAE,OAAO,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;CACnB,CAAC,CAsBD"}

package/dist/openai_provider.js

@@ -0,0 +1,250 @@
+"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.OpenAIProvider = void 0;
+exports.checkOpenAISetup = checkOpenAISetup;
+const openai_1 = __importDefault(require("openai"));
+const provider_interface_js_1 = require("./provider_interface.js");
+const provider_utils_js_1 = require("./provider_utils.js");
+const base_provider_js_1 = require("./base_provider.js");
+const logger_js_1 = require("./logger.js");
+function inferVisionSupport(model) {
+    const lower = model.toLowerCase();
+    return lower.includes('vision') || lower.includes('4o') || lower.includes('omni');
+}
+class OpenAIProvider extends base_provider_js_1.BaseProvider {
+    constructor(config) {
+        super();
+        this.name = 'openai';
+        if (!provider_utils_js_1.API_KEY_PATTERNS.openai.test(config.apiKey)) {
+            throw new Error('Invalid API key format. Expected sk-* format.');
+        }
+        if (config.baseUrl) {
+            const validation = (0, provider_utils_js_1.validateAndSanitizeUrl)(config.baseUrl);
+            if (!validation.valid) {
+                throw new Error(`Invalid base URL: ${validation.warning}`);
+            }
+            if (validation.warning) {
+                logger_js_1.logger.warn(`HTTPS required for remote URLs: ${validation.warning}`);
+            }
+        }
+        this.client = new openai_1.default({
+            apiKey: config.apiKey,
+            baseURL: config.baseUrl,
+            organization: config.organizationId,
+        });
+        this.model = config.model || 'gpt-4';
+        const maxTokens = config.maxTokens || 128000;
+        const costPer1MInputTokens = config.costPer1MInputTokens ?? 0;
+        const costPer1MOutputTokens = config.costPer1MOutputTokens ?? 0;
+        this.capabilities = {
+            vision: inferVisionSupport(this.model),
+            streaming: true,
+            maxTokens,
+            costPer1MInputTokens,
+            costPer1MOutputTokens,
+            supportsTools: true,
+            supportsPromptCaching: false,
+            typicalResponseTimeMs: 1200,
+        };
+    }
+    async generateText(prompt, options) {
+        const startTime = Date.now();
+        try {
+            if (prompt.length > 10 * 1024 * 1024) {
+                throw new Error('Prompt exceeds maximum size (10MB)');
+            }
+            const messages = [];
+            if (options?.systemPrompt) {
+                messages.push({ role: 'system', content: options.systemPrompt });
+            }
+            messages.push({ role: 'user', content: prompt });
+            const response = await (0, provider_utils_js_1.withTimeout)(this.client.chat.completions.create({
+                model: this.model,
+                messages,
+                max_tokens: options?.maxTokens,
+                temperature: options?.temperature,
+                top_p: options?.topP,
+                stop: options?.stopSequences,
+            }), options?.timeout, 'generateText');
+            const responseTime = Date.now() - startTime;
+            const text = response.choices[0]?.message?.content || '';
+            const usage = this.extractUsage(response.usage);
+            const cost = this.calculateCost(usage, this.capabilities.costPer1MInputTokens, this.capabilities.costPer1MOutputTokens);
+            this.updateStats(usage, responseTime, cost);
+            return {
+                text,
+                usage,
+                cost,
+                metadata: {
+                    model: this.model,
+                    responseTimeMs: responseTime,
+                    finishReason: response.choices[0]?.finish_reason,
+                },
+            };
+        }
+        catch (error) {
+            this.stats.failedRequests++;
+            throw new provider_interface_js_1.LLMProviderError((0, provider_utils_js_1.sanitizeErrorMessage)(error, 'generateText'), this.name, this.extractStatusCode(error), error);
+        }
+    }
+    async analyzeImage(images, prompt, options) {
+        if (!this.capabilities.vision) {
+            throw new provider_interface_js_1.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 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)');
+                }
+                const url = `data:${mediaType};base64,${data}`;
+                content.push({ type: 'image_url', image_url: { url } });
+                if (image.description) {
+                    content.push({ type: 'text', text: `[Image: ${image.description}]` });
+                }
+            }
+            const messages = [];
+            if (options?.systemPrompt) {
+                messages.push({ role: 'system', content: options.systemPrompt });
+            }
+            messages.push({ role: 'user', content });
+            const response = await (0, provider_utils_js_1.withTimeout)(this.client.chat.completions.create({
+                model: this.model,
+                messages,
+                max_tokens: options?.maxTokens,
+                temperature: options?.temperature,
+                top_p: options?.topP,
+                stop: options?.stopSequences,
+            }), options?.timeout, 'analyzeImage');
+            const responseTime = Date.now() - startTime;
+            const text = response.choices[0]?.message?.content || '';
+            const usage = this.extractUsage(response.usage);
+            const cost = this.calculateCost(usage, this.capabilities.costPer1MInputTokens, this.capabilities.costPer1MOutputTokens);
+            this.updateStats(usage, responseTime, cost);
+            return {
+                text,
+                usage,
+                cost,
+                metadata: {
+                    model: this.model,
+                    responseTimeMs: responseTime,
+                    finishReason: response.choices[0]?.finish_reason,
+                    imageCount: images.length,
+                },
+            };
+        }
+        catch (error) {
+            this.stats.failedRequests++;
+            throw new provider_interface_js_1.LLMProviderError((0, provider_utils_js_1.sanitizeErrorMessage)(error, 'analyzeImage'), this.name, this.extractStatusCode(error), error);
+        }
+    }
+    async *streamText(prompt, options) {
+        try {
+            if (prompt.length > 10 * 1024 * 1024) {
+                throw new Error('Prompt exceeds maximum size (10MB)');
+            }
+            const messages = [];
+            if (options?.systemPrompt) {
+                messages.push({ role: 'system', content: options.systemPrompt });
+            }
+            messages.push({ role: 'user', content: prompt });
+            const stream = await (0, provider_utils_js_1.withTimeout)(this.client.chat.completions.create({
+                model: this.model,
+                messages,
+                max_tokens: options?.maxTokens,
+                temperature: options?.temperature,
+                top_p: options?.topP,
+                stop: options?.stopSequences,
+                stream: true,
+            }), options?.timeout, 'streamText');
+            for await (const chunk of stream) {
+                const content = chunk.choices[0]?.delta?.content;
+                if (content) {
+                    yield content;
+                }
+            }
+            this.stats.requestCount++;
+            this.stats.lastUpdated = new Date();
+        }
+        catch (error) {
+            this.stats.failedRequests++;
+            throw new provider_interface_js_1.LLMProviderError((0, provider_utils_js_1.sanitizeErrorMessage)(error, 'streamText'), this.name, this.extractStatusCode(error), error);
+        }
+    }
+    extractUsage(usage) {
+        return {
+            inputTokens: usage?.prompt_tokens || 0,
+            outputTokens: usage?.completion_tokens || 0,
+            totalTokens: usage?.total_tokens || 0,
+        };
+    }
+    extractStatusCode(error) {
+        if (error && typeof error === 'object') {
+            const err = error;
+            const status = err.status;
+            if (typeof status === 'number') {
+                return status;
+            }
+        }
+        return undefined;
+    }
+    async checkHealth() {
+        try {
+            await (0, provider_utils_js_1.withTimeout)(this.client.chat.completions.create({
+                model: this.model,
+                max_tokens: 5,
+                messages: [{ role: 'user', content: 'Hi' }],
+            }), 5000, 'health check');
+            return {
+                healthy: true,
+                message: 'OpenAI API is accessible',
+            };
+        }
+        catch (error) {
+            return {
+                healthy: false,
+                message: `OpenAI API error: ${(0, provider_utils_js_1.sanitizeErrorMessage)(error, 'health check')}`,
+            };
+        }
+    }
+}
+exports.OpenAIProvider = OpenAIProvider;
+async function checkOpenAISetup(apiKey) {
+    if (!apiKey) {
+        return {
+            valid: false,
+            message: 'No API key provided',
+        };
+    }
+    try {
+        const provider = new OpenAIProvider({ apiKey });
+        const health = await provider.checkHealth();
+        return {
+            valid: health.healthy,
+            message: health.message,
+        };
+    }
+    catch (error) {
+        return {
+            valid: false,
+            message: `Setup check failed: ${(0, provider_utils_js_1.sanitizeErrorMessage)(error, 'setup check')}`,
+        };
+    }
+}

package/dist/plan-and-test-constants.d.ts

@@ -0,0 +1,110 @@
+/**
+ * Centralized constants for plan-and-test command
+ * Eliminates magic strings and hardcoded values
+ * Makes configuration easy to modify and maintain
+ */
+export declare const PLANNING_CONFIG: {
+    readonly SCENARIO_COUNTS: {
+        readonly P0: 3;
+        readonly P1: 2;
+        readonly P2: 1;
+    };
+    readonly DEFAULTS: {
+        readonly MAX_TESTS: 10;
+        readonly COVERAGE_THRESHOLD: 50;
+        readonly PRIORITY_FILTER: readonly ["P0", "P1"];
+    };
+    readonly LIMITS: {
+        readonly MIN_MAX_TESTS: 1;
+        readonly MAX_MAX_TESTS: 100;
+        readonly MIN_COVERAGE_THRESHOLD: 0;
+        readonly MAX_COVERAGE_THRESHOLD: 100;
+    };
+};
+/**
+ * Display messages for plan-and-test command
+ */
+export declare const PLAN_AND_TEST_MESSAGES: {
+    readonly HEADER: {
+        readonly MAIN: "🚀 Planning and Generating Tests";
+        readonly STEP_1_ANALYSIS: "📊 Step 1: Analyzing Code Changes...";
+        readonly STEP_2_PLANNING: "💡 Step 2: Planning Test Generation...";
+        readonly STEP_3_GENERATION: "⚡ Step 3: Generating Tests...";
+        readonly STEP_4_SUMMARY: "📈 Generation Summary";
+        readonly FOUND_FLOW_GROUPS: (count: number) => string;
+    };
+    readonly ANALYSIS: {
+        readonly FOUND_FLOWS: (count: number) => string;
+        readonly MORE_FLOWS: (count: number) => string;
+        readonly FOUND_FLOW_GROUPS: (count: number) => string;
+    };
+    readonly PLANNING: {
+        readonly PLAN_CREATED: (count: number) => string;
+        readonly SKIPPING_COUNT: (count: number) => string;
+    };
+    readonly SKIP_REASONS: {
+        readonly MAX_LIMIT_REACHED: (limit: number) => string;
+        readonly ALREADY_COVERED: (count: number) => string;
+    };
+    readonly COVERAGE_REASONS: {
+        readonly NO_COVERAGE: (priority: string) => string;
+        readonly PARTIAL_COVERAGE: (priority: string, gaps: number) => string;
+    };
+    readonly EXECUTION: {
+        readonly TEST_COUNT: (index: number, total: number) => string;
+        readonly GENERATION_FAILED: (error: string) => string;
+        readonly DRY_RUN_MODE: "📋 DRY RUN: Not executing. Run without --dry-run to generate tests.";
+    };
+    readonly SUMMARY: {
+        readonly SEPARATOR: string;
+        readonly TOTAL_GENERATED: (count: number) => string;
+        readonly SUCCESSFUL: (successful: number, total: number) => string;
+        readonly TOTAL_SCENARIOS: (count: number) => string;
+        readonly COMPLETION: "✅ Execution complete!";
+    };
+    readonly NEXT_STEPS: readonly ["  • Run tests: npx playwright test --grep @smoke", "  • Re-run impact: npx e2e-ai-agents impact --path <app-root> --tests-root <tests-root>", "  • Check coverage: npm run test:impact"];
+    readonly ERRORS: {
+        readonly INVALID_PRIORITY: (priorities: string[]) => string;
+        readonly INVALID_MAX_TESTS: (min: number, max: number) => string;
+        readonly INVALID_COVERAGE_THRESHOLD: (min: number, max: number) => string;
+        readonly NO_CHANGES_DETECTED: "✓ No significant changes detected";
+    };
+};
+/**
+ * Priority levels in the system
+ */
+export declare const PRIORITY_LEVELS: {
+    readonly CRITICAL: "P0";
+    readonly HIGH: "P1";
+    readonly MEDIUM: "P2";
+};
+/**
+ * Test strategy types for flow groups
+ */
+export declare const TEST_STRATEGIES: {
+    readonly SEQUENTIAL: "sequential";
+    readonly PARALLEL: "parallel";
+    readonly MIXED: "mixed";
+};
+/**
+ * Flow group types
+ */
+export declare const FLOW_GROUP_TYPES: {
+    readonly MESSAGING_LIFECYCLE: "messaging-lifecycle";
+    readonly CHANNEL_MANAGEMENT: "channel-management";
+    readonly MESSAGING_INTERACTIONS: "messaging-interactions";
+};
+/**
+ * Utility function to get scenario count for a priority
+ * Provides type-safe access to scenario counts
+ */
+export declare function getScenarioCount(priority: string): number;
+/**
+ * Utility function to validate priority level
+ */
+export declare function isValidPriority(priority: string): boolean;
+/**
+ * Utility function to get all valid priority levels
+ */
+export declare function getValidPriorities(): string[];
+//# sourceMappingURL=plan-and-test-constants.d.ts.map