@yasserkhanorg/impact-gate 2.0.0

package/dist/training/enricher.js

@@ -0,0 +1,350 @@
+"use strict";
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateEntries = validateEntries;
+exports.parseEnrichResponse = parseEnrichResponse;
+exports.enrichFamilies = enrichFamilies;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const logger_js_1 = require("../logger.js");
+const types_js_1 = require("./types.js");
+const MAX_FILES_PER_FAMILY = 20;
+const MAX_LINES_PER_FILE = 50;
+const LLM_TIMEOUT_MS = 60000;
+const MAX_PROMPT_CHARS = 100000;
+const SENSITIVE_PATTERNS = [
+    /[._]env/, /secret/i, /credential/i, /\.pem$/, /\.key$/, /password/i,
+    /config\/secrets/, /fixtures\/.*auth/i, /\.npmrc/, /\.netrc/,
+    /id_rsa/, /id_ed25519/, /\.p12$/, /\.pfx$/, /tokens?\.json/i,
+];
+const SKIP_DIRS = new Set([
+    'node_modules', '.git', 'dist', 'build', '.next', '.nuxt', 'coverage',
+]);
+function sampleFiles(dir, maxFiles) {
+    const files = [];
+    function walk(d, depth = 0, maxDepth = 10) {
+        if (files.length >= maxFiles)
+            return;
+        if (depth > maxDepth)
+            return;
+        try {
+            for (const entry of (0, fs_1.readdirSync)(d)) {
+                if (files.length >= maxFiles)
+                    return;
+                // Skip dot-dirs and known heavy directories
+                if (entry.startsWith('.') || SKIP_DIRS.has(entry))
+                    continue;
+                const full = (0, path_1.join)(d, entry);
+                try {
+                    // Skip symlinks
+                    const lstat = (0, fs_1.lstatSync)(full);
+                    if (lstat.isSymbolicLink())
+                        continue;
+                    // Skip sensitive files (test against relative path from scan root)
+                    const relPath = (0, path_1.relative)(dir, full);
+                    if (SENSITIVE_PATTERNS.some((p) => p.test(relPath) || p.test(entry)))
+                        continue;
+                    if (lstat.isDirectory()) {
+                        walk(full, depth + 1, maxDepth);
+                    }
+                    else if (lstat.isFile() && lstat.size < 50000) {
+                        const ext = entry.slice(entry.lastIndexOf('.'));
+                        if (['.ts', '.tsx', '.js', '.jsx', '.go', '.py', '.rs'].includes(ext)) {
+                            const content = (0, fs_1.readFileSync)(full, 'utf-8');
+                            const lines = content.split('\n').slice(0, MAX_LINES_PER_FILE).join('\n');
+                            files.push({ path: full, content: lines });
+                        }
+                    }
+                }
+                catch { /* skip */ }
+            }
+        }
+        catch { /* skip */ }
+    }
+    walk(dir);
+    return files;
+}
+/**
+ * Build a shallow directory listing of the source tree (depth 2-3) so the LLM
+ * can suggest accurate webappPaths / serverPaths for test-derived families.
+ */
+function getSourceTreeListing(projectRoot, maxDepth = 3) {
+    const lines = [];
+    function walk(dir, depth, prefix) {
+        if (depth > maxDepth || lines.length > 200)
+            return;
+        let entries;
+        try {
+            entries = (0, fs_1.readdirSync)(dir).sort();
+        }
+        catch {
+            return;
+        }
+        const dirs = entries.filter((e) => {
+            if (e.startsWith('.') || SKIP_DIRS.has(e))
+                return false;
+            try {
+                const stat = (0, fs_1.lstatSync)((0, path_1.join)(dir, e));
+                return !stat.isSymbolicLink() && stat.isDirectory();
+            }
+            catch {
+                return false;
+            }
+        });
+        for (const d of dirs) {
+            lines.push(`${prefix}${d}/`);
+            walk((0, path_1.join)(dir, d), depth + 1, prefix + '  ');
+        }
+    }
+    walk((0, path_1.resolve)(projectRoot), 0, '');
+    return lines.join('\n');
+}
+function buildEnrichPrompt(families, projectRoot, testsRoot) {
+    const sections = [];
+    const hasTestOnlyFamilies = families.some((f) => f.webappPaths.length === 0 && f.serverPaths.length === 0);
+    const resolvedTestsRoot = testsRoot ? (0, path_1.resolve)(testsRoot) : (0, path_1.resolve)(projectRoot);
+    for (const family of families) {
+        const isTestOnly = family.webappPaths.length === 0 && family.serverPaths.length === 0;
+        const allDirs = [
+            ...family.webappPaths.map((p) => p.replace(/\/?\*.*$/, '')),
+            ...family.serverPaths.map((p) => p.replace(/\/?\*.*$/, '')),
+        ];
+        const samples = [];
+        for (const dir of allDirs) {
+            if (!dir)
+                continue;
+            const fullDir = (0, path_1.join)((0, path_1.resolve)(projectRoot), dir);
+            samples.push(...sampleFiles(fullDir, MAX_FILES_PER_FAMILY - samples.length));
+            if (samples.length >= MAX_FILES_PER_FAMILY)
+                break;
+        }
+        // For test-only families, sample the test files themselves for richer context
+        if (isTestOnly) {
+            for (const specDir of family.specDirs) {
+                if (samples.length >= MAX_FILES_PER_FAMILY)
+                    break;
+                const fullDir = (0, path_1.join)(resolvedTestsRoot, specDir);
+                samples.push(...sampleFiles(fullDir, MAX_FILES_PER_FAMILY - samples.length));
+            }
+        }
+        // Sample spec descriptions
+        const specSamples = [];
+        for (const specDir of family.specDirs) {
+            const fullDir = (0, path_1.join)(resolvedTestsRoot, specDir);
+            const specFiles = sampleFiles(fullDir, 5);
+            for (const sf of specFiles) {
+                const matches = sf.content.match(/(?:test|it|describe)\s*\(\s*['"`]([^'"`]+)/g);
+                if (matches) {
+                    specSamples.push(...matches.map((m) => m.replace(/(?:test|it|describe)\s*\(\s*['"`]/, '')));
+                }
+            }
+        }
+        sections.push(`## Family: ${family.id}${isTestOnly ? ' [TEST-ONLY — needs webappPaths/serverPaths]' : ''}
+Routes (guessed): ${JSON.stringify(family.routes)}
+Webapp paths: ${JSON.stringify(family.webappPaths)}
+Server paths: ${JSON.stringify(family.serverPaths)}
+Spec dirs: ${JSON.stringify(family.specDirs)}
+Tags: ${JSON.stringify(family.tags)}
+Features: ${family.features.map((f) => f.id).join(', ') || 'none'}
+
+Sample files (${samples.length}):
+${samples.map((s) => `### ${(0, path_1.relative)(projectRoot, s.path)}\n\`\`\`\n${s.content}\n\`\`\``).join('\n')}
+
+Test descriptions:
+${specSamples.length > 0 ? specSamples.map((d) => `- ${d}`).join('\n') : '(none found)'}
+`);
+    }
+    // Include source tree listing when we have test-only families
+    const sourceTreeSection = hasTestOnlyFamilies
+        ? `\n## Source Directory Structure\nUse this to suggest accurate webappPaths and serverPaths for test-only families:\n\`\`\`\n${getSourceTreeListing(projectRoot)}\n\`\`\`\n`
+        : '';
+    return `You are analyzing a codebase to enrich route-family definitions for an E2E test impact analysis tool.
+
+For each family below, provide:
+1. **priority**: P0 (critical user flow), P1 (important), or P2 (nice-to-have)
+2. **userFlows**: Array of human-readable flow names (e.g., "Create channel", "Search messages")
+3. **routes**: Improved URL patterns (e.g., "/{team}/channels/{channel}" instead of "/channels")
+4. **pageObjects**: Array of page object class names found in the code
+5. **components**: Array of UI component names relevant to this family
+6. **webappPaths**: Array of glob patterns for frontend source directories (e.g., "src/components/drafts/**"). REQUIRED for families marked [TEST-ONLY].
+7. **serverPaths**: Array of glob patterns for backend source directories. REQUIRED for families marked [TEST-ONLY].
+
+Respond in JSON format:
+\`\`\`json
+[
+  {
+    "id": "family_id",
+    "priority": "P0",
+    "userFlows": ["Flow name 1", "Flow name 2"],
+    "routes": ["/improved/route/{param}"],
+    "pageObjects": ["PageName"],
+    "components": ["ComponentName"],
+    "webappPaths": ["src/components/feature_name/**"],
+    "serverPaths": ["server/channels/api4/feature.go"]
+  }
+]
+\`\`\`
+${sourceTreeSection}
+${sections.join('\n---\n')}`;
+}
+function validateEntries(parsed) {
+    const filterStrings = (arr, maxLen) => {
+        if (!Array.isArray(arr))
+            return undefined;
+        const filtered = arr.filter((v) => typeof v === 'string' && v.length < maxLen);
+        return filtered.length > 0 ? filtered : undefined;
+    };
+    return parsed
+        .filter((e) => !!e && typeof e.id === 'string')
+        .map((entry) => ({
+        id: entry.id,
+        priority: ['P0', 'P1', 'P2'].includes(entry.priority) ? entry.priority : undefined,
+        routes: filterStrings(entry.routes, 200),
+        userFlows: filterStrings(entry.userFlows, 500),
+        pageObjects: filterStrings(entry.pageObjects, 200),
+        components: filterStrings(entry.components, 200),
+        webappPaths: filterStrings(entry.webappPaths, 300),
+        serverPaths: filterStrings(entry.serverPaths, 300),
+    }));
+}
+function parseEnrichResponse(response) {
+    // Extract JSON from response (may be wrapped in markdown code block)
+    const jsonMatch = response.match(/```(?:json)?\s*([\s\S]*?)```/) || [null, response];
+    const jsonStr = jsonMatch[1]?.trim() || response.trim();
+    try {
+        const parsed = JSON.parse(jsonStr);
+        if (Array.isArray(parsed)) {
+            return validateEntries(parsed);
+        }
+    }
+    catch {
+        // Try to find any JSON array in the response
+        const arrayMatch = response.match(/\[[\s\S]*\]/);
+        if (arrayMatch) {
+            try {
+                const parsed = JSON.parse(arrayMatch[0]);
+                if (Array.isArray(parsed)) {
+                    return validateEntries(parsed);
+                }
+            }
+            catch {
+                // give up
+            }
+        }
+    }
+    return [];
+}
+function applyEnrichment(family, enriched) {
+    const result = { ...family };
+    if (enriched.priority && !family.priority) {
+        result.priority = enriched.priority;
+    }
+    if (enriched.userFlows && (!family.userFlows || family.userFlows.length === 0)) {
+        result.userFlows = enriched.userFlows;
+    }
+    if (enriched.routes && enriched.routes.length > 0) {
+        // Only replace if current routes look like guesses
+        if ((0, types_js_1.isGuessedRoute)(family.routes)) {
+            result.routes = enriched.routes;
+        }
+    }
+    if (enriched.pageObjects && (!family.pageObjects || family.pageObjects.length === 0)) {
+        result.pageObjects = enriched.pageObjects;
+    }
+    if (enriched.components && (!family.components || family.components.length === 0)) {
+        result.components = enriched.components;
+    }
+    // Only fill source paths when the family has none (test-derived families)
+    if (enriched.webappPaths && (!family.webappPaths || family.webappPaths.length === 0)) {
+        result.webappPaths = enriched.webappPaths;
+    }
+    if (enriched.serverPaths && (!family.serverPaths || family.serverPaths.length === 0)) {
+        result.serverPaths = enriched.serverPaths;
+    }
+    return result;
+}
+async function enrichFamilies(families, scanned, projectRoot, provider, budgetUSD, testsRoot) {
+    const scannedMap = new Map(scanned.map((s) => [s.id, s]));
+    const enriched = [];
+    let totalTokens = 0;
+    let totalCost = 0;
+    let requestCount = 0;
+    let totalResponseMs = 0;
+    const skipped = [];
+    // Process in chunks of 4 families
+    const chunkSize = 4;
+    for (let i = 0; i < families.length; i += chunkSize) {
+        if (totalCost >= budgetUSD) {
+            for (let j = i; j < families.length; j++) {
+                skipped.push(families[j].id);
+                enriched.push(families[j]);
+            }
+            break;
+        }
+        const chunk = families.slice(i, i + chunkSize);
+        const scannedChunk = chunk
+            .map((f) => scannedMap.get(f.id))
+            .filter((s) => s !== undefined);
+        if (scannedChunk.length === 0) {
+            enriched.push(...chunk);
+            continue;
+        }
+        let prompt = buildEnrichPrompt(scannedChunk, projectRoot, testsRoot);
+        if (prompt.length > MAX_PROMPT_CHARS) {
+            // Truncate at the last complete section boundary to avoid malformed input
+            const lastSectionEnd = prompt.lastIndexOf('\n---\n', MAX_PROMPT_CHARS);
+            if (lastSectionEnd > 0) {
+                logger_js_1.logger.warn(`[train] Prompt truncated from ${prompt.length} chars at section boundary`);
+                prompt = prompt.slice(0, lastSectionEnd);
+            }
+            else {
+                logger_js_1.logger.warn(`[train] Prompt truncated from ${prompt.length} to ${MAX_PROMPT_CHARS} chars`);
+                prompt = prompt.slice(0, MAX_PROMPT_CHARS);
+            }
+        }
+        let timeoutTimer;
+        try {
+            const timeoutPromise = new Promise((_, reject) => {
+                timeoutTimer = setTimeout(() => reject(new Error('LLM request timed out')), LLM_TIMEOUT_MS);
+            });
+            const reqStart = performance.now();
+            const response = await Promise.race([
+                provider.generateText(prompt, { maxTokens: 4096, temperature: 0.3 }),
+                timeoutPromise,
+            ]);
+            totalResponseMs += performance.now() - reqStart;
+            requestCount++;
+            totalTokens += (response.usage?.inputTokens ?? 0) + (response.usage?.outputTokens ?? 0);
+            totalCost += response.cost ?? 0;
+            const entries = parseEnrichResponse(response.text);
+            const entryMap = new Map(entries.map((e) => [e.id, e]));
+            for (const family of chunk) {
+                const entry = entryMap.get(family.id);
+                if (entry) {
+                    enriched.push(applyEnrichment(family, entry));
+                }
+                else {
+                    enriched.push(family);
+                }
+            }
+        }
+        catch (error) {
+            // On LLM failure, keep families unchanged
+            logger_js_1.logger.warn(`[train] LLM enrichment failed for chunk: ${error instanceof Error ? error.message : String(error)}`);
+            enriched.push(...chunk);
+        }
+        finally {
+            if (timeoutTimer)
+                clearTimeout(timeoutTimer);
+        }
+    }
+    return {
+        enrichedFamilies: enriched,
+        tokensUsed: totalTokens,
+        costUSD: Math.round(totalCost * 100) / 100,
+        skippedFamilies: skipped,
+        requestCount,
+        avgResponseMs: requestCount > 0 ? Math.round(totalResponseMs / requestCount) : 0,
+    };
+}

package/dist/training/kg_scanner.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Converts an Understand-Anything knowledge graph into the same ScanResult
+ * format produced by the filesystem scanner. This allows the existing
+ * merge/enrich/validate pipeline to work unchanged with KG input.
+ */
+import type { KnowledgeGraph } from '../knowledge/kg_types.js';
+import type { ScanResult } from './types.js';
+/**
+ * Converts KG nodes/edges into a ScanResult compatible with the filesystem scanner output.
+ * Groups nodes by their containing module/directory to form families.
+ */
+export declare function scanFromKnowledgeGraph(kg: KnowledgeGraph): ScanResult;
+//# sourceMappingURL=kg_scanner.d.ts.map

package/dist/training/kg_scanner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"kg_scanner.d.ts","sourceRoot":"","sources":["../../src/training/kg_scanner.ts"],"names":[],"mappings":"AAGA;;;;GAIG;AAEH,OAAO,KAAK,EAAC,cAAc,EAAS,MAAM,0BAA0B,CAAC;AAErE,OAAO,KAAK,EAAC,UAAU,EAAgC,MAAM,YAAY,CAAC;AAE1E;;;GAGG;AACH,wBAAgB,sBAAsB,CAAC,EAAE,EAAE,cAAc,GAAG,UAAU,CA4FrE"}

package/dist/training/kg_scanner.js

@@ -0,0 +1,118 @@
+"use strict";
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scanFromKnowledgeGraph = scanFromKnowledgeGraph;
+const cluster_utils_js_1 = require("../knowledge/cluster_utils.js");
+/**
+ * Converts KG nodes/edges into a ScanResult compatible with the filesystem scanner output.
+ * Groups nodes by their containing module/directory to form families.
+ */
+function scanFromKnowledgeGraph(kg) {
+    const clusters = new Map();
+    // Group nodes into clusters by directory/module
+    for (const node of kg.nodes) {
+        if (node.layer === 'infra')
+            continue; // skip infrastructure nodes
+        const clusterId = (0, cluster_utils_js_1.deriveClusterId)(node, cluster_utils_js_1.SKIP_DIRS_WITH_TESTS);
+        if (!clusterId)
+            continue;
+        if (!clusters.has(clusterId)) {
+            clusters.set(clusterId, []);
+        }
+        clusters.get(clusterId).push(node);
+    }
+    let totalSourceFiles = 0;
+    let totalTestFiles = 0;
+    const families = [];
+    for (const [id, nodes] of clusters) {
+        const webappPaths = [];
+        const serverPaths = [];
+        const specDirs = [];
+        const tags = [];
+        const seenDirs = new Set();
+        for (const node of nodes) {
+            if (!node.filePath)
+                continue;
+            const normalized = node.filePath.replace(/\\/g, '/');
+            if (node.layer === 'test') {
+                totalTestFiles++;
+                const dir = normalized.split('/').slice(0, -1).join('/');
+                if (dir && !seenDirs.has(dir)) {
+                    seenDirs.add(dir);
+                    specDirs.push(dir + '/');
+                }
+                continue;
+            }
+            totalSourceFiles++;
+            const glob = buildGlobFromPath(normalized);
+            if (node.layer === 'api' || node.layer === 'service' || node.layer === 'data') {
+                serverPaths.push(glob);
+            }
+            else if (node.layer === 'ui') {
+                webappPaths.push(glob);
+            }
+            else {
+                // Default assignment based on file path heuristics
+                if (isLikelyServerPath(normalized)) {
+                    serverPaths.push(glob);
+                }
+                else {
+                    webappPaths.push(glob);
+                }
+            }
+            // Extract tags from node metadata
+            if (node.tags) {
+                tags.push(...node.tags);
+            }
+        }
+        if (webappPaths.length === 0 && serverPaths.length === 0 && specDirs.length === 0) {
+            continue;
+        }
+        families.push({
+            id,
+            routes: [`/${id}`],
+            webappPaths: [...new Set(webappPaths)],
+            serverPaths: [...new Set(serverPaths)],
+            specDirs: [...new Set(specDirs)],
+            cypressSpecDirs: [],
+            tags: [...new Set(tags)],
+            features: [],
+            routesGuessed: true,
+        });
+    }
+    return {
+        families,
+        unmatchedSourceDirs: [],
+        unmatchedTestDirs: [],
+        stats: {
+            totalSourceFiles,
+            totalTestFiles,
+            familyCount: families.length,
+        },
+    };
+}
+// ---------------------------------------------------------------------------
+// Internal helpers
+// ---------------------------------------------------------------------------
+// deriveClusterId and deriveClusterIdFromPath imported from cluster_utils.ts
+function buildGlobFromPath(filePath) {
+    // Reject paths with traversal or null bytes
+    if (filePath.includes('..') || filePath.includes('\0')) {
+        return '';
+    }
+    // Convert a file path to a glob pattern matching the directory
+    const dir = filePath.split('/').slice(0, -1).join('/');
+    return dir ? `${dir}/*` : `${filePath}*`;
+}
+function isLikelyServerPath(filePath) {
+    const lower = filePath.toLowerCase();
+    return lower.includes('/server/') ||
+        lower.includes('/api/') ||
+        lower.includes('/routes/') ||
+        lower.includes('/controllers/') ||
+        lower.includes('/services/') ||
+        lower.includes('/models/') ||
+        lower.endsWith('.go') ||
+        lower.endsWith('.py');
+}

package/dist/training/merger.d.ts

@@ -0,0 +1,15 @@
+import type { RouteFamilyManifest } from '../knowledge/route_families.js';
+import type { MergeResult, ScannedFamily } from './types.js';
+export declare function mergeFamilies(existing: RouteFamilyManifest | null, scanned: ScannedFamily[]): MergeResult;
+/**
+ * Detect families whose paths no longer exist on disk.
+ *
+ * Paths in the manifest may be relative to different roots:
+ * - webappPaths / serverPaths are typically relative to the repo root
+ * - specDirs may be relative to the tests root
+ *
+ * We try each pattern against all provided roots (and the git repo root
+ * if discoverable) to avoid false positives from path-prefix mismatches.
+ */
+export declare function detectStaleFamilies(manifest: RouteFamilyManifest, projectRoot: string, testsRoot?: string): string[];
+//# sourceMappingURL=merger.d.ts.map

package/dist/training/merger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"merger.d.ts","sourceRoot":"","sources":["../../src/training/merger.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAc,mBAAmB,EAAC,MAAM,gCAAgC,CAAC;AAGrF,OAAO,KAAK,EAAC,WAAW,EAAE,aAAa,EAAC,MAAM,YAAY,CAAC;AAkF3D,wBAAgB,aAAa,CACzB,QAAQ,EAAE,mBAAmB,GAAG,IAAI,EACpC,OAAO,EAAE,aAAa,EAAE,GACzB,WAAW,CA+Cb;AAED;;;;;;;;;GASG;AACH,wBAAgB,mBAAmB,CAC/B,QAAQ,EAAE,mBAAmB,EAC7B,WAAW,EAAE,MAAM,EACnB,SAAS,CAAC,EAAE,MAAM,GACnB,MAAM,EAAE,CA6DV"}