@yasserkhanorg/impact-gate 2.0.0

package/dist/esm/pipeline/stage4_heal.js

@@ -0,0 +1,288 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+import { existsSync, readFileSync, writeFileSync } from 'fs';
+import { join, resolve } from 'path';
+import { runTargetedSpecHeal } from '../agent/pipeline.js';
+import { extractPlaywrightUnstableSpecs } from '../agent/playwright_report.js';
+import { resolvePlaywrightBinary, runCommand } from '../agent/process_runner.js';
+import { logger } from '../logger.js';
+/**
+ * Resolve heal targets from one or more sources, in priority order:
+ * 1. Playwright JSON report (CI failures/flakes)
+ * 2. Stage 3 generated specs (newly written files that need runtime validation)
+ * 3. Explicit target list
+ */
+export function resolveHealTargets(testsRoot, options, decisions) {
+    const targets = [];
+    const seen = new Set();
+    const addTarget = (specPath, status, reason) => {
+        // Normalize to absolute path so relative (from Playwright report) and absolute
+        // (from generated specs) deduplicate correctly
+        let normalized = specPath.replace(/\\/g, '/');
+        if (!specPath.startsWith('/') && !(/^[A-Za-z]:[\\/]/).test(specPath)) {
+            normalized = join(testsRoot, specPath).replace(/\\/g, '/');
+        }
+        if (seen.has(normalized)) {
+            return;
+        }
+        seen.add(normalized);
+        // Try to match to a FlowDecision for context
+        const decision = findDecisionForSpec(normalized, decisions, testsRoot);
+        targets.push({ specPath: normalized, status, decision, reason });
+    };
+    // Source 1: Playwright JSON report
+    if (options.playwrightReportPath) {
+        const reportPath = resolve(options.playwrightReportPath);
+        if (existsSync(reportPath)) {
+            const unstable = extractPlaywrightUnstableSpecs(reportPath, [testsRoot]);
+            for (const spec of unstable) {
+                addTarget(spec.specPath, spec.status, `Playwright report: failingTests=${spec.failingTests}, flakyTests=${spec.flakyTests}`);
+            }
+        }
+    }
+    // Source 2: Stage 3 generated specs (heal immediately after generation)
+    if (options.generatedSpecs) {
+        for (const gen of options.generatedSpecs) {
+            if (gen.written) {
+                addTarget(gen.specPath, 'failed', `Newly generated spec — needs runtime validation`);
+            }
+        }
+    }
+    // Source 3: Explicit targets
+    if (options.explicitTargets) {
+        for (const t of options.explicitTargets) {
+            addTarget(t.specPath, t.status, t.reason);
+        }
+    }
+    return targets;
+}
+/**
+ * Find the FlowDecision most relevant to a given spec path by matching
+ * targetSpec / newSpecPath / specPath suffix against decisions.
+ */
+function findDecisionForSpec(specPath, decisions, testsRoot) {
+    const normalizedRoot = testsRoot.replace(/\\/g, '/');
+    const relative = specPath.startsWith(normalizedRoot)
+        ? specPath.slice(normalizedRoot.length).replace(/^\//, '')
+        : specPath;
+    return decisions.find((d) => {
+        const target = (d.targetSpec || d.newSpecPath || '').replace(/\\/g, '/');
+        if (!target)
+            return false;
+        // Exact match
+        if (target === relative || target === specPath)
+            return true;
+        // Suffix match with path-segment boundary (must be preceded by /)
+        if (relative.endsWith(`/${target}`) || target.endsWith(`/${relative}`))
+            return true;
+        return false;
+    });
+}
+const MAX_HEAL_CYCLES = 2;
+/**
+ * Verify a healed spec by running it with Playwright.
+ * Returns null on success, or the error message on failure.
+ */
+function verifyHealedSpec(testsRoot, specPath, playwrightBinary) {
+    if (!playwrightBinary) {
+        return null; // Can't verify without playwright — assume success
+    }
+    // Resolve to absolute path to prevent argument injection via paths starting with '-'
+    const safePath = resolve(specPath);
+    const result = runCommand(playwrightBinary, ['test', safePath, '--retries', '1', '--reporter', 'list'], testsRoot, 60000);
+    if (result.status === 0) {
+        return null; // Passed
+    }
+    // Extract meaningful error from output
+    const output = [result.stdout, result.stderr].filter(Boolean).join('\n');
+    const errorLines = output.split('\n').filter((l) => l.includes('Error') || l.includes('error') || l.includes('FAILED') || l.includes('Timeout')).slice(0, 5);
+    return errorLines.join('\n') || result.error || 'Verification failed';
+}
+/**
+ * Mark a spec as test.fixme() when healing cannot fix it.
+ * Adds a comment explaining the failure.
+ */
+function markSpecAsFixme(specPath, reason) {
+    if (!existsSync(specPath))
+        return;
+    try {
+        const content = readFileSync(specPath, 'utf-8');
+        const fixmeComment = `// HEAL-INCOMPLETE: ${reason.split('\n')[0].slice(0, 120)}`;
+        let commentAdded = false;
+        let inBlockComment = false;
+        const lines = content.split('\n');
+        const result = [];
+        for (const line of lines) {
+            // Minimal block-comment tracking to avoid replacing test( inside /* ... */
+            if (!inBlockComment && line.includes('/*'))
+                inBlockComment = true;
+            if (inBlockComment) {
+                if (line.includes('*/'))
+                    inBlockComment = false;
+                result.push(line);
+                continue;
+            }
+            const match = line.match(/^([ \t]*)(test\()/);
+            if (match) {
+                const indent = match[1];
+                if (!commentAdded) {
+                    commentAdded = true;
+                    result.push(`${indent}${fixmeComment}`);
+                }
+                result.push(line.replace(/^([ \t]*)test\(/, '$1test.fixme('));
+            }
+            else {
+                result.push(line);
+            }
+        }
+        writeFileSync(specPath, result.join('\n'), 'utf-8');
+    }
+    catch {
+        // Best effort — don't fail the pipeline
+    }
+}
+export async function runHealStage(testsRoot, targets, config) {
+    const warnings = [];
+    let healAttempts = 0;
+    let healSuccess = 0;
+    if (targets.length === 0) {
+        return {
+            targets,
+            summary: {
+                runner: 'package-native',
+                results: [],
+                warnings: ['No heal targets provided.'],
+            },
+            warnings,
+            healAttempts: 0,
+            healSuccess: 0,
+        };
+    }
+    const healTargets = targets.map((t) => ({
+        specPath: t.specPath,
+        status: t.status,
+        reason: t.reason,
+    }));
+    const pipelineConfig = {
+        enabled: true,
+        scenarios: 1,
+        outputDir: config.outputDir || 'specs/functional/ai-assisted',
+        heal: true,
+        dryRun: config.dryRun,
+        mcp: config.mcp ?? true,
+        mcpAllowFallback: config.mcpAllowFallback ?? false,
+        mcpOnly: config.mcpOnly ?? false,
+        mcpCommandTimeoutMs: config.mcpCommandTimeoutMs,
+        mcpRetries: config.mcpRetries ?? 1,
+    };
+    const summary = runTargetedSpecHeal(testsRoot, healTargets, pipelineConfig);
+    healAttempts += summary.results.filter((r) => r.healStatus === 'success' || r.healStatus === 'failed').length;
+    warnings.push(...summary.warnings);
+    // Verify-after-heal: re-run healed specs to confirm fixes work
+    if (!config.dryRun) {
+        const playwrightBinary = resolvePlaywrightBinary(testsRoot);
+        const healedResults = summary.results.filter((r) => r.healStatus === 'success');
+        for (const result of healedResults) {
+            const normalizedFlowId = result.flowId.replace(/\\/g, '/');
+            // Try exact match first, then path-suffix match with segment boundary
+            let target = targets.find((t) => {
+                const normalizedSpec = t.specPath.replace(/\\/g, '/');
+                return normalizedSpec === normalizedFlowId;
+            });
+            if (!target) {
+                // Basename fallback: only accept if exactly one candidate matches
+                const candidates = targets.filter((t) => {
+                    const specBasename = t.specPath.split('/').pop() || '';
+                    const flowBasename = normalizedFlowId.split('/').pop() || '';
+                    return specBasename === flowBasename;
+                });
+                if (candidates.length === 1) {
+                    target = candidates[0];
+                }
+            }
+            const specPath = target?.specPath || result.flowId;
+            if (!existsSync(specPath)) {
+                continue;
+            }
+            let verifyError = verifyHealedSpec(testsRoot, specPath, playwrightBinary);
+            if (verifyError) {
+                logger.info(`Heal verification failed for ${specPath}, attempting re-heal (cycle 2/${MAX_HEAL_CYCLES})`);
+                healAttempts++;
+                // Re-heal with enriched failure detail
+                const reHealTargets = [{
+                        specPath,
+                        status: 'failed',
+                        reason: `Re-heal: verification failed after first heal. Error: ${verifyError.slice(0, 500)}`,
+                    }];
+                const reHealSummary = runTargetedSpecHeal(testsRoot, reHealTargets, pipelineConfig);
+                warnings.push(...reHealSummary.warnings);
+                const reHealed = reHealSummary.results.find((r) => r.healStatus === 'success');
+                if (reHealed) {
+                    verifyError = verifyHealedSpec(testsRoot, specPath, playwrightBinary);
+                }
+                if (verifyError) {
+                    // After 2 cycles, mark as fixme
+                    logger.warn(`Heal-and-verify failed after ${MAX_HEAL_CYCLES} cycles for ${specPath}, marking as test.fixme()`);
+                    markSpecAsFixme(specPath, verifyError);
+                    result.healStatus = 'failed';
+                    result.error = `heal-incomplete: ${verifyError.slice(0, 200)}`;
+                    warnings.push(`Heal-incomplete: ${specPath} — marked as test.fixme() after ${MAX_HEAL_CYCLES} failed cycles`);
+                }
+                else {
+                    healSuccess++;
+                }
+            }
+            else {
+                healSuccess++;
+            }
+        }
+    }
+    return { targets, summary, warnings, healAttempts, healSuccess };
+}
+/**
+ * Convenience: extract heal targets from a complete pipeline report + optional
+ * Playwright run results, then run the heal stage.
+ */
+export async function healFromReport(testsRoot, report, options) {
+    const targets = resolveHealTargets(testsRoot, {
+        playwrightReportPath: options.playwrightReportPath,
+        generatedSpecs: options.generatedSpecs,
+    }, report.decisions);
+    return runHealStage(testsRoot, targets, options.healConfig || { mcp: true });
+}
+/**
+ * Write a heal summary section to the pipeline report markdown.
+ */
+export function renderHealMarkdown(result) {
+    const lines = ['## Heal Results', ''];
+    const healedCount = result.summary.results.filter((r) => r.healStatus === 'success').length;
+    const failedCount = result.summary.results.filter((r) => r.healStatus === 'failed').length;
+    const skippedCount = result.summary.results.filter((r) => r.healStatus === 'skipped').length;
+    const successRate = result.healAttempts > 0
+        ? `${Math.round((result.healSuccess / result.healAttempts) * 100)}%`
+        : 'n/a';
+    lines.push(`| Metric | Value |`);
+    lines.push(`|--------|-------|`);
+    lines.push(`| Targets | ${result.targets.length} |`);
+    lines.push(`| Healed | ${healedCount} |`);
+    lines.push(`| Failed | ${failedCount} |`);
+    lines.push(`| Skipped | ${skippedCount} |`);
+    lines.push(`| Heal Attempts | ${result.healAttempts} |`);
+    lines.push(`| Verified Passing | ${result.healSuccess} |`);
+    lines.push(`| Success Rate | ${successRate} |`);
+    lines.push('');
+    for (const r of result.summary.results) {
+        const icon = r.healStatus === 'success' ? '✅' : r.healStatus === 'failed' ? '❌' : '⏭';
+        lines.push(`- ${icon} \`${r.flowId}\` — heal: ${r.healStatus || 'n/a'}`);
+        if (r.error) {
+            lines.push(`  - Error: ${r.error}`);
+        }
+    }
+    if (result.warnings.length > 0) {
+        lines.push('', '### Heal Warnings', '');
+        for (const w of result.warnings) {
+            lines.push(`- ${w}`);
+        }
+    }
+    return lines.join('\n');
+}

package/dist/esm/progress.js

@@ -0,0 +1,112 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+import { EventEmitter } from 'events';
+export class ProgressReporter extends EventEmitter {
+    constructor(options) {
+        super();
+        this.isTTY = options?.isTTY ?? (process.stdout.isTTY === true);
+        this.silent = (options?.quiet ?? false) || (options?.jsonMode ?? false);
+        this.completedAgents = 0;
+        this.totalAgents = 0;
+        this.currentPhase = '';
+    }
+    phaseStart(phase, agentCount) {
+        const payload = { phase, agentCount };
+        this.emit('phase-start', payload);
+        if (this.silent) {
+            return;
+        }
+        this.currentPhase = phase;
+        this.completedAgents = 0;
+        this.totalAgents = agentCount;
+        const message = `--- Phase: ${phase} (${agentCount} agent${agentCount !== 1 ? 's' : ''}) ---`;
+        this.writeLine(message);
+    }
+    agentStart(agent, family) {
+        const payload = { agent, family };
+        this.emit('agent-start', payload);
+        if (this.silent) {
+            return;
+        }
+        const familyLabel = family ? ` processing ${family}` : '';
+        if (this.isTTY) {
+            const progress = `[${this.completedAgents}/${this.totalAgents} agents]`;
+            const message = `${progress} ${this.currentPhase}: ${agent}${familyLabel}...`;
+            process.stdout.write(`\r${clearLine()}${message}`);
+        }
+        else {
+            const message = `[${this.currentPhase}] ${agent} started${familyLabel ? ':' + familyLabel : ''}`;
+            this.writeLine(message);
+        }
+    }
+    agentComplete(agent, family, tokens, cost, durationMs) {
+        const payload = { agent, family, tokens, cost, durationMs };
+        this.emit('agent-complete', payload);
+        if (this.silent) {
+            return;
+        }
+        this.completedAgents++;
+        const costStr = formatCost(cost);
+        const durationStr = formatDuration(durationMs);
+        const tokensStr = formatTokens(tokens);
+        const familyLabel = family ? ` ${family}` : '';
+        if (this.isTTY) {
+            const progress = `[${this.completedAgents}/${this.totalAgents} agents]`;
+            const message = `${progress} ${this.currentPhase}: ${agent} complete${familyLabel} (${tokensStr}, ${costStr}, ${durationStr})`;
+            process.stdout.write(`\r${clearLine()}${message}\n`);
+        }
+        else {
+            const message = `[${this.currentPhase}] ${agent} complete:${familyLabel} (${tokensStr}, ${costStr}, ${durationStr})`;
+            this.writeLine(message);
+        }
+    }
+    phaseComplete(phase, elapsedMs) {
+        const payload = { phase, elapsedMs };
+        this.emit('phase-complete', payload);
+        if (this.silent) {
+            return;
+        }
+        const durationStr = formatDuration(elapsedMs);
+        const message = `--- Phase ${phase} complete (${durationStr}) ---`;
+        this.writeLine(message);
+    }
+    workflowComplete(totalCost, totalTokens, elapsedMs) {
+        const payload = { totalCost, totalTokens, elapsedMs };
+        this.emit('workflow-complete', payload);
+        if (this.silent) {
+            return;
+        }
+        const costStr = formatCost(totalCost);
+        const tokensStr = formatTokens(totalTokens);
+        const durationStr = formatDuration(elapsedMs);
+        const message = `=== Workflow complete: ${tokensStr}, ${costStr}, ${durationStr} ===`;
+        this.writeLine(message);
+    }
+    writeLine(message) {
+        process.stdout.write(message + '\n');
+    }
+}
+function clearLine() {
+    return '\x1B[2K';
+}
+function formatCost(cost) {
+    return `$${cost.toFixed(2)}`;
+}
+function formatTokens(tokens) {
+    if (tokens >= 1000000) {
+        return `${(tokens / 1000000).toFixed(1)}M tokens`;
+    }
+    if (tokens >= 1000) {
+        return `${(tokens / 1000).toFixed(0).replace(/\B(?=(\d{3})+(?!\d))/g, ',')} tokens`;
+    }
+    return `${tokens} tokens`;
+}
+function formatDuration(ms) {
+    const seconds = Math.round(ms / 1000);
+    if (seconds >= 60) {
+        const minutes = Math.floor(seconds / 60);
+        const remainingSeconds = seconds % 60;
+        return remainingSeconds > 0 ? `${minutes}m${remainingSeconds}s` : `${minutes}m`;
+    }
+    return `${seconds}s`;
+}

package/dist/esm/prompts/coverage.js

@@ -0,0 +1,57 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+import { extractJsonFromResponse } from './json_extract.js';
+import { sanitizeForPrompt } from '../crew/sanitize.js';
+export function buildCoveragePrompt(ctx) {
+    const flowsBlock = ctx.flows
+        .map((f) => {
+        const actions = f.userActions.length > 0 ? f.userActions.map((a) => sanitizeForPrompt(a)).join('; ') : 'unknown';
+        return `- ${f.flowId} (${f.priority}): ${f.flowName}\n  Route: ${f.route}\n  User actions: ${actions}\n  Evidence: ${sanitizeForPrompt(f.evidence)}`;
+    })
+        .join('\n\n');
+    const specsBlock = ctx.specs
+        .map((s) => {
+        return `### ${s.relativePath}\nTest titles: ${s.testTitles.join(', ')}\n\`\`\`typescript\n${s.content}\n\`\`\``;
+    })
+        .join('\n\n');
+    return [
+        `You are evaluating whether existing ${ctx.profile?.projectName || 'the project'} ${ctx.profile?.testFramework || 'Playwright'} E2E tests cover the impacted flows.`,
+        '',
+        `IMPACTED FLOWS (${ctx.flows.length}):`,
+        flowsBlock,
+        '',
+        `EXISTING SPEC FILES (${ctx.specs.length}):`,
+        specsBlock,
+        '',
+        ctx.contextBlock,
+        '',
+        'For each flow, determine coverage.',
+        '',
+        'Return strict JSON only with this shape:',
+        '{"coverage":[{"flowId":"<flow_id>","action":"run_existing|add_scenarios|create_spec|cannot_determine","existingSpecs":[{"path":"<relative path>","testTitles":["<exact test title>"],"coverageLevel":"full|partial|none","missingScenarios":["<specific scenario>"]}],"scenariosToAdd":["<scenario description>"],"targetSpec":"<path to extend>","newSpecPath":"<path for new spec>","blockingReason":"<why cannot_determine>","confidence":0-100}]}',
+        '',
+        'Rules:',
+        '- When claiming coverage exists, you MUST quote the exact test title from the spec file.',
+        '- If a spec tests a related but different flow, mark as "partial" not "full".',
+        '- Do NOT claim coverage exists if you cannot cite the exact test.',
+        '- Scenario gaps must be stated as user actions, not code changes.',
+        '  Wrong: "test the new isEditing state"',
+        '  Right: "test editing a scheduled message while it is in pending state"',
+        '- For add_scenarios, specify which existing spec file to extend in targetSpec.',
+        `- For create_spec, suggest a path following ${ctx.profile?.projectName || 'the project'} conventions.`,
+        '- Prefer adding scenarios to existing specs over creating new spec files.',
+        '',
+        'SEMANTIC MATCHING RULES (critical for accuracy):',
+        '- A happy-path test does NOT cover the negative/error path of the same feature.',
+        '  "user can edit post" does NOT cover "user without permission cannot edit post".',
+        '- A test for one user role does NOT cover a different role.',
+        '  "admin can delete channel" does NOT cover "member cannot delete channel".',
+        '- A test for creation does NOT cover editing or deletion of the same entity.',
+        '- "partial" means: same feature area but different specific scenario.',
+        '- "full" means: the exact user action sequence and outcome is tested.',
+        '- When in doubt between "full" and "partial", choose "partial".',
+    ].join('\n');
+}
+export function parseCoverageResponse(text) {
+    return extractJsonFromResponse(text, (obj) => obj != null && typeof obj === 'object' && Array.isArray(obj.coverage));
+}

package/dist/esm/prompts/cross-impact.js

@@ -0,0 +1,53 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+import { sanitizeForPrompt } from '../crew/sanitize.js';
+import { extractJsonFromResponse } from './json_extract.js';
+export function buildCrossImpactPrompt(ctx) {
+    const familiesBlock = ctx.families
+        .map((f) => {
+        const paths = [
+            ...(f.webappPaths || []),
+            ...(f.serverPaths || []),
+            ...(f.components || []),
+        ];
+        return `- ${f.id}: routes=[${f.routes.join(', ')}] paths=[${paths.join(', ')}] pageObjects=[${(f.pageObjects || []).join(', ')}]`;
+    })
+        .join('\n');
+    const changedBlock = ctx.changedFiles.map((f) => sanitizeForPrompt(f)).join('\n');
+    return [
+        `You are analyzing code changes in ${ctx.projectName || 'the project'} to identify cross-family ripple effects.`,
+        'When a change in one route family could affect another family through shared dependencies,',
+        'that is a cross-impact.',
+        '',
+        `CHANGED FILES (${ctx.changedFiles.length}):`,
+        changedBlock,
+        '',
+        `DIRECTLY IMPACTED FAMILIES: ${ctx.directlyImpactedFamilyIds.join(', ')}`,
+        '',
+        `ALL ROUTE FAMILIES (${ctx.families.length}):`,
+        familiesBlock,
+        '',
+        'TASK: Identify cross-family impacts. For each pair, explain the shared dependency.',
+        '',
+        'Look for:',
+        '1. Shared webapp paths (same component used by multiple families)',
+        '2. Shared page objects (same PO class referenced by multiple families)',
+        '3. Shared API endpoints (changes affecting data used by multiple families)',
+        '4. Shared components (React components imported across family boundaries)',
+        '5. Shared state management (Redux stores, contexts used across families)',
+        '',
+        'Return strict JSON only with this shape:',
+        '{"crossImpacts":[{"sourceFamily":"<directly impacted family>","affectedFamily":"<indirectly affected family>","sharedDependency":"<what connects them>","riskLevel":"high|medium|low","evidence":"<specific file/component/API that creates the dependency>"}]}',
+        '',
+        'Rules:',
+        '- Only report cross-impacts where both families are in the manifest.',
+        '- sourceFamily must be one of the directly impacted families.',
+        '- affectedFamily must be DIFFERENT from sourceFamily.',
+        '- Risk levels: high = shared data model/state, medium = shared UI component, low = shared utility.',
+        '- Evidence must cite specific files, components, or API paths.',
+        '- Return empty array if no cross-impacts are found.',
+    ].join('\n');
+}
+export function parseCrossImpactResponse(text) {
+    return extractJsonFromResponse(text, (obj) => obj != null && typeof obj === 'object' && Array.isArray(obj.crossImpacts));
+}