@yasserkhanorg/impact-gate 2.0.0

package/dist/esm/metrics/prometheus.js

@@ -0,0 +1,149 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+const DURATION_BUCKETS = [0.1, 0.5, 1, 2, 5, 10, 30, 60, 120, 300];
+export class PrometheusMetrics {
+    constructor() {
+        this.counters = [];
+        this.gauges = [];
+        this.histograms = [];
+    }
+    /**
+     * Record an LLM request.
+     */
+    recordLLMRequest(provider, agent, durationMs, costUSD, tokens) {
+        this.incrementCounter('e2e_agents_llm_requests_total', 'Total LLM requests', { provider, agent });
+        this.incrementCounter('e2e_agents_llm_tokens_total', 'Total tokens consumed', { provider, agent }, tokens);
+        this.incrementCounter('e2e_agents_llm_cost_usd_total', 'Total LLM cost in USD', { provider, agent }, costUSD);
+        this.observeHistogram('e2e_agents_llm_request_duration_seconds', 'LLM request duration', { provider, agent }, durationMs / 1000);
+    }
+    /**
+     * Record a crew workflow run.
+     */
+    recordCrewRun(workflow, families, durationMs, costUSD) {
+        this.incrementCounter('e2e_agents_crew_runs_total', 'Total crew workflow runs', { workflow });
+        this.incrementCounter('e2e_agents_crew_families_processed_total', 'Total families processed', { workflow }, families);
+        this.incrementCounter('e2e_agents_crew_cost_usd_total', 'Total crew cost in USD', { workflow }, costUSD);
+        this.observeHistogram('e2e_agents_crew_duration_seconds', 'Crew workflow duration', { workflow }, durationMs / 1000);
+    }
+    /**
+     * Record a budget check event.
+     */
+    recordBudgetCheck(exceeded, currentUSD, limitUSD) {
+        this.incrementCounter('e2e_agents_budget_checks_total', 'Total budget checks', { exceeded: String(exceeded) });
+        this.setGauge('e2e_agents_budget_used_usd', 'Current budget usage in USD', {}, currentUSD);
+        this.setGauge('e2e_agents_budget_limit_usd', 'Budget limit in USD', {}, limitUSD);
+    }
+    /**
+     * Record a circuit breaker state change.
+     */
+    recordCircuitBreakerState(state) {
+        this.setGauge('e2e_agents_circuit_breaker_state', 'Circuit breaker state (0=closed, 1=open, 2=half-open)', {}, state === 'closed' ? 0 : state === 'open' ? 1 : 2);
+    }
+    /**
+     * Record a cache hit or miss.
+     */
+    recordCacheResult(hit, agent) {
+        this.incrementCounter('e2e_agents_cache_lookups_total', 'Total cache lookups', { result: hit ? 'hit' : 'miss', agent });
+    }
+    /**
+     * Export all metrics in Prometheus text exposition format.
+     */
+    export() {
+        const lines = [];
+        const seenHelp = new Set();
+        // Export counters
+        for (const counter of this.counters) {
+            if (!seenHelp.has(counter.name)) {
+                lines.push(`# HELP ${counter.name} ${counter.help}`);
+                lines.push(`# TYPE ${counter.name} counter`);
+                seenHelp.add(counter.name);
+            }
+            const labelStr = formatLabels(counter.labels);
+            lines.push(`${counter.name}${labelStr} ${counter.value}`);
+        }
+        // Export gauges
+        for (const gauge of this.gauges) {
+            if (!seenHelp.has(gauge.name)) {
+                lines.push(`# HELP ${gauge.name} ${gauge.help}`);
+                lines.push(`# TYPE ${gauge.name} gauge`);
+                seenHelp.add(gauge.name);
+            }
+            const labelStr = formatLabels(gauge.labels);
+            lines.push(`${gauge.name}${labelStr} ${gauge.value}`);
+        }
+        // Export histograms
+        for (const hist of this.histograms) {
+            if (!seenHelp.has(hist.name)) {
+                lines.push(`# HELP ${hist.name} ${hist.help}`);
+                lines.push(`# TYPE ${hist.name} histogram`);
+                seenHelp.add(hist.name);
+            }
+            const labelStr = formatLabels(hist.labels);
+            let cumulative = 0;
+            for (const bucket of DURATION_BUCKETS) {
+                cumulative += hist.buckets.get(bucket) || 0;
+                lines.push(`${hist.name}_bucket${formatLabels({ ...hist.labels, le: String(bucket) })} ${cumulative}`);
+            }
+            lines.push(`${hist.name}_bucket${formatLabels({ ...hist.labels, le: '+Inf' })} ${hist.count}`);
+            lines.push(`${hist.name}_sum${labelStr} ${hist.sum}`);
+            lines.push(`${hist.name}_count${labelStr} ${hist.count}`);
+        }
+        return lines.join('\n') + '\n';
+    }
+    /**
+     * Reset all metrics to zero.
+     */
+    reset() {
+        this.counters = [];
+        this.gauges = [];
+        this.histograms = [];
+    }
+    incrementCounter(name, help, labels, value = 1) {
+        const existing = this.counters.find((c) => c.name === name && labelsMatch(c.labels, labels));
+        if (existing) {
+            existing.value += value;
+        }
+        else {
+            this.counters.push({ name, help, labels, value });
+        }
+    }
+    setGauge(name, help, labels, value) {
+        const existing = this.gauges.find((c) => c.name === name && labelsMatch(c.labels, labels));
+        if (existing) {
+            existing.value = value;
+        }
+        else {
+            this.gauges.push({ name, help, labels, value });
+        }
+    }
+    observeHistogram(name, help, labels, value) {
+        let existing = this.histograms.find((h) => h.name === name && labelsMatch(h.labels, labels));
+        if (!existing) {
+            existing = { name, help, labels, sum: 0, count: 0, buckets: new Map() };
+            this.histograms.push(existing);
+        }
+        existing.sum += value;
+        existing.count++;
+        for (const bucket of DURATION_BUCKETS) {
+            if (value <= bucket) {
+                existing.buckets.set(bucket, (existing.buckets.get(bucket) || 0) + 1);
+            }
+        }
+    }
+}
+function escapeLabel(v) {
+    return v.replace(/\\/g, '\\\\').replace(/"/g, '\\"').replace(/\n/g, '\\n');
+}
+function formatLabels(labels) {
+    const entries = Object.entries(labels);
+    if (entries.length === 0)
+        return '';
+    return `{${entries.map(([k, v]) => `${k}="${escapeLabel(v)}"`).join(',')}}`;
+}
+function labelsMatch(a, b) {
+    const keysA = Object.keys(a);
+    const keysB = Object.keys(b);
+    if (keysA.length !== keysB.length)
+        return false;
+    return keysA.every((k) => a[k] === b[k]);
+}

package/dist/esm/model_router.js

@@ -0,0 +1,59 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+const AGENT_COMPLEXITY = {
+    'impact-analyst': 'classification',
+    'coverage-evaluator': 'classification',
+    'cross-impact': 'extraction',
+    'regression-advisor': 'extraction',
+    'strategist': 'classification',
+    'test-designer': 'generation',
+    'generator': 'generation',
+    'executor': 'generation',
+    'healer': 'reasoning',
+    'explorer': 'reasoning',
+};
+const DEFAULT_MODELS = {
+    anthropic: {
+        classification: 'claude-haiku-4-5-20251001',
+        extraction: 'claude-haiku-4-5-20251001',
+        generation: 'claude-sonnet-4-5-20250514',
+        reasoning: 'claude-sonnet-4-5-20250514',
+    },
+    openai: {
+        classification: 'gpt-4o-mini',
+        extraction: 'gpt-4o-mini',
+        generation: 'gpt-4o',
+        reasoning: 'gpt-4o',
+    },
+};
+export class ModelRouter {
+    constructor(providerType, overrides) {
+        this.providerType = providerType;
+        this.overrides = overrides || {};
+    }
+    /**
+     * Get the recommended model for a given agent role.
+     * Returns undefined if no routing recommendation (use provider default).
+     */
+    getModel(role) {
+        const complexity = AGENT_COMPLEXITY[role];
+        if (!complexity)
+            return undefined;
+        // Check user overrides first
+        const override = this.overrides[complexity];
+        if (override)
+            return override;
+        // Check provider defaults
+        const defaults = DEFAULT_MODELS[this.providerType];
+        if (defaults)
+            return defaults[complexity];
+        // No recommendation — use provider's default model
+        return undefined;
+    }
+    /**
+     * Get the task complexity for an agent role.
+     */
+    getComplexity(role) {
+        return AGENT_COMPLEXITY[role] || 'generation';
+    }
+}

package/dist/esm/ollama_provider.js

@@ -0,0 +1,301 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+import OpenAI from 'openai';
+import { LLMProviderError, UnsupportedCapabilityError } from './provider_interface.js';
+import { sanitizeErrorMessage, withTimeout } from './provider_utils.js';
+import { BaseProvider } from './base_provider.js';
+import { logger } from './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.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.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)
+ */
+export class OllamaProvider extends 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) {
+            logger.warn(urlValidation.warning);
+        }
+        // SECURITY: Validate timeout
+        const timeout = validateTimeout(config.timeout);
+        // Ollama uses OpenAI-compatible API
+        this.client = new OpenAI({
+            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) {
+        this.checkBudget();
+        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 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 LLMProviderError(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 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 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 LLMProviderError(sanitizeErrorMessage(error, 'streamText'), this.name, undefined, error);
+        }
+    }
+    /**
+     * Check if Ollama is running and accessible
+     */
+    async checkHealth() {
+        try {
+            // Try a simple request
+            await 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: ${sanitizeErrorMessage(error, 'health check')}`,
+            };
+        }
+    }
+    /**
+     * List available models in Ollama
+     */
+    async listModels() {
+        try {
+            const response = await withTimeout(this.client.models.list(), 5000, 'listModels');
+            return response.data.map((model) => model.id);
+        }
+        catch (error) {
+            throw new LLMProviderError(sanitizeErrorMessage(error, 'listModels'), this.name, undefined, error);
+        }
+    }
+}
+/**
+ * Helper function to check if Ollama is installed and suggest setup
+ */
+export 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(),
+        };
+    }
+}