@yasserkhanorg/impact-gate 2.0.0

package/dist/esm/custom_provider.js

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

package/dist/esm/engine/ai_enrichment.js

@@ -0,0 +1,264 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+import { formatDiffsForPrompt } from './diff_loader.js';
+const MAX_SPEC_LIST = 50;
+function normalizePriority(value) {
+    if (value === 'P0' || value === 'P1' || value === 'P2') {
+        return value;
+    }
+    return 'P2';
+}
+const MAX_SCENARIOS_PER_SPEC = 20;
+function buildPrompt(options) {
+    const { deterministicImpact, diffs, specList, specDetails, manifestSummary } = options;
+    const { changedFiles, impactedFeatures, unboundFiles } = deterministicImpact;
+    const lines = [];
+    // Optional manifest summary
+    if (manifestSummary) {
+        lines.push('## Application Overview');
+        lines.push(manifestSummary);
+        lines.push('');
+    }
+    // Changed files section
+    lines.push(`## Changed Files (${changedFiles.length} total)`);
+    for (const f of changedFiles) {
+        lines.push(`- ${f}`);
+    }
+    lines.push('');
+    // Diffs section
+    lines.push('## Code Diffs');
+    lines.push(formatDiffsForPrompt(diffs));
+    lines.push('');
+    // Deterministic features summary
+    lines.push('## Deterministic Impact Analysis');
+    lines.push('The following features/flows have been deterministically identified as impacted:');
+    lines.push('');
+    for (const feature of impactedFeatures) {
+        const featureIdPart = feature.featureId ? `featureId=${feature.featureId}` : 'featureId=undefined';
+        const specCount = feature.playwrightSpecs.length + feature.cypressSpecs.length;
+        const specList2 = [...feature.playwrightSpecs, ...feature.cypressSpecs];
+        const specsDisplay = specList2.length > 0 ? specList2.join(', ') : 'none';
+        const userFlowsDisplay = feature.userFlows.length > 0 ? ` userFlows=[${feature.userFlows.slice(0, 5).join(', ')}]` : '';
+        lines.push(`- familyId=${feature.familyId} ${featureIdPart} (${feature.priority}): ${specCount} specs, coverage=${feature.coverageStatus}, specs=[${specsDisplay}]${userFlowsDisplay}`);
+    }
+    lines.push('');
+    // Unbound files
+    if (unboundFiles.length > 0) {
+        lines.push('## Unbound Files (not mapped to any feature)');
+        for (const f of unboundFiles) {
+            lines.push(`- ${f}`);
+        }
+        lines.push('');
+    }
+    // Spec coverage with scenario titles (when available) or bare file paths
+    if (specDetails && specDetails.length > 0) {
+        const cappedDetails = specDetails.slice(0, MAX_SPEC_LIST);
+        const totalScenarios = cappedDetails.reduce((sum, s) => sum + s.scenarios.length, 0);
+        lines.push(`## Existing Test Coverage (${cappedDetails.length} specs, ${totalScenarios} scenarios)`);
+        lines.push('Use this to avoid suggesting scenarios that already exist.');
+        lines.push('');
+        for (const spec of cappedDetails) {
+            lines.push(`- ${spec.file}`);
+            const cappedScenarios = spec.scenarios.slice(0, MAX_SCENARIOS_PER_SPEC);
+            for (const scenario of cappedScenarios) {
+                lines.push(`  • "${scenario}"`);
+            }
+            if (spec.scenarios.length > MAX_SCENARIOS_PER_SPEC) {
+                lines.push(`  • ... and ${spec.scenarios.length - MAX_SCENARIOS_PER_SPEC} more`);
+            }
+        }
+        lines.push('');
+    }
+    else if (specList.length > 0) {
+        const cappedSpecs = specList.slice(0, MAX_SPEC_LIST);
+        lines.push(`## Available Test Specs (showing ${cappedSpecs.length} of ${specList.length})`);
+        for (const s of cappedSpecs) {
+            lines.push(`- ${s}`);
+        }
+        lines.push('');
+    }
+    // Instructions
+    lines.push('## Instructions');
+    lines.push('Return ONLY valid JSON (no markdown fences, no explanation) in this exact shape:');
+    lines.push('');
+    lines.push('Rules for coveredBy:');
+    lines.push('- Reference SPECIFIC scenario titles from the Existing Test Coverage section when possible.');
+    lines.push('- Format: "file.spec.ts → scenario title"');
+    lines.push('');
+    lines.push('Rules for missingScenarios:');
+    lines.push('- Cross-reference the scenario titles in Existing Test Coverage. If a scenario already exists that covers the behavior, do NOT suggest it — instead list it in coveredBy.');
+    lines.push('- For coverage=uncovered: list ONLY scenarios that test the SPECIFIC behavior change in this diff — NOT generic scenarios for the entire feature. A permission check fix needs permission-denial test scenarios, not general CRUD tests.');
+    lines.push('- For coverage=covered or coverage=partial: ONLY list scenarios introduced by THIS diff that have NO matching scenario in existing coverage. If the diff adds no new user-visible behavior, return []. Do not pad with generic scenarios.');
+    lines.push('- If the source code diff is trivial (single-line fix, type change, field rename, or the PR is primarily adding tests), return missingScenarios=[] and explain in reasons that no new user-visible behavior was introduced.');
+    lines.push('');
+    lines.push(JSON.stringify({
+        impactedFlows: [
+            {
+                id: '<featureId or familyId from the deterministic list above>',
+                name: '<human-readable flow name>',
+                priority: 'P0|P1|P2',
+                reasons: [
+                    '<EXACTLY 1-2 sentences explaining what SPECIFICALLY changed for users in THIS diff. Reference the actual behavior modification — NOT a general description of what the feature does. BAD: "Users can create and view posts." GOOD: "Users editing posts now require create_post permission, which may block edits for restricted roles.">',
+                ],
+                coveredBy: ['<spec file paths that cover this flow>'],
+                missingScenarios: ['<concrete scenario title for a NEW or CHANGED behavior in THIS diff. Must be SPECIFIC to the code change — never generic feature tests. BAD: "User can create a new post". GOOD: "User without create_post permission sees error when editing a post". If the diff is trivial (typo, field rename, test-only) return [].>'],
+            },
+        ],
+        unboundFileAnalysis: [
+            {
+                file: '<path to unbound file>',
+                likelyFeature: '<best guess at which feature/family this affects>',
+                reason: '<why you think this file belongs to that feature>',
+            },
+        ],
+    }, null, 2));
+    return lines.join('\n');
+}
+function extractJSON(text) {
+    // Try markdown fenced block first
+    const fenced = text.match(/```(?:json)?\s*([\s\S]*?)```/i);
+    const candidates = fenced ? [fenced[1], text] : [text];
+    for (const candidate of candidates) {
+        const start = candidate.indexOf('{');
+        const end = candidate.lastIndexOf('}');
+        if (start >= 0 && end > start) {
+            return candidate.slice(start, end + 1).trim();
+        }
+    }
+    // Fallback: return trimmed text
+    return text.trim();
+}
+function toEnrichedFeature(det, aiFlow) {
+    return {
+        familyId: det.familyId,
+        featureId: det.featureId,
+        priority: normalizePriority(det.priority),
+        changedFiles: det.changedFiles,
+        coverageStatus: det.coverageStatus,
+        playwrightSpecs: det.playwrightSpecs,
+        cypressSpecs: det.cypressSpecs,
+        userFlows: det.userFlows,
+        aiReasons: aiFlow?.reasons ?? [],
+        aiMissingScenarios: aiFlow?.missingScenarios ?? [],
+        aiCoveredBy: aiFlow?.coveredBy ?? [],
+    };
+}
+/**
+ * Enriches a deterministic impact result with AI-generated reasons,
+ * missing test scenarios, and coverage insights.
+ */
+export async function enrichImpactWithAI(options) {
+    const { deterministicImpact, provider } = options;
+    const warnings = [];
+    let tokenUsage = { input: 0, output: 0 };
+    const prompt = buildPrompt(options);
+    let aiResponse = null;
+    let unboundFileInsights = [];
+    try {
+        const response = await provider.generateText(prompt, {
+            maxTokens: 4000,
+            temperature: 0,
+            timeout: 45000,
+            systemPrompt: 'You are an expert E2E test analyst. Return only valid JSON.',
+        });
+        tokenUsage = {
+            input: response.usage?.inputTokens ?? 0,
+            output: response.usage?.outputTokens ?? 0,
+        };
+        const rawJSON = extractJSON(response.text);
+        try {
+            const parsed = JSON.parse(rawJSON);
+            // Validate that impactedFlows is an array
+            if (!Array.isArray(parsed.impactedFlows)) {
+                warnings.push('AI response parsed but impactedFlows is not an array; returning empty enrichedFeatures');
+                return {
+                    enrichedFeatures: [],
+                    unboundFileInsights: [],
+                    warnings,
+                    providerName: provider.name,
+                    tokenUsage,
+                };
+            }
+            aiResponse = parsed;
+            unboundFileInsights = (parsed.unboundFileAnalysis ?? []).map((item) => ({
+                file: item.file,
+                likelyFeature: item.likelyFeature,
+                reason: item.reason,
+            }));
+        }
+        catch (parseErr) {
+            warnings.push(`Failed to parse AI response as JSON: ${parseErr instanceof Error ? parseErr.message : String(parseErr)}`);
+            return {
+                enrichedFeatures: [],
+                unboundFileInsights: [],
+                warnings,
+                providerName: provider.name,
+                tokenUsage,
+            };
+        }
+    }
+    catch (err) {
+        warnings.push(`AI provider error: ${err instanceof Error ? err.message : String(err)}`);
+        return {
+            enrichedFeatures: [],
+            unboundFileInsights: [],
+            warnings,
+            providerName: provider.name,
+            tokenUsage,
+        };
+    }
+    // Build a map of AI flows by id (featureId or familyId)
+    const aiFlowMap = new Map();
+    if (aiResponse?.impactedFlows) {
+        for (const flow of aiResponse.impactedFlows) {
+            aiFlowMap.set(flow.id, flow);
+        }
+    }
+    // Build a set of all deterministic ids for unmatched-flow detection
+    const deterministicIds = new Set();
+    for (const det of deterministicImpact.impactedFeatures) {
+        if (det.featureId) {
+            deterministicIds.add(det.featureId);
+        }
+        deterministicIds.add(det.familyId);
+    }
+    // Warn on AI flows that don't match any deterministic feature
+    for (const flow of aiFlowMap.values()) {
+        if (!deterministicIds.has(flow.id)) {
+            warnings.push(`AI returned flow '${flow.id}' with no matching deterministic feature (using as-is)`);
+        }
+    }
+    // Merge deterministic features with AI data
+    const enrichedFeatures = deterministicImpact.impactedFeatures.map((det) => {
+        // Match by featureId first, then by familyId
+        const aiFlow = det.featureId
+            ? (aiFlowMap.get(det.featureId) ?? aiFlowMap.get(det.familyId))
+            : aiFlowMap.get(det.familyId);
+        return toEnrichedFeature(det, aiFlow);
+    });
+    // Include AI flows that had no deterministic match (as-is, with empty deterministic fields)
+    for (const flow of aiFlowMap.values()) {
+        if (!deterministicIds.has(flow.id)) {
+            enrichedFeatures.push({
+                familyId: flow.id,
+                featureId: undefined,
+                priority: normalizePriority(flow.priority),
+                changedFiles: [],
+                coverageStatus: 'uncovered',
+                playwrightSpecs: [],
+                cypressSpecs: [],
+                userFlows: [],
+                aiReasons: flow.reasons ?? [],
+                aiMissingScenarios: flow.missingScenarios ?? [],
+                aiCoveredBy: flow.coveredBy ?? [],
+            });
+        }
+    }
+    return {
+        enrichedFeatures,
+        unboundFileInsights,
+        warnings,
+        providerName: provider.name,
+        tokenUsage,
+    };
+}

