@yasserkhanorg/impact-gate 2.0.0

package/dist/esm/training/enricher.js

@@ -0,0 +1,345 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+import { lstatSync, readdirSync, readFileSync } from 'fs';
+import { join, relative, resolve } from 'path';
+import { logger } from '../logger.js';
+import { isGuessedRoute } from './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 readdirSync(d)) {
+                if (files.length >= maxFiles)
+                    return;
+                // Skip dot-dirs and known heavy directories
+                if (entry.startsWith('.') || SKIP_DIRS.has(entry))
+                    continue;
+                const full = join(d, entry);
+                try {
+                    // Skip symlinks
+                    const lstat = lstatSync(full);
+                    if (lstat.isSymbolicLink())
+                        continue;
+                    // Skip sensitive files (test against relative path from scan root)
+                    const relPath = 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 = 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 = readdirSync(dir).sort();
+        }
+        catch {
+            return;
+        }
+        const dirs = entries.filter((e) => {
+            if (e.startsWith('.') || SKIP_DIRS.has(e))
+                return false;
+            try {
+                const stat = lstatSync(join(dir, e));
+                return !stat.isSymbolicLink() && stat.isDirectory();
+            }
+            catch {
+                return false;
+            }
+        });
+        for (const d of dirs) {
+            lines.push(`${prefix}${d}/`);
+            walk(join(dir, d), depth + 1, prefix + '  ');
+        }
+    }
+    walk(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 ? resolve(testsRoot) : 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 = join(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 = 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 = 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) => `### ${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')}`;
+}
+export 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),
+    }));
+}
+export 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 (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;
+}
+export 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.warn(`[train] Prompt truncated from ${prompt.length} chars at section boundary`);
+                prompt = prompt.slice(0, lastSectionEnd);
+            }
+            else {
+                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.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/esm/training/kg_scanner.js

@@ -0,0 +1,115 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+import { deriveClusterId, SKIP_DIRS_WITH_TESTS } from '../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.
+ */
+export 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 = deriveClusterId(node, 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/esm/training/merger.js

@@ -0,0 +1,204 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+import { execFileSync } from 'child_process';
+import { existsSync } from 'fs';
+import { join, resolve } from 'path';
+import { isGuessedRoute } from './types.js';
+function unionArrays(existing, incoming) {
+    const set = new Set(existing || []);
+    for (const item of incoming) {
+        set.add(item);
+    }
+    return Array.from(set);
+}
+function mergeFamily(existing, scanned) {
+    const merged = { ...existing };
+    // Structural fields: union arrays
+    merged.webappPaths = unionArrays(existing.webappPaths, scanned.webappPaths);
+    merged.serverPaths = unionArrays(existing.serverPaths, scanned.serverPaths);
+    merged.specDirs = unionArrays(existing.specDirs, scanned.specDirs);
+    merged.cypressSpecDirs = unionArrays(existing.cypressSpecDirs, scanned.cypressSpecDirs);
+    merged.tags = unionArrays(existing.tags, scanned.tags);
+    // Routes: only update if existing looks like a guess
+    if (isGuessedRoute(existing.routes) && !isGuessedRoute(scanned.routes)) {
+        merged.routes = scanned.routes;
+    }
+    // Human-curated fields: never overwrite (priority, userFlows, pageObjects, components)
+    // Merge features
+    if (scanned.features.length > 0) {
+        const existingFeatures = existing.features || [];
+        const existingIds = new Set(existingFeatures.map((f) => f.id));
+        const newFeatures = scanned.features.filter((f) => !existingIds.has(f.id));
+        if (newFeatures.length > 0) {
+            merged.features = [
+                ...existingFeatures,
+                ...newFeatures.map((f) => ({
+                    id: f.id,
+                    webappPaths: f.webappPaths,
+                    serverPaths: f.serverPaths,
+                    specDirs: f.specDirs,
+                })),
+            ];
+        }
+    }
+    return merged;
+}
+function scannedToRouteFamily(scanned) {
+    const family = {
+        id: scanned.id,
+        routes: scanned.routes,
+    };
+    if (scanned.webappPaths.length > 0)
+        family.webappPaths = scanned.webappPaths;
+    if (scanned.serverPaths.length > 0)
+        family.serverPaths = scanned.serverPaths;
+    if (scanned.specDirs.length > 0)
+        family.specDirs = scanned.specDirs;
+    if (scanned.cypressSpecDirs.length > 0)
+        family.cypressSpecDirs = scanned.cypressSpecDirs;
+    if (scanned.tags.length > 0)
+        family.tags = scanned.tags;
+    if (scanned.features.length > 0) {
+        family.features = scanned.features.map((f) => ({
+            id: f.id,
+            webappPaths: f.webappPaths.length > 0 ? f.webappPaths : undefined,
+            serverPaths: f.serverPaths.length > 0 ? f.serverPaths : undefined,
+            specDirs: f.specDirs.length > 0 ? f.specDirs : undefined,
+        }));
+    }
+    return family;
+}
+/**
+ * Try to find a matching family ID with singular/plural normalization.
+ * "team" matches "teams", "emoji" matches "emoji", etc.
+ */
+function findFuzzyMatch(id, idMap) {
+    if (idMap.has(id))
+        return id;
+    // Try adding 's'
+    if (!id.endsWith('s') && idMap.has(id + 's'))
+        return id + 's';
+    // Try removing 's'
+    if (id.endsWith('s') && idMap.has(id.slice(0, -1)))
+        return id.slice(0, -1);
+    return undefined;
+}
+export function mergeFamilies(existing, scanned) {
+    const existingFamilies = existing?.families || [];
+    const existingMap = new Map(existingFamilies.map((f) => [f.id, f]));
+    const scannedMap = new Map(scanned.map((f) => [f.id, f]));
+    const newFamilies = [];
+    const updatedFamilies = [];
+    const mergedFamilies = [];
+    // Process existing families — match scanned by exact or fuzzy ID
+    for (const ef of existingFamilies) {
+        let sf = scannedMap.get(ef.id);
+        // Try singular/plural match if exact match failed
+        if (!sf) {
+            const fuzzyId = findFuzzyMatch(ef.id, scannedMap);
+            if (fuzzyId)
+                sf = scannedMap.get(fuzzyId);
+        }
+        if (sf) {
+            mergedFamilies.push(mergeFamily(ef, sf));
+            updatedFamilies.push(ef.id);
+        }
+        else {
+            // Keep untouched
+            mergedFamilies.push({ ...ef });
+        }
+    }
+    // Add new families from scanner (if no existing family matched)
+    for (const sf of scanned) {
+        const matchedExisting = findFuzzyMatch(sf.id, existingMap);
+        if (!matchedExisting) {
+            mergedFamilies.push(scannedToRouteFamily(sf));
+            newFamilies.push(sf.id);
+        }
+    }
+    const parts = [];
+    if (updatedFamilies.length > 0)
+        parts.push(`${updatedFamilies.length} families updated`);
+    if (newFamilies.length > 0)
+        parts.push(`${newFamilies.length} new families added`);
+    if (parts.length === 0)
+        parts.push('no changes');
+    return {
+        manifest: { families: mergedFamilies, source: existing?.source || 'train-scan' },
+        newFamilies,
+        updatedFamilies,
+        staleFamilies: [],
+        summary: parts.join(', '),
+    };
+}
+/**
+ * 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 function detectStaleFamilies(manifest, projectRoot, testsRoot) {
+    const roots = new Set([resolve(projectRoot)]);
+    if (testsRoot)
+        roots.add(resolve(testsRoot));
+    // Also try to discover the git repo root — manifest paths may be repo-relative
+    try {
+        const gitRoot = execFileSync('git', ['rev-parse', '--show-toplevel'], {
+            cwd: projectRoot,
+            encoding: 'utf-8',
+            stdio: ['pipe', 'pipe', 'pipe'],
+        }).trim();
+        if (gitRoot)
+            roots.add(resolve(gitRoot));
+    }
+    catch {
+        // Not a git repo or git not available — that's fine
+    }
+    const stale = [];
+    for (const family of manifest.families) {
+        const allPatterns = [
+            ...(family.webappPaths || []),
+            ...(family.serverPaths || []),
+            ...(family.specDirs || []),
+        ];
+        if (allPatterns.length === 0)
+            continue;
+        // Check if any pattern resolves to existing files/dirs in any root
+        let hasAny = false;
+        for (const pattern of allPatterns) {
+            // Strip trailing glob (* or **) to get the directory
+            const dirPart = pattern.replace(/\/?\*.*$/, '');
+            if (!dirPart)
+                continue;
+            // For file-level patterns like "server/channels/api4/draft*.go",
+            // dirPart is "server/channels/api4/draft" — check the parent dir instead
+            const isFileGlob = /\.\w+$/.test(pattern);
+            const pathsToCheck = [dirPart];
+            if (isFileGlob) {
+                const parentDir = dirPart.split('/').slice(0, -1).join('/');
+                if (parentDir)
+                    pathsToCheck.push(parentDir);
+            }
+            for (const checkPath of pathsToCheck) {
+                for (const root of roots) {
+                    if (existsSync(join(root, checkPath))) {
+                        hasAny = true;
+                        break;
+                    }
+                }
+                if (hasAny)
+                    break;
+            }
+            if (hasAny)
+                break;
+        }
+        if (!hasAny) {
+            stale.push(family.id);
+        }
+    }
+    return stale;
+}