@yasserkhanorg/impact-gate 2.0.0

package/dist/engine/impact_engine.js

@@ -0,0 +1,298 @@
+"use strict";
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractScenarios = extractScenarios;
+exports.analyzeImpact = analyzeImpact;
+exports.getGapsWithSuppressed = getGapsWithSuppressed;
+exports.getGaps = getGaps;
+exports.getPartialGaps = getPartialGaps;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const route_families_js_1 = require("../knowledge/route_families.js");
+const git_js_1 = require("../agent/git.js");
+function scanDirForSpecs(baseDir, specDir, extension) {
+    const fullDir = (0, path_1.join)(baseDir, specDir);
+    if (!(0, fs_1.existsSync)(fullDir)) {
+        return [];
+    }
+    const specs = [];
+    try {
+        const items = (0, fs_1.readdirSync)(fullDir, { withFileTypes: true });
+        for (const item of items) {
+            const itemPath = (0, path_1.join)(fullDir, item.name);
+            if (item.isDirectory()) {
+                specs.push(...scanDirForSpecsRecursive(itemPath, extension));
+            }
+            else if (item.name.endsWith(extension)) {
+                specs.push((0, path_1.join)(specDir, item.name));
+            }
+        }
+    }
+    catch {
+        // Directory not readable
+    }
+    return specs;
+}
+function scanDirForSpecsRecursive(dir, extension) {
+    const specs = [];
+    try {
+        const items = (0, fs_1.readdirSync)(dir, { withFileTypes: true });
+        for (const item of items) {
+            const fullPath = (0, path_1.join)(dir, item.name);
+            if (item.isDirectory()) {
+                specs.push(...scanDirForSpecsRecursive(fullPath, extension));
+            }
+            else if (item.name.endsWith(extension)) {
+                specs.push(fullPath);
+            }
+        }
+    }
+    catch {
+        // Directory not readable
+    }
+    return specs;
+}
+// Regex patterns for extracting test scenario titles from spec files.
+// Playwright uses test() and test.describe(); Cypress uses describe(), context(), it().
+const PLAYWRIGHT_SCENARIO_RE = /(?:test\.describe|test)\(\s*['"`]([^'"`]+)['"`]/g;
+const CYPRESS_SCENARIO_RE = /(?:describe|context|it)\(\s*['"`]([^'"`]+)['"`]/g;
+/**
+ * Extract describe/test/it titles from a spec file using regex.
+ * Returns an empty array if the file cannot be read.
+ */
+function extractScenarios(filePath, framework) {
+    let content;
+    try {
+        content = (0, fs_1.readFileSync)(filePath, 'utf-8');
+    }
+    catch {
+        return [];
+    }
+    const re = framework === 'playwright' ? PLAYWRIGHT_SCENARIO_RE : CYPRESS_SCENARIO_RE;
+    const scenarios = [];
+    let match;
+    // Reset lastIndex in case the regex was used before
+    re.lastIndex = 0;
+    while ((match = re.exec(content)) !== null) {
+        scenarios.push(match[1]);
+    }
+    return scenarios;
+}
+function resolvePlaywrightSpecs(testsRoot, specDirs) {
+    const paths = [];
+    const details = [];
+    for (const dir of specDirs) {
+        const found = scanDirForSpecs(testsRoot, dir, '.spec.ts');
+        for (const relPath of found) {
+            paths.push(relPath);
+            const absPath = (0, path_1.join)(testsRoot, relPath);
+            details.push({ file: relPath, scenarios: extractScenarios(absPath, 'playwright') });
+        }
+    }
+    return { paths, details };
+}
+function resolveCypressSpecs(cypressRoot, specDirs) {
+    const paths = [];
+    const details = [];
+    for (const dir of specDirs) {
+        // cypressSpecDirs are relative to testsRoot (e.g. ../cypress/tests/integration/channels/search/)
+        // Resolve them relative to the cypress root
+        const resolvedDir = (0, path_1.join)(cypressRoot, dir.replace(/^\.\.\/cypress\//, ''));
+        if (!(0, fs_1.existsSync)(resolvedDir)) {
+            continue;
+        }
+        const found = scanDirForSpecsRecursive(resolvedDir, '.js');
+        const tsFound = scanDirForSpecsRecursive(resolvedDir, '.ts');
+        for (const absPath of [...found, ...tsFound]) {
+            paths.push(absPath);
+            details.push({ file: absPath, scenarios: extractScenarios(absPath, 'cypress') });
+        }
+    }
+    return { paths, details };
+}
+function computeCoverageStatus(pwSpecs, cySpecs) {
+    // Playwright is the primary framework — having Playwright specs is sufficient for "covered".
+    // Cypress-only = partial (advisory: legacy coverage, migrate when possible).
+    // Neither = uncovered (must add tests).
+    if (pwSpecs.length > 0) {
+        return 'covered';
+    }
+    if (cySpecs.length > 0) {
+        return 'partial';
+    }
+    return 'uncovered';
+}
+/**
+ * Group file bindings into a deduplicated map of family/feature → changed files.
+ */
+function groupBindings(fileBindings) {
+    const groups = new Map();
+    for (const fb of fileBindings) {
+        for (const binding of fb.bindings) {
+            const key = binding.feature || binding.family;
+            const existing = groups.get(key);
+            if (existing) {
+                if (!existing._seen.has(fb.file)) {
+                    existing._seen.add(fb.file);
+                    existing.files.push(fb.file);
+                }
+            }
+            else {
+                groups.set(key, {
+                    familyId: binding.family,
+                    featureId: binding.feature,
+                    files: [fb.file],
+                    _seen: new Set([fb.file]),
+                });
+            }
+        }
+    }
+    return groups;
+}
+/** Classify filtered test files by type for downstream decision-making. */
+function classifyPrTestFiles(allFiles, sourceFiles) {
+    const sourceSet = new Set(sourceFiles);
+    return allFiles
+        .filter((f) => !sourceSet.has(f))
+        .map((f) => {
+        const n = f.replace(/\\/g, '/');
+        if (/\.snap$/.test(n) || n.includes('__snapshots__/')) {
+            return { file: f, type: 'snapshot' };
+        }
+        if (/\.spec\.(ts|tsx|js|jsx)$/.test(n)) {
+            return { file: f, type: 'playwright' };
+        }
+        if (n.includes('/cypress/') && /\.(js|ts)$/.test(n)) {
+            return { file: f, type: 'cypress' };
+        }
+        return { file: f, type: 'unit' };
+    });
+}
+function analyzeImpact(changedFiles, options) {
+    const { testsRoot, routeFamilies } = options;
+    const warnings = [];
+    // Partition into source files and test files.
+    // Combine: (a) test files already in changedFiles that isTestFile catches, and
+    // (b) test files pre-filtered by the caller (filteredTestFiles from git.ts).
+    const preFilteredTests = options.filteredTestFiles ?? [];
+    const allOriginalFiles = [...new Set([...changedFiles, ...preFilteredTests])];
+    changedFiles = changedFiles.filter((f) => !(0, git_js_1.isTestFile)(f));
+    const prIncludedTestFiles = classifyPrTestFiles(allOriginalFiles, changedFiles);
+    // Load manifest, fall back to heuristic families if not found
+    let manifest = (0, route_families_js_1.loadRouteFamilyManifest)(testsRoot, routeFamilies);
+    if (!manifest) {
+        manifest = (0, route_families_js_1.buildHeuristicFamilies)(changedFiles, testsRoot);
+        warnings.push('Route family manifest not found. Using directory-based heuristics (lower accuracy).', 'Tip: Run `impact-gate train` to generate a proper manifest.');
+    }
+    // Combine original + expanded files
+    const allFiles = [...new Set([...changedFiles, ...(options.expandedFiles || [])])];
+    // Bind files to families
+    const fileBindings = (0, route_families_js_1.bindFilesToFamilies)(allFiles, manifest);
+    // Find unbound files
+    const unboundFiles = fileBindings
+        .filter((fb) => fb.bindings.length === 0)
+        .map((fb) => fb.file);
+    // Group bindings into features
+    const groups = groupBindings(fileBindings.filter((fb) => fb.bindings.length > 0));
+    // Determine cypress root
+    const cypressRoot = options.cypressRoot || inferCypressRoot(testsRoot);
+    // Resolve specs and compute coverage for each feature
+    const impactedFeatures = [];
+    for (const group of groups.values()) {
+        const binding = { family: group.familyId, feature: group.featureId };
+        const specDirs = (0, route_families_js_1.getSpecDirsForBinding)(manifest, binding);
+        const cypressSpecDirs = (0, route_families_js_1.getCypressSpecDirsForBinding)(manifest, binding);
+        const priority = (0, route_families_js_1.getPriorityForBinding)(manifest, binding);
+        const userFlows = (0, route_families_js_1.getUserFlowsForBinding)(manifest, binding);
+        const pw = resolvePlaywrightSpecs(testsRoot, specDirs);
+        const cy = cypressRoot ? resolveCypressSpecs(cypressRoot, cypressSpecDirs) : { paths: [], details: [] };
+        const coverageStatus = computeCoverageStatus(pw.paths, cy.paths);
+        impactedFeatures.push({
+            familyId: group.familyId,
+            featureId: group.featureId,
+            priority,
+            changedFiles: group.files,
+            playwrightSpecs: pw.paths,
+            cypressSpecs: cy.paths,
+            playwrightSpecDetails: pw.details,
+            cypressSpecDetails: cy.details,
+            userFlows,
+            coverageStatus,
+        });
+    }
+    // Sort by priority (P0 first, then P1, then P2)
+    const priorityOrder = { P0: 0, P1: 1, P2: 2 };
+    impactedFeatures.sort((a, b) => priorityOrder[a.priority] - priorityOrder[b.priority]);
+    if (unboundFiles.length > 0 && unboundFiles.length <= 5) {
+        warnings.push(`${unboundFiles.length} file(s) not mapped to any route family: ${unboundFiles.join(', ')}`);
+    }
+    else if (unboundFiles.length > 5) {
+        warnings.push(`${unboundFiles.length} file(s) not mapped to any route family`);
+    }
+    return {
+        changedFiles,
+        expandedFiles: options.expandedFiles || [],
+        impactedFeatures,
+        unboundFiles,
+        warnings,
+        prIncludedTestFiles,
+    };
+}
+function inferCypressRoot(testsRoot) {
+    // testsRoot is typically the Playwright tests directory
+    // Cypress tests are at a sibling path: e2e-tests/cypress/tests/integration/channels/
+    const candidate = (0, path_1.join)(testsRoot, '..', 'cypress');
+    if ((0, fs_1.existsSync)(candidate)) {
+        return candidate;
+    }
+    return undefined;
+}
+/**
+ * Get gaps: P0/P1 features with 'uncovered' status.
+ *
+ * Suppresses family-level (generic) gaps when ALL their changed files are
+ * already covered by feature-level (specific) matches in other families.
+ * Suppressed gaps are returned separately so the plan builder can promote
+ * them to advisory ("new behavior detected") on covered flows.
+ */
+function getGapsWithSuppressed(result) {
+    // Collect files that are covered via feature-level matches (more specific)
+    const filesCoveredByFeatures = new Set();
+    for (const f of result.impactedFeatures) {
+        if (f.featureId && f.coverageStatus !== 'uncovered') {
+            for (const file of f.changedFiles) {
+                filesCoveredByFeatures.add(file);
+            }
+        }
+    }
+    const gaps = [];
+    const suppressedGaps = [];
+    for (const f of result.impactedFeatures) {
+        if (f.priority !== 'P0' && f.priority !== 'P1')
+            continue;
+        if (f.coverageStatus !== 'uncovered')
+            continue;
+        // Only suppress FAMILY-level gaps (no featureId = generic match).
+        if (!f.featureId && f.changedFiles.every((file) => filesCoveredByFeatures.has(file))) {
+            suppressedGaps.push(f);
+        }
+        else {
+            gaps.push(f);
+        }
+    }
+    return { gaps, suppressedGaps };
+}
+/**
+ * Get gaps: P0/P1 features with 'uncovered' status.
+ * Convenience wrapper that returns only active gaps (backward-compatible).
+ */
+function getGaps(result) {
+    return getGapsWithSuppressed(result).gaps;
+}
+/**
+ * Get partial gaps: P0/P1 features with 'partial' status (advisory).
+ */
+function getPartialGaps(result) {
+    return result.impactedFeatures.filter((f) => (f.priority === 'P0' || f.priority === 'P1') && f.coverageStatus === 'partial');
+}

package/dist/engine/plan_builder.d.ts

@@ -0,0 +1,11 @@
+import type { PolicyConfig } from '../agent/config.js';
+import type { ImpactResult } from './impact_engine.js';
+import type { AIEnrichmentResult } from './ai_enrichment.js';
+import type { AdaptiveThresholds } from '../agent/feedback.js';
+import type { PlanReport, GapDetail, CoveredFlowSummary } from '../agent/plan.js';
+export type { PlanReport, GapDetail, CoveredFlowSummary };
+export declare function buildPlanFromImpact(impact: ImpactResult, policyOverride?: Partial<PolicyConfig>, aiEnrichment?: AIEnrichmentResult, adaptiveThresholds?: AdaptiveThresholds): PlanReport;
+export declare function writePlanReport(appRoot: string, plan: PlanReport): string;
+export declare function renderCiSummaryMarkdown(plan: PlanReport): string;
+export declare function writeCiSummary(appRoot: string, markdown: string, relativePath?: string): string;
+//# sourceMappingURL=plan_builder.d.ts.map

package/dist/engine/plan_builder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plan_builder.d.ts","sourceRoot":"","sources":["../../src/engine/plan_builder.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,oBAAoB,CAAC;AAErD,OAAO,KAAK,EAAC,YAAY,EAA8B,MAAM,oBAAoB,CAAC;AAGlF,OAAO,KAAK,EAAC,kBAAkB,EAAC,MAAM,oBAAoB,CAAC;AAC3D,OAAO,KAAK,EAAC,kBAAkB,EAAC,MAAM,sBAAsB,CAAC;AAG7D,OAAO,KAAK,EACR,UAAU,EACV,SAAS,EACT,kBAAkB,EAIrB,MAAM,kBAAkB,CAAC;AAE1B,YAAY,EAAC,UAAU,EAAE,SAAS,EAAE,kBAAkB,EAAC,CAAC;AAsUxD,wBAAgB,mBAAmB,CAC/B,MAAM,EAAE,YAAY,EACpB,cAAc,CAAC,EAAE,OAAO,CAAC,YAAY,CAAC,EACtC,YAAY,CAAC,EAAE,kBAAkB,EACjC,kBAAkB,CAAC,EAAE,kBAAkB,GACxC,UAAU,CA6LZ;AAED,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,UAAU,GAAG,MAAM,CAMzE;AAED,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,UAAU,GAAG,MAAM,CA4IhE;AAED,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,YAAY,SAAiC,GAAG,MAAM,CAMvH"}