package/dist/esm/engine/diff_loader.js

@@ -0,0 +1,59 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+import { runGitRaw } from '../agent/git.js';
+const MAX_DIFF_CHARS = 8000;
+const MAX_TOTAL_CHARS = 60000;
+const TRUNCATION_NOTICE = '\n... (diff truncated)';
+/**
+ * Loads git diffs for the given changed files relative to the given since ref.
+ * Uses `git merge-base` to find the accurate base ref first.
+ * Individual diffs are truncated at 8000 chars and total output is capped at 60000 chars.
+ */
+export function loadDiffs(appRoot, since, changedFiles) {
+    const result = new Map();
+    if (changedFiles.length === 0) {
+        return result;
+    }
+    // Try to get accurate merge base
+    let baseRef = since;
+    const mergeBaseOutput = runGitRaw(['merge-base', since, 'HEAD'], appRoot);
+    if (mergeBaseOutput) {
+        const candidate = mergeBaseOutput
+            .split('\n')
+            .map((line) => line.trim())
+            .find(Boolean);
+        if (candidate) {
+            baseRef = candidate;
+        }
+    }
+    let totalChars = 0;
+    for (const file of changedFiles) {
+        if (totalChars >= MAX_TOTAL_CHARS) {
+            break;
+        }
+        const diffOutput = runGitRaw(['diff', `${baseRef}..HEAD`, '--', file], appRoot);
+        if (diffOutput === null) {
+            continue;
+        }
+        let diff = diffOutput;
+        if (diff.length > MAX_DIFF_CHARS) {
+            diff = diff.slice(0, MAX_DIFF_CHARS) + TRUNCATION_NOTICE;
+        }
+        result.set(file, diff);
+        totalChars += diff.length;
+    }
+    return result;
+}
+/**
+ * Formats a diffs map into a human-readable string suitable for an AI prompt.
+ */
+export function formatDiffsForPrompt(diffs) {
+    if (diffs.size === 0) {
+        return 'No diffs available.';
+    }
+    const sections = [];
+    for (const [file, diff] of diffs) {
+        sections.push(`--- ${file} ---\n${diff}`);
+    }
+    return sections.join('\n\n');
+}