@yasserkhanorg/e2e-agents 0.3.2

package/dist/esm/provider_factory.js

@@ -0,0 +1,336 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+import { AnthropicProvider } from './anthropic_provider.js';
+import { CustomProvider } from './custom_provider.js';
+import { OllamaProvider } from './ollama_provider.js';
+import { OpenAIProvider } from './openai_provider.js';
+import { UnsupportedCapabilityError } from './provider_interface.js';
+/**
+ * LLM Provider Factory
+ *
+ * Creates and configures LLM providers based on configuration.
+ * Supports multiple strategies:
+ * - Single provider (Ollama, Anthropic, etc.)
+ * - Hybrid provider (free primary + premium fallback)
+ * - Auto-selection based on environment
+ *
+ * Usage:
+ *
+ * // Create single provider
+ * const provider = LLMProviderFactory.create({
+ *   type: 'ollama',
+ *   config: { model: 'deepseek-r1:7b' }
+ * });
+ *
+ * // Create hybrid provider
+ * const provider = LLMProviderFactory.createHybrid({
+ *   primary: { type: 'ollama', config: { model: 'deepseek-r1:7b' } },
+ *   fallback: { type: 'anthropic', config: { apiKey: '...' } },
+ *   useFallbackFor: ['vision']
+ * });
+ *
+ * // Auto-detect from environment
+ * const provider = LLMProviderFactory.createFromEnv();
+ */
+export class LLMProviderFactory {
+    /**
+     * Create a single LLM provider
+     */
+    static create(config) {
+        switch (config.type) {
+            case 'ollama':
+                return new OllamaProvider(config.config);
+            case 'anthropic':
+                return new AnthropicProvider(config.config);
+            case 'openai':
+                return new OpenAIProvider(config.config);
+            case 'custom':
+                return new CustomProvider(config.config);
+            default:
+                throw new Error(`Unknown provider type: ${config.type}`);
+        }
+    }
+    /**
+     * Create a hybrid provider (free primary + premium fallback)
+     *
+     * Use cases:
+     * - Most operations use free Ollama
+     * - Vision tasks fall back to Claude
+     * - Complex diagnosis falls back to Claude
+     *
+     * This gives best cost/quality balance:
+     * - ~$20/month instead of $80/month (75% cost reduction)
+     * - Still get premium quality for vision and complex tasks
+     */
+    static createHybrid(config) {
+        const primary = this.create(config.primary);
+        const fallback = this.create(config.fallback);
+        return new HybridProvider({
+            primary,
+            fallback,
+            useFallbackFor: config.useFallbackFor || ['vision'],
+        });
+    }
+    /**
+     * Auto-detect provider from environment variables
+     *
+     * Priority:
+     * 1. LLM_PROVIDER env var (ollama, anthropic, openai)
+     * 2. ANTHROPIC_API_KEY exists → Anthropic
+     * 3. OPENAI_API_KEY exists → OpenAI
+     * 4. Ollama running locally → Ollama
+     * 5. Error (no provider available)
+     */
+    static async createFromEnv() {
+        const providerType = process.env.LLM_PROVIDER?.toLowerCase();
+        if (providerType === 'ollama') {
+            return new OllamaProvider({
+                baseUrl: process.env.OLLAMA_BASE_URL || 'http://localhost:11434/v1',
+                model: process.env.OLLAMA_MODEL || 'deepseek-r1:7b',
+            });
+        }
+        if (providerType === 'openai') {
+            if (!process.env.OPENAI_API_KEY) {
+                throw new Error('OPENAI_API_KEY environment variable is required for OpenAI provider');
+            }
+            return new OpenAIProvider({
+                apiKey: process.env.OPENAI_API_KEY,
+                model: process.env.OPENAI_MODEL || 'gpt-4',
+                baseUrl: process.env.OPENAI_BASE_URL,
+                organizationId: process.env.OPENAI_ORG_ID,
+            });
+        }
+        if (providerType === 'anthropic') {
+            if (!process.env.ANTHROPIC_API_KEY) {
+                throw new Error('ANTHROPIC_API_KEY environment variable is required for Anthropic provider');
+            }
+            return new AnthropicProvider({
+                apiKey: process.env.ANTHROPIC_API_KEY,
+                model: process.env.ANTHROPIC_MODEL || 'claude-sonnet-4-5-20250929',
+            });
+        }
+        if (process.env.ANTHROPIC_API_KEY) {
+            return new AnthropicProvider({
+                apiKey: process.env.ANTHROPIC_API_KEY,
+                model: process.env.ANTHROPIC_MODEL || 'claude-sonnet-4-5-20250929',
+            });
+        }
+        if (process.env.OPENAI_API_KEY) {
+            return new OpenAIProvider({
+                apiKey: process.env.OPENAI_API_KEY,
+                model: process.env.OPENAI_MODEL || 'gpt-4',
+                baseUrl: process.env.OPENAI_BASE_URL,
+                organizationId: process.env.OPENAI_ORG_ID,
+            });
+        }
+        // Try Ollama as default
+        const ollama = new OllamaProvider({});
+        const health = await ollama.checkHealth();
+        if (health.healthy) {
+            // eslint-disable-next-line no-console
+            console.log('Auto-detected Ollama provider (free, local)');
+            return ollama;
+        }
+        throw new Error('No LLM provider available. Please either:\n' +
+            '1. Install Ollama: curl -fsSL https://ollama.com/install.sh | sh\n' +
+            '2. Set ANTHROPIC_API_KEY environment variable\n' +
+            '3. Set OPENAI_API_KEY environment variable\n' +
+            '4. Set LLM_PROVIDER environment variable');
+    }
+    /**
+     * Create provider from simple string format
+     *
+     * Examples:
+     * - "ollama" → Ollama with defaults
+     * - "ollama:deepseek-r1:14b" → Ollama with specific model
+     * - "anthropic" → Anthropic with env API key
+     * - "anthropic:claude-opus-4-5" → Anthropic with specific model
+     * - "openai" → OpenAI with env API key
+     * - "openai:gpt-4" → OpenAI with specific model
+     */
+    static createFromString(providerString) {
+        const [type, ...modelParts] = providerString.split(':');
+        const model = modelParts.join(':');
+        switch (type.toLowerCase()) {
+            case 'ollama':
+                return new OllamaProvider({
+                    model: model || 'deepseek-r1:7b',
+                });
+            case 'anthropic':
+                if (!process.env.ANTHROPIC_API_KEY) {
+                    throw new Error('ANTHROPIC_API_KEY environment variable is required');
+                }
+                return new AnthropicProvider({
+                    apiKey: process.env.ANTHROPIC_API_KEY,
+                    model: model || 'claude-sonnet-4-5-20250929',
+                });
+            case 'openai':
+                if (!process.env.OPENAI_API_KEY) {
+                    throw new Error('OPENAI_API_KEY environment variable is required');
+                }
+                return new OpenAIProvider({
+                    apiKey: process.env.OPENAI_API_KEY,
+                    model: model || 'gpt-4',
+                    baseUrl: process.env.OPENAI_BASE_URL,
+                    organizationId: process.env.OPENAI_ORG_ID,
+                });
+            default:
+                throw new Error(`Unknown provider type: ${type}`);
+        }
+    }
+}
+/**
+ * Hybrid Provider - Mix free and premium providers
+ *
+ * Strategy:
+ * - Use free provider (Ollama) for most operations (~80% of requests)
+ * - Fall back to premium (Claude) only when needed (~20% of requests)
+ *
+ * Cost savings example:
+ * - Pure Claude: $80/month
+ * - Pure Ollama: $0/month but no vision
+ * - Hybrid: $20/month (75% cost reduction, keeps vision)
+ */
+class HybridProvider {
+    constructor(config) {
+        this.name = 'hybrid';
+        this.capabilities = {
+            // Report combined capabilities
+            vision: true, // Fallback provides vision
+            streaming: true, // Both support streaming
+            maxTokens: 0, // Will be set in constructor
+            costPer1MInputTokens: 0, // Variable cost
+            costPer1MOutputTokens: 0, // Variable cost
+            supportsTools: true,
+            supportsPromptCaching: false,
+            typicalResponseTimeMs: 0, // Variable
+        };
+        this.primary = config.primary;
+        this.fallback = config.fallback;
+        this.useFallbackFor = new Set(config.useFallbackFor);
+        // Set combined capabilities
+        this.capabilities.maxTokens = Math.max(this.primary.capabilities.maxTokens, this.fallback.capabilities.maxTokens);
+        this.capabilities.typicalResponseTimeMs = this.primary.capabilities.typicalResponseTimeMs;
+    }
+    async generateText(prompt, options) {
+        // Use primary for text generation (free)
+        // eslint-disable-next-line no-console
+        console.log(`[Hybrid] Using ${this.primary.name} for text generation`);
+        return await this.primary.generateText(prompt, options);
+    }
+    async analyzeImage(images, prompt, options) {
+        // Check if vision is a fallback trigger
+        if (this.useFallbackFor.has('vision')) {
+            // Use fallback if primary doesn't support vision
+            if (!this.primary.capabilities.vision) {
+                // eslint-disable-next-line no-console
+                console.log(`[Hybrid] Using ${this.fallback.name} for vision analysis (primary doesn't support vision)`);
+                if (!this.fallback.analyzeImage) {
+                    throw new UnsupportedCapabilityError(this.name, 'vision');
+                }
+                return await this.fallback.analyzeImage(images, prompt, options);
+            }
+        }
+        // Try primary first
+        if (this.primary.analyzeImage) {
+            // eslint-disable-next-line no-console
+            console.log(`[Hybrid] Using ${this.primary.name} for vision analysis`);
+            return await this.primary.analyzeImage(images, prompt, options);
+        }
+        throw new UnsupportedCapabilityError(this.name, 'vision');
+    }
+    async *streamText(prompt, options) {
+        // Use primary for streaming (free)
+        if (!this.primary.streamText) {
+            throw new UnsupportedCapabilityError(this.primary.name, 'streaming');
+        }
+        // eslint-disable-next-line no-console
+        console.log(`[Hybrid] Using ${this.primary.name} for streaming`);
+        yield* this.primary.streamText(prompt, options);
+    }
+    getUsageStats() {
+        const primaryStats = this.primary.getUsageStats();
+        const fallbackStats = this.fallback.getUsageStats();
+        // Combine stats
+        return {
+            requestCount: primaryStats.requestCount + fallbackStats.requestCount,
+            totalInputTokens: primaryStats.totalInputTokens + fallbackStats.totalInputTokens,
+            totalOutputTokens: primaryStats.totalOutputTokens + fallbackStats.totalOutputTokens,
+            totalTokens: primaryStats.totalTokens + fallbackStats.totalTokens,
+            totalCost: primaryStats.totalCost + fallbackStats.totalCost,
+            averageResponseTimeMs: (primaryStats.averageResponseTimeMs * primaryStats.requestCount +
+                fallbackStats.averageResponseTimeMs * fallbackStats.requestCount) /
+                (primaryStats.requestCount + fallbackStats.requestCount),
+            failedRequests: primaryStats.failedRequests + fallbackStats.failedRequests,
+            startTime: new Date(Math.min(primaryStats.startTime.getTime(), fallbackStats.startTime.getTime())),
+            lastUpdated: new Date(Math.max(primaryStats.lastUpdated.getTime(), fallbackStats.lastUpdated.getTime())),
+        };
+    }
+    resetUsageStats() {
+        this.primary.resetUsageStats();
+        this.fallback.resetUsageStats();
+    }
+    /**
+     * Get breakdown of which provider was used for what
+     */
+    getProviderBreakdown() {
+        const primaryStats = this.primary.getUsageStats();
+        const fallbackStats = this.fallback.getUsageStats();
+        // Calculate what it would cost if we used only fallback
+        const totalRequests = primaryStats.requestCount + fallbackStats.requestCount;
+        const fallbackCostPerRequest = fallbackStats.requestCount > 0 ? fallbackStats.totalCost / fallbackStats.requestCount : 0;
+        const hypotheticalFullCost = totalRequests * fallbackCostPerRequest;
+        const actualCost = primaryStats.totalCost + fallbackStats.totalCost;
+        const savings = hypotheticalFullCost - actualCost;
+        const savingsPercent = hypotheticalFullCost > 0 ? (savings / hypotheticalFullCost) * 100 : 0;
+        return {
+            primary: {
+                name: this.primary.name,
+                stats: primaryStats,
+            },
+            fallback: {
+                name: this.fallback.name,
+                stats: fallbackStats,
+            },
+            costSavings: `$${savings.toFixed(2)} saved (${savingsPercent.toFixed(1)}% reduction)`,
+        };
+    }
+}
+/**
+ * Helper to validate provider setup
+ */
+export async function validateProviderSetup(provider) {
+    const capabilities = [];
+    if (provider.capabilities.vision) {
+        capabilities.push('✓ Vision support (screenshot comparison)');
+    }
+    else {
+        capabilities.push('✗ No vision support');
+    }
+    if (provider.capabilities.streaming) {
+        capabilities.push('✓ Streaming responses');
+    }
+    if (provider.capabilities.supportsTools) {
+        capabilities.push('✓ Function calling');
+    }
+    capabilities.push(`✓ ${provider.capabilities.maxTokens.toLocaleString()} token context window`);
+    capabilities.push(`✓ Cost: $${provider.capabilities.costPer1MOutputTokens}/1M tokens`);
+    try {
+        // Try a simple request
+        const response = await provider.generateText('Say "OK" if you can read this', {
+            maxTokens: 10,
+        });
+        return {
+            valid: response.text.length > 0,
+            message: `Provider '${provider.name}' is working correctly`,
+            capabilities,
+        };
+    }
+    catch (error) {
+        return {
+            valid: false,
+            message: `Provider '${provider.name}' validation failed: ${error instanceof Error ? error.message : String(error)}`,
+            capabilities,
+        };
+    }
+}

