@yasserkhanorg/impact-gate 2.0.0

package/dist/esm/agents/test-designer.js

@@ -0,0 +1,107 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+/**
+ * Test Designer Agent — designs structured test cases across 9 categories.
+ * Takes strategist output + API surface + existing specs and produces TestDesign[].
+ */
+import { getCrewProvider } from '../crew/provider.js';
+import { getSpecsForFamily } from '../knowledge/spec_index.js';
+import { buildTestDesignerPrompt, parseTestDesignerResponse } from '../prompts/test-designer.js';
+const MAX_TEST_CASES_PER_FLOW = 15;
+const VALID_TYPES = new Set([
+    'happy-path', 'edge-case', 'boundary', 'negative',
+    'state-transition', 'race-condition', 'permission', 'accessibility', 'performance',
+]);
+export class TestDesignerAgent {
+    constructor() {
+        this.role = 'test-designer';
+    }
+    async execute(_task, ctx) {
+        const warnings = [];
+        if (ctx.strategyEntries.length === 0) {
+            warnings.push('Test designer: no strategy entries to design tests for.');
+            return { role: this.role, status: 'partial', output: [], warnings };
+        }
+        // Only design tests for flows with full-test or smoke-test approach
+        const designable = ctx.strategyEntries.filter((s) => s.approach === 'full-test' || s.approach === 'smoke-test');
+        if (designable.length === 0) {
+            warnings.push('Test designer: all flows are skip or manual-review.');
+            return { role: this.role, status: 'partial', output: [], warnings };
+        }
+        let provider;
+        try {
+            provider = await getCrewProvider(ctx.providerOverride, ctx.budgetUSD, {
+                agentRole: 'test-designer',
+                modelRoutingProviderType: ctx.modelRoutingProviderType,
+                modelRoutingOverrides: ctx.modelRoutingOverrides,
+                budgetLedger: ctx.budgetLedger,
+            });
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            warnings.push(`Test designer provider unavailable: ${message}`);
+            return { role: this.role, status: 'failed', output: [], warnings };
+        }
+        const designs = [];
+        for (const strategy of designable) {
+            const flow = ctx.impactedFlows.find((f) => f.flowId === strategy.flowId);
+            if (!flow) {
+                warnings.push(`Test designer: strategy entry '${strategy.flowId}' has no matching flow.`);
+                continue;
+            }
+            const familySpecs = getSpecsForFamily(ctx.specIndex, flow.routeFamily, flow.featureId);
+            const relevantCrossImpacts = ctx.crossImpacts.filter((ci) => ci.sourceFamily === flow.routeFamily || ci.affectedFamily === flow.routeFamily);
+            const prompt = buildTestDesignerPrompt({
+                flow,
+                strategy,
+                apiSurface: ctx.apiSurface,
+                existingSpecs: familySpecs,
+                crossImpacts: relevantCrossImpacts,
+            });
+            try {
+                const response = await provider.generateText(prompt, {
+                    maxTokens: 4000,
+                    temperature: 0.1,
+                    timeout: 60000,
+                    systemPrompt: 'Return only valid JSON. Do not include markdown fences unless necessary.',
+                });
+                const parsed = parseTestDesignerResponse(response.text);
+                if (!parsed || parsed.testDesign.testCases.length === 0) {
+                    warnings.push(`Test designer: no test cases returned for flow ${strategy.flowId}.`);
+                    continue;
+                }
+                const validatedCases = parsed.testDesign.testCases
+                    .filter((tc) => tc.name && tc.steps && tc.steps.length > 0)
+                    .map((tc) => ({
+                    name: tc.name,
+                    type: VALID_TYPES.has(tc.type) ? tc.type : 'happy-path',
+                    preconditions: Array.isArray(tc.preconditions) ? tc.preconditions : [],
+                    steps: Array.isArray(tc.steps) ? tc.steps : [],
+                    expectedOutcome: tc.expectedOutcome || '',
+                    priority: (['P0', 'P1', 'P2'].includes(tc.priority) ? tc.priority : 'P2'),
+                    rationale: tc.rationale || '',
+                }))
+                    .slice(0, MAX_TEST_CASES_PER_FLOW);
+                if (validatedCases.length > 0) {
+                    designs.push({
+                        flowId: strategy.flowId,
+                        flowName: strategy.flowName,
+                        testCases: validatedCases,
+                    });
+                }
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                warnings.push(`Test designer failed for flow ${strategy.flowId}: ${message}`);
+            }
+        }
+        ctx.testDesigns.push(...designs);
+        return {
+            role: this.role,
+            status: designs.length > 0 ? 'success' : 'partial',
+            output: designs,
+            usage: provider.getUsageStats(),
+            warnings,
+        };
+    }
+}