package/dist/esm/provider_interface.js

@@ -0,0 +1,23 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+/**
+ * Error thrown by LLM providers
+ */
+export class LLMProviderError extends Error {
+    constructor(message, provider, statusCode, cause) {
+        super(message);
+        this.provider = provider;
+        this.statusCode = statusCode;
+        this.cause = cause;
+        this.name = 'LLMProviderError';
+    }
+}
+/**
+ * Error thrown when a required capability is not supported
+ */
+export class UnsupportedCapabilityError extends LLMProviderError {
+    constructor(provider, capability) {
+        super(`Provider '${provider}' does not support capability: ${capability}`, provider);
+        this.name = 'UnsupportedCapabilityError';
+    }
+}

package/dist/esm/provider_utils.js

@@ -0,0 +1,96 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+/**
+ * SECURITY: Shared utility functions for all LLM providers
+ * Eliminates code duplication and ensures consistent error handling
+ */
+/**
+ * Pre-compiled regex patterns for API key validation
+ * Compiled once and reused to avoid repeated regex compilation
+ */
+export const API_KEY_PATTERNS = {
+    anthropic: /^sk-ant-[a-zA-Z0-9_\-]{20,}$/,
+    openai: /^sk-[a-zA-Z0-9_\-]{20,}$/,
+};
+/**
+ * SECURITY: Sanitize error messages to prevent information leakage
+ * Maps specific API errors to safe, user-friendly messages
+ * Prevents leaking stack traces, API keys, or internal details
+ */
+export function sanitizeErrorMessage(error, context) {
+    if (error instanceof Error) {
+        const msg = error.message.toLowerCase();
+        // Map specific API errors to safe messages
+        if (msg.includes('401') || msg.includes('authentication')) {
+            return `Authentication failed (${context})`;
+        }
+        if (msg.includes('429') || msg.includes('rate')) {
+            return `Rate limit exceeded (${context})`;
+        }
+        if (msg.includes('timeout') || msg.includes('etimedout')) {
+            return `Request timeout (${context})`;
+        }
+        if (msg.includes('network') || msg.includes('econnrefused')) {
+            return `Connection failed (${context})`;
+        }
+        if (msg.includes('enotfound') || msg.includes('getaddrinfo')) {
+            return `Host not found (${context})`;
+        }
+        // Don't leak stack traces, API keys, or internal details
+        return `Operation failed (${context})`;
+    }
+    return 'An unexpected error occurred';
+}
+/**
+ * Generic timeout wrapper for promises
+ * Rejects with timeout error if promise doesn't resolve in time
+ */
+export function withTimeout(promise, timeoutMs, context) {
+    if (!timeoutMs) {
+        return promise;
+    }
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => reject(new Error(`Request timeout (${context})`)), timeoutMs);
+        promise.then((value) => {
+            clearTimeout(timer);
+            resolve(value);
+        }, (error) => {
+            clearTimeout(timer);
+            reject(error);
+        });
+    });
+}
+/**
+ * Check if a hostname is localhost
+ * Used by URL validation to allow HTTP for local development
+ */
+export function isLocalhost(hostname) {
+    if (!hostname) {
+        return false;
+    }
+    return hostname === 'localhost' || hostname === '127.0.0.1' || hostname === '::1';
+}
+/**
+ * SECURITY: Validate and enforce HTTPS for remote URLs
+ * Allows HTTP only for localhost development
+ * Returns validation result with optional warning message
+ */
+export function validateAndSanitizeUrl(baseUrl) {
+    if (!baseUrl) {
+        return { valid: true };
+    }
+    try {
+        const url = new URL(baseUrl);
+        // For non-localhost URLs, require HTTPS
+        if (!isLocalhost(url.hostname) && url.protocol !== 'https:') {
+            return {
+                valid: false,
+                warning: `HTTPS required for remote URLs. Got: ${url.protocol}//${url.hostname}`,
+            };
+        }
+        return { valid: true, url: baseUrl };
+    }
+    catch {
+        return { valid: false };
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,31 @@
+/**
+ * LLM Provider Module
+ *
+ * Framework-agnostic library for working with Language Learning Models.
+ * Pluggable architecture supports multiple providers:
+ * - Anthropic Claude (premium, vision support)
+ * - Ollama (free, local)
+ * - OpenAI (official API)
+ * - Custom providers
+ *
+ * Switch between providers seamlessly without changing application code.
+ */
+export type { LLMProvider, GenerateOptions, ImageInput, LLMResponse, TokenUsage, ProviderCapabilities, ProviderUsageStats, ProviderConfig, AnthropicConfig, OllamaConfig, OpenAIConfig, CustomConfig, } from './provider_interface.js';
+export { LLMProviderError, UnsupportedCapabilityError } from './provider_interface.js';
+export { AnthropicProvider, checkAnthropicSetup } from './anthropic_provider.js';
+export { OllamaProvider, checkOllamaSetup } from './ollama_provider.js';
+export { OpenAIProvider, checkOpenAISetup } from './openai_provider.js';
+export { CustomProvider } from './custom_provider.js';
+export { LLMProviderFactory, validateProviderSetup } from './provider_factory.js';
+export type { HybridConfig } from './provider_factory.js';
+export { analyzeImpact, findGaps, recommendTests, handoffGeneratedTests, ingestTraceability, captureTraceability } from './api.js';
+export type { AgentApiOptions, AnalyzeResult, RecommendTestsResult, TraceabilityIngestApiOptions, TraceabilityCaptureApiOptions, } from './api.js';
+export { appendFeedbackAndRecompute, readCalibration } from './agent/feedback.js';
+export type { RecommendationFeedbackEntry, CalibrationSummary } from './agent/feedback.js';
+export { finalizeGeneratedTests } from './agent/handoff.js';
+export type { FinalizeGeneratedTestsOptions, FinalizeGeneratedTestsResult } from './agent/handoff.js';
+export { ingestTraceabilityInput } from './agent/traceability_ingest.js';
+export type { TraceabilityIngestOptions, TraceabilityIngestResult, TraceabilityIngestEntry } from './agent/traceability_ingest.js';
+export { captureTraceabilityInput } from './agent/traceability_capture.js';
+export type { TraceabilityCaptureOptions, TraceabilityCaptureResult } from './agent/traceability_capture.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;GAWG;AAGH,YAAY,EACR,WAAW,EACX,eAAe,EACf,UAAU,EACV,WAAW,EACX,UAAU,EACV,oBAAoB,EACpB,kBAAkB,EAClB,cAAc,EACd,eAAe,EACf,YAAY,EACZ,YAAY,EACZ,YAAY,GACf,MAAM,yBAAyB,CAAC;AAEjC,OAAO,EAAC,gBAAgB,EAAE,0BAA0B,EAAC,MAAM,yBAAyB,CAAC;AAGrF,OAAO,EAAC,iBAAiB,EAAE,mBAAmB,EAAC,MAAM,yBAAyB,CAAC;AAC/E,OAAO,EAAC,cAAc,EAAE,gBAAgB,EAAC,MAAM,sBAAsB,CAAC;AACtE,OAAO,EAAC,cAAc,EAAE,gBAAgB,EAAC,MAAM,sBAAsB,CAAC;AACtE,OAAO,EAAC,cAAc,EAAC,MAAM,sBAAsB,CAAC;AAGpD,OAAO,EAAC,kBAAkB,EAAE,qBAAqB,EAAC,MAAM,uBAAuB,CAAC;AAChF,YAAY,EAAC,YAAY,EAAC,MAAM,uBAAuB,CAAC;AAGxD,OAAO,EAAC,aAAa,EAAE,QAAQ,EAAE,cAAc,EAAE,qBAAqB,EAAE,kBAAkB,EAAE,mBAAmB,EAAC,MAAM,UAAU,CAAC;AACjI,YAAY,EACR,eAAe,EACf,aAAa,EACb,oBAAoB,EACpB,4BAA4B,EAC5B,6BAA6B,GAChC,MAAM,UAAU,CAAC;AAClB,OAAO,EAAC,0BAA0B,EAAE,eAAe,EAAC,MAAM,qBAAqB,CAAC;AAChF,YAAY,EAAC,2BAA2B,EAAE,kBAAkB,EAAC,MAAM,qBAAqB,CAAC;AACzF,OAAO,EAAC,sBAAsB,EAAC,MAAM,oBAAoB,CAAC;AAC1D,YAAY,EAAC,6BAA6B,EAAE,4BAA4B,EAAC,MAAM,oBAAoB,CAAC;AACpG,OAAO,EAAC,uBAAuB,EAAC,MAAM,gCAAgC,CAAC;AACvE,YAAY,EAAC,yBAAyB,EAAE,wBAAwB,EAAE,uBAAuB,EAAC,MAAM,gCAAgC,CAAC;AACjI,OAAO,EAAC,wBAAwB,EAAC,MAAM,iCAAiC,CAAC;AACzE,YAAY,EAAC,0BAA0B,EAAE,yBAAyB,EAAC,MAAM,iCAAiC,CAAC"}

package/dist/index.js

@@ -0,0 +1,41 @@
+"use strict";
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.captureTraceabilityInput = exports.ingestTraceabilityInput = exports.finalizeGeneratedTests = exports.readCalibration = exports.appendFeedbackAndRecompute = exports.captureTraceability = exports.ingestTraceability = exports.handoffGeneratedTests = exports.recommendTests = exports.findGaps = exports.analyzeImpact = exports.validateProviderSetup = exports.LLMProviderFactory = exports.CustomProvider = exports.checkOpenAISetup = exports.OpenAIProvider = exports.checkOllamaSetup = exports.OllamaProvider = exports.checkAnthropicSetup = exports.AnthropicProvider = exports.UnsupportedCapabilityError = exports.LLMProviderError = void 0;
+var provider_interface_js_1 = require("./provider_interface.js");
+Object.defineProperty(exports, "LLMProviderError", { enumerable: true, get: function () { return provider_interface_js_1.LLMProviderError; } });
+Object.defineProperty(exports, "UnsupportedCapabilityError", { enumerable: true, get: function () { return provider_interface_js_1.UnsupportedCapabilityError; } });
+// Provider implementations
+var anthropic_provider_js_1 = require("./anthropic_provider.js");
+Object.defineProperty(exports, "AnthropicProvider", { enumerable: true, get: function () { return anthropic_provider_js_1.AnthropicProvider; } });
+Object.defineProperty(exports, "checkAnthropicSetup", { enumerable: true, get: function () { return anthropic_provider_js_1.checkAnthropicSetup; } });
+var ollama_provider_js_1 = require("./ollama_provider.js");
+Object.defineProperty(exports, "OllamaProvider", { enumerable: true, get: function () { return ollama_provider_js_1.OllamaProvider; } });
+Object.defineProperty(exports, "checkOllamaSetup", { enumerable: true, get: function () { return ollama_provider_js_1.checkOllamaSetup; } });
+var openai_provider_js_1 = require("./openai_provider.js");
+Object.defineProperty(exports, "OpenAIProvider", { enumerable: true, get: function () { return openai_provider_js_1.OpenAIProvider; } });
+Object.defineProperty(exports, "checkOpenAISetup", { enumerable: true, get: function () { return openai_provider_js_1.checkOpenAISetup; } });
+var custom_provider_js_1 = require("./custom_provider.js");
+Object.defineProperty(exports, "CustomProvider", { enumerable: true, get: function () { return custom_provider_js_1.CustomProvider; } });
+// Factory
+var provider_factory_js_1 = require("./provider_factory.js");
+Object.defineProperty(exports, "LLMProviderFactory", { enumerable: true, get: function () { return provider_factory_js_1.LLMProviderFactory; } });
+Object.defineProperty(exports, "validateProviderSetup", { enumerable: true, get: function () { return provider_factory_js_1.validateProviderSetup; } });
+// Agent API (impact, gap, suggest, traceability ingest)
+var api_js_1 = require("./api.js");
+Object.defineProperty(exports, "analyzeImpact", { enumerable: true, get: function () { return api_js_1.analyzeImpact; } });
+Object.defineProperty(exports, "findGaps", { enumerable: true, get: function () { return api_js_1.findGaps; } });
+Object.defineProperty(exports, "recommendTests", { enumerable: true, get: function () { return api_js_1.recommendTests; } });
+Object.defineProperty(exports, "handoffGeneratedTests", { enumerable: true, get: function () { return api_js_1.handoffGeneratedTests; } });
+Object.defineProperty(exports, "ingestTraceability", { enumerable: true, get: function () { return api_js_1.ingestTraceability; } });
+Object.defineProperty(exports, "captureTraceability", { enumerable: true, get: function () { return api_js_1.captureTraceability; } });
+var feedback_js_1 = require("./agent/feedback.js");
+Object.defineProperty(exports, "appendFeedbackAndRecompute", { enumerable: true, get: function () { return feedback_js_1.appendFeedbackAndRecompute; } });
+Object.defineProperty(exports, "readCalibration", { enumerable: true, get: function () { return feedback_js_1.readCalibration; } });
+var handoff_js_1 = require("./agent/handoff.js");
+Object.defineProperty(exports, "finalizeGeneratedTests", { enumerable: true, get: function () { return handoff_js_1.finalizeGeneratedTests; } });
+var traceability_ingest_js_1 = require("./agent/traceability_ingest.js");
+Object.defineProperty(exports, "ingestTraceabilityInput", { enumerable: true, get: function () { return traceability_ingest_js_1.ingestTraceabilityInput; } });
+var traceability_capture_js_1 = require("./agent/traceability_capture.js");
+Object.defineProperty(exports, "captureTraceabilityInput", { enumerable: true, get: function () { return traceability_capture_js_1.captureTraceabilityInput; } });

package/dist/logger.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Simple structured logging system
+ * Replaces 18 console.log statements with configurable logging
+ * Environment variable: LOG_LEVEL (ERROR, WARN, INFO, DEBUG)
+ */
+export declare enum LogLevel {
+    ERROR = 0,
+    WARN = 1,
+    INFO = 2,
+    DEBUG = 3
+}
+export declare class Logger {
+    private level;
+    constructor(minLevel?: LogLevel);
+    error(message: string, context?: Record<string, unknown>): void;
+    warn(message: string, context?: Record<string, unknown>): void;
+    info(message: string, context?: Record<string, unknown>): void;
+    debug(message: string, context?: Record<string, unknown>): void;
+    setLevel(level: LogLevel): void;
+    private log;
+}
+export declare const logger: Logger;
+//# sourceMappingURL=logger.d.ts.map

package/dist/logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../src/logger.ts"],"names":[],"mappings":"AAGA;;;;GAIG;AAEH,oBAAY,QAAQ;IAChB,KAAK,IAAI;IACT,IAAI,IAAI;IACR,IAAI,IAAI;IACR,KAAK,IAAI;CACZ;AAqCD,qBAAa,MAAM;IACf,OAAO,CAAC,KAAK,CAAW;gBAEZ,QAAQ,CAAC,EAAE,QAAQ;IAI/B,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI;IAM/D,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI;IAM9D,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI;IAM9D,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI;IAM/D,QAAQ,CAAC,KAAK,EAAE,QAAQ,GAAG,IAAI;IAI/B,OAAO,CAAC,GAAG;CAYd;AAGD,eAAO,MAAM,MAAM,QAAe,CAAC"}

package/dist/logger.js

@@ -0,0 +1,93 @@
+"use strict";
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logger = exports.Logger = exports.LogLevel = void 0;
+/**
+ * Simple structured logging system
+ * Replaces 18 console.log statements with configurable logging
+ * Environment variable: LOG_LEVEL (ERROR, WARN, INFO, DEBUG)
+ */
+var LogLevel;
+(function (LogLevel) {
+    LogLevel[LogLevel["ERROR"] = 0] = "ERROR";
+    LogLevel[LogLevel["WARN"] = 1] = "WARN";
+    LogLevel[LogLevel["INFO"] = 2] = "INFO";
+    LogLevel[LogLevel["DEBUG"] = 3] = "DEBUG";
+})(LogLevel || (exports.LogLevel = LogLevel = {}));
+/**
+ * Get log level from environment variable
+ */
+function getLogLevelFromEnv() {
+    const level = process.env.LOG_LEVEL?.toUpperCase() || 'INFO';
+    switch (level) {
+        case 'ERROR':
+            return LogLevel.ERROR;
+        case 'WARN':
+            return LogLevel.WARN;
+        case 'INFO':
+            return LogLevel.INFO;
+        case 'DEBUG':
+            return LogLevel.DEBUG;
+        default:
+            return LogLevel.INFO;
+    }
+}
+/**
+ * Convert log level to string
+ */
+function logLevelToString(level) {
+    switch (level) {
+        case LogLevel.ERROR:
+            return 'ERROR';
+        case LogLevel.WARN:
+            return 'WARN';
+        case LogLevel.INFO:
+            return 'INFO';
+        case LogLevel.DEBUG:
+            return 'DEBUG';
+    }
+}
+class Logger {
+    constructor(minLevel) {
+        this.level = minLevel ?? getLogLevelFromEnv();
+    }
+    error(message, context) {
+        if (this.level >= LogLevel.ERROR) {
+            this.log(LogLevel.ERROR, message, context);
+        }
+    }
+    warn(message, context) {
+        if (this.level >= LogLevel.WARN) {
+            this.log(LogLevel.WARN, message, context);
+        }
+    }
+    info(message, context) {
+        if (this.level >= LogLevel.INFO) {
+            this.log(LogLevel.INFO, message, context);
+        }
+    }
+    debug(message, context) {
+        if (this.level >= LogLevel.DEBUG) {
+            this.log(LogLevel.DEBUG, message, context);
+        }
+    }
+    setLevel(level) {
+        this.level = level;
+    }
+    log(level, message, context) {
+        const timestamp = new Date().toISOString();
+        const levelStr = logLevelToString(level);
+        const contextStr = context ? ` ${JSON.stringify(context)}` : '';
+        const output = `[${timestamp}] [${levelStr}] ${message}${contextStr}`;
+        if (level <= LogLevel.WARN) {
+            console.error(output);
+        }
+        else {
+            console.log(output);
+        }
+    }
+}
+exports.Logger = Logger;
+// Global logger instance
+exports.logger = new Logger();