package/dist/esm/anthropic_provider.js

@@ -0,0 +1,326 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+import Anthropic from '@anthropic-ai/sdk';
+import { LLMProviderError } from './provider_interface.js';
+import { API_KEY_PATTERNS, sanitizeErrorMessage, withTimeout, validateAndSanitizeUrl } from './provider_utils.js';
+import { BaseProvider } from './base_provider.js';
+import { logger } from './logger.js';
+/**
+ * Anthropic Provider - Claude AI models
+ *
+ * Features:
+ * - Highest quality AI (98% accuracy in testing)
+ * - Vision support (analyze screenshots, compare UI)
+ * - Fast response times (<1 second)
+ * - 200K token context window
+ * - Prompt caching (reduces costs by 90% on repeated prompts)
+ *
+ * Costs (Claude Sonnet 4.5):
+ * - Input: $3 per 1M tokens
+ * - Output: $15 per 1M tokens
+ * - Cached input: $0.30 per 1M tokens
+ * - Estimated: ~$30-80/month for autonomous testing
+ *
+ * Use cases:
+ * - Vision tasks (screenshot comparison)
+ * - Complex failure diagnosis
+ * - High-stakes production testing
+ * - When quality is paramount
+ *
+ * Models:
+ * - claude-sonnet-4-5-20250929 (recommended - best balance)
+ * - claude-opus-4-5-20251101 (highest quality, slower, more expensive)
+ * - claude-haiku-4-0-20250430 (fastest, cheapest, lower quality)
+ */
+export class AnthropicProvider extends BaseProvider {
+    constructor(config) {
+        super();
+        this.name = 'anthropic';
+        this.capabilities = {
+            vision: true, // Full vision support
+            streaming: true,
+            maxTokens: 200000, // 200K context window
+            costPer1MInputTokens: 3, // $3 per 1M input tokens
+            costPer1MOutputTokens: 15, // $15 per 1M output tokens
+            supportsTools: true, // Function calling support
+            supportsPromptCaching: true, // Reduces costs by 90%
+            typicalResponseTimeMs: 800, // ~0.8 seconds
+        };
+        // SECURITY: Validate API key format
+        if (!API_KEY_PATTERNS.anthropic.test(config.apiKey)) {
+            throw new Error('Invalid API key format. Expected sk-ant-* format.');
+        }
+        // SECURITY: Validate and enforce HTTPS for remote connections
+        if (config.baseUrl) {
+            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.client = new Anthropic({
+            apiKey: config.apiKey,
+            baseURL: config.baseUrl,
+            maxRetries: 0,
+        });
+        this.model = config.model || 'claude-sonnet-4-5-20250929';
+    }
+    async generateText(prompt, options) {
+        this.checkBudget();
+        const startTime = Date.now();
+        try {
+            // SECURITY: Validate prompt length to prevent resource exhaustion
+            if (prompt.length > 10 * 1024 * 1024) {
+                throw new Error('Prompt exceeds maximum size (10MB)');
+            }
+            const response = await withTimeout(this.client.messages.create({
+                model: this.model,
+                max_tokens: options?.maxTokens || 4000,
+                temperature: options?.temperature,
+                top_p: options?.topP,
+                stop_sequences: options?.stopSequences,
+                system: options?.systemPrompt,
+                messages: [
+                    {
+                        role: 'user',
+                        content: prompt,
+                    },
+                ],
+            }), options?.timeout, 'generateText');
+            const responseTime = Date.now() - startTime;
+            const text = this.extractTextFromResponse(response);
+            // SECURITY: Type-safe usage extraction
+            const usage = this.extractUsageFromResponse(response.usage);
+            const cost = this.calculateCost(usage, this.capabilities.costPer1MInputTokens, this.capabilities.costPer1MOutputTokens);
+            // Update stats
+            this.updateStats(usage, responseTime, cost);
+            return {
+                text,
+                usage,
+                cost,
+                metadata: {
+                    model: this.model,
+                    responseTimeMs: responseTime,
+                    stopReason: response.stop_reason,
+                    stopSequence: response.stop_sequence,
+                },
+            };
+        }
+        catch (error) {
+            this.stats.failedRequests++;
+            throw new LLMProviderError(sanitizeErrorMessage(error, 'generateText'), this.name, this.extractStatusCode(error), error);
+        }
+    }
+    async analyzeImage(images, prompt, options) {
+        const startTime = Date.now();
+        try {
+            // SECURITY: Validate image array size
+            if (images.length === 0 || images.length > 20) {
+                throw new Error('Image count must be between 1 and 20');
+            }
+            // SECURITY: Validate prompt length
+            if (prompt.length > 10 * 1024 * 1024) {
+                throw new Error('Prompt exceeds maximum size (10MB)');
+            }
+            // Build content array with text and images
+            const content = [];
+            // Add prompt text first
+            content.push({
+                type: 'text',
+                text: prompt,
+            });
+            // Add each image
+            for (const image of images) {
+                // Validate media type
+                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 || '';
+                // SECURITY: Validate base64 data size (limit to 20MB per image)
+                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: data,
+                    },
+                });
+                // Add description if provided
+                if (image.description) {
+                    content.push({
+                        type: 'text',
+                        text: `[Image: ${image.description}]`,
+                    });
+                }
+            }
+            const response = await withTimeout(this.client.messages.create({
+                model: this.model,
+                max_tokens: options?.maxTokens || 4000,
+                temperature: options?.temperature,
+                top_p: options?.topP,
+                stop_sequences: options?.stopSequences,
+                system: options?.systemPrompt,
+                messages: [
+                    {
+                        role: 'user',
+                        content,
+                    },
+                ],
+            }), options?.timeout, 'analyzeImage');
+            const responseTime = Date.now() - startTime;
+            const text = this.extractTextFromResponse(response);
+            // SECURITY: Type-safe usage extraction
+            const usage = this.extractUsageFromResponse(response.usage);
+            const cost = this.calculateCost(usage, this.capabilities.costPer1MInputTokens, this.capabilities.costPer1MOutputTokens);
+            // Update stats
+            this.updateStats(usage, responseTime, cost);
+            return {
+                text,
+                usage,
+                cost,
+                metadata: {
+                    model: this.model,
+                    responseTimeMs: responseTime,
+                    stopReason: response.stop_reason,
+                    imageCount: images.length,
+                },
+            };
+        }
+        catch (error) {
+            this.stats.failedRequests++;
+            throw new LLMProviderError(sanitizeErrorMessage(error, 'analyzeImage'), this.name, this.extractStatusCode(error), error);
+        }
+    }
+    async *streamText(prompt, options) {
+        try {
+            // SECURITY: Validate prompt length
+            if (prompt.length > 10 * 1024 * 1024) {
+                throw new Error('Prompt exceeds maximum size (10MB)');
+            }
+            const stream = await withTimeout(this.client.messages.create({
+                model: this.model,
+                max_tokens: options?.maxTokens || 4000,
+                temperature: options?.temperature,
+                top_p: options?.topP,
+                stop_sequences: options?.stopSequences,
+                system: options?.systemPrompt,
+                messages: [
+                    {
+                        role: 'user',
+                        content: prompt,
+                    },
+                ],
+                stream: true,
+            }), options?.timeout, 'streamText');
+            for await (const event of stream) {
+                if (event.type === 'content_block_delta' && event.delta.type === 'text_delta') {
+                    yield event.delta.text;
+                }
+            }
+            // Note: Streaming doesn't provide detailed usage stats
+            // We increment request count but can't track exact tokens/cost
+            this.stats.requestCount++;
+            this.stats.lastUpdated = new Date();
+        }
+        catch (error) {
+            this.stats.failedRequests++;
+            throw new LLMProviderError(sanitizeErrorMessage(error, 'streamText'), this.name, this.extractStatusCode(error), error);
+        }
+    }
+    extractTextFromResponse(response) {
+        const textBlocks = response.content.filter((block) => block.type === 'text');
+        return textBlocks.map((block) => {
+            if (block.type === 'text') {
+                return block.text;
+            }
+            return '';
+        }).join('\n');
+    }
+    /**
+     * SECURITY: Type-safe usage extraction
+     * Avoids unsafe `as any` casts
+     */
+    extractUsageFromResponse(usage) {
+        return {
+            inputTokens: usage.input_tokens || 0,
+            outputTokens: usage.output_tokens || 0,
+            totalTokens: (usage.input_tokens || 0) + (usage.output_tokens || 0),
+            cachedTokens: usage.cache_read_input_tokens ?? undefined,
+        };
+    }
+    /**
+     * SECURITY: Extract status code safely
+     */
+    extractStatusCode(error) {
+        if (error && typeof error === 'object') {
+            const err = error;
+            const status = err.status;
+            if (typeof status === 'number') {
+                return status;
+            }
+        }
+        return undefined;
+    }
+    /**
+     * Check if API key is valid and service is accessible
+     */
+    async checkHealth() {
+        try {
+            // Try a minimal request to verify API key
+            await withTimeout(this.client.messages.create({
+                model: this.model,
+                max_tokens: 10,
+                messages: [
+                    {
+                        role: 'user',
+                        content: 'Hi',
+                    },
+                ],
+            }), 5000, 'health check');
+            return {
+                healthy: true,
+                message: `Anthropic API is accessible`,
+            };
+        }
+        catch (error) {
+            return {
+                healthy: false,
+                message: `Anthropic API error: ${sanitizeErrorMessage(error, 'health check')}`,
+            };
+        }
+    }
+}
+/**
+ * Helper to check Anthropic setup
+ */
+export async function checkAnthropicSetup(apiKey) {
+    if (!apiKey) {
+        return {
+            valid: false,
+            message: 'No API key provided',
+            estimatedMonthlyCost: 'N/A',
+        };
+    }
+    try {
+        const provider = new AnthropicProvider({ apiKey });
+        const health = await provider.checkHealth();
+        return {
+            valid: health.healthy,
+            message: health.message,
+            estimatedMonthlyCost: '$30-80 for autonomous testing (24 cycles/day)',
+        };
+    }
+    catch (error) {
+        return {
+            valid: false,
+            message: `Setup check failed: ${sanitizeErrorMessage(error, 'setup check')}`,
+            estimatedMonthlyCost: 'N/A',
+        };
+    }
+}

package/dist/esm/api.js

@@ -0,0 +1,143 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+import { resolveConfig } from './agent/config.js';
+import { appendPlanMetrics, } from './agent/plan.js';
+import { analyzeImpact as analyzeImpactV2 } from './engine/impact_engine.js';
+import { buildPlanFromImpact, renderCiSummaryMarkdown, writeCiSummary, writePlanReport, } from './engine/plan_builder.js';
+import { getChangedFiles } from './agent/git.js';
+import { getAdaptiveThresholds } from './agent/feedback.js';
+import { loadDiffs } from './engine/diff_loader.js';
+import { enrichImpactWithAI } from './engine/ai_enrichment.js';
+import { LLMProviderFactory } from './provider_factory.js';
+import { finalizeGeneratedTests } from './agent/handoff.js';
+import { ingestTraceabilityInput, } from './agent/traceability_ingest.js';
+import { captureTraceabilityInput, } from './agent/traceability_capture.js';
+function resolveAgent(options, mode) {
+    const cwd = options.cwd || process.cwd();
+    const { config } = resolveConfig(cwd, options.configPath, {
+        ...options,
+        mode,
+    });
+    if (options.allowFallback) {
+        config.impact.allowFallback = true;
+    }
+    return config;
+}
+export function handoffGeneratedTests(options) {
+    return finalizeGeneratedTests(options);
+}
+export function ingestTraceability(options) {
+    const cwd = options.cwd || process.cwd();
+    const { config } = resolveConfig(cwd, options.configPath, {
+        path: options.path,
+        testsRoot: options.testsRoot,
+        mode: 'impact',
+    });
+    const reportRoot = config.testsRoot || config.path;
+    return ingestTraceabilityInput(reportRoot, config.impact.traceability, options.payload, options.options);
+}
+export function analyzeImpactDeterministic(options = {}) {
+    const config = resolveAgent(options, 'impact');
+    const reportRoot = config.testsRoot || config.path;
+    const gitResult = getChangedFiles(config.path, config.git.since, { includeUncommitted: config.git.includeUncommitted });
+    return analyzeImpactV2(gitResult.files, {
+        testsRoot: reportRoot,
+        routeFamilies: config.routeFamilies,
+        filteredTestFiles: gitResult.filteredTestFiles,
+    });
+}
+export function recommendTestsDeterministic(options = {}) {
+    const config = resolveAgent(options, 'impact');
+    const reportRoot = config.testsRoot || config.path;
+    const gitResult = getChangedFiles(config.path, config.git.since, { includeUncommitted: config.git.includeUncommitted });
+    const impact = analyzeImpactV2(gitResult.files, {
+        testsRoot: reportRoot,
+        routeFamilies: config.routeFamilies,
+        filteredTestFiles: gitResult.filteredTestFiles,
+    });
+    const adaptive = getAdaptiveThresholds(reportRoot);
+    const plan = buildPlanFromImpact(impact, config.policy, undefined, adaptive);
+    const planPath = writePlanReport(reportRoot, plan);
+    const ciSummaryMarkdown = renderCiSummaryMarkdown(plan);
+    const ciSummaryPath = writeCiSummary(reportRoot, ciSummaryMarkdown);
+    appendPlanMetrics(reportRoot, plan);
+    return { impact, plan, planPath, ciSummaryMarkdown, ciSummaryPath };
+}
+export async function recommendTestsAI(options = {}) {
+    const config = resolveAgent(options, 'impact');
+    const reportRoot = config.testsRoot || config.path;
+    const gitResult = getChangedFiles(config.path, config.git.since, { includeUncommitted: config.git.includeUncommitted });
+    const impact = analyzeImpactV2(gitResult.files, {
+        testsRoot: reportRoot,
+        routeFamilies: config.routeFamilies,
+        filteredTestFiles: gitResult.filteredTestFiles,
+    });
+    let aiEnrichment;
+    let provider;
+    try {
+        provider = await LLMProviderFactory.createFromPreference(config.llm.provider);
+    }
+    catch (error) {
+        const configuredProvider = config.llm.provider?.trim().toLowerCase();
+        const envProvider = process.env.LLM_PROVIDER?.trim().toLowerCase();
+        const shouldThrow = Boolean((configuredProvider && configuredProvider !== 'auto') ||
+            (envProvider && envProvider !== 'auto'));
+        if (shouldThrow) {
+            throw error;
+        }
+    }
+    if (provider) {
+        const diffs = loadDiffs(config.path, config.git.since, gitResult.files);
+        // Collect all known spec paths and scenario details from impacted features
+        const specSet = new Set();
+        const specDetailsMap = new Map();
+        for (const feature of impact.impactedFeatures) {
+            for (const s of feature.playwrightSpecs) {
+                specSet.add(s);
+            }
+            for (const detail of feature.playwrightSpecDetails) {
+                if (!specDetailsMap.has(detail.file)) {
+                    specDetailsMap.set(detail.file, detail);
+                }
+            }
+            for (const detail of feature.cypressSpecDetails) {
+                if (!specDetailsMap.has(detail.file)) {
+                    specDetailsMap.set(detail.file, detail);
+                }
+            }
+        }
+        aiEnrichment = await enrichImpactWithAI({
+            deterministicImpact: impact,
+            diffs,
+            provider,
+            specList: [...specSet],
+            specDetails: [...specDetailsMap.values()],
+        });
+    }
+    const adaptive = getAdaptiveThresholds(reportRoot);
+    const plan = buildPlanFromImpact(impact, config.policy, aiEnrichment, adaptive);
+    const planPath = writePlanReport(reportRoot, plan);
+    const ciSummaryMarkdown = renderCiSummaryMarkdown(plan);
+    const ciSummaryPath = writeCiSummary(reportRoot, ciSummaryMarkdown);
+    appendPlanMetrics(reportRoot, plan);
+    return { impact, plan, planPath, ciSummaryMarkdown, ciSummaryPath, aiEnrichment };
+}
+export function captureTraceability(options) {
+    const cwd = options.cwd || process.cwd();
+    const { config } = resolveConfig(cwd, options.configPath, {
+        path: options.path,
+        testsRoot: options.testsRoot,
+        mode: 'impact',
+    });
+    const reportRoot = config.testsRoot || config.path;
+    const captureOptions = {
+        appPath: config.path,
+        testsRoot: reportRoot,
+        reportPath: options.reportPath,
+        sinceRef: options.sinceRef || config.git.since,
+        outputPath: options.outputPath,
+        coverageMapPath: options.coverageMapPath,
+        changedFilesPath: options.changedFilesPath,
+    };
+    return captureTraceabilityInput(captureOptions);
+}