@syke1/mcp-server 1.4.17 → 1.4.18

package/dist/ai/realtime-analyzer.js

@@ -112,7 +112,7 @@ async function analyzeChangeRealtime(change, graph, getFileContent) {
     const absPath = path.normalize(path.join(graph.sourceDir, relPath));
     let affectedNodes = [];
     if (graph.files.has(absPath)) {
-        const impact = (0, analyze_impact_1.analyzeImpact)(absPath, graph);
+        const impact = await (0, analyze_impact_1.analyzeImpact)(absPath, graph);
         affectedNodes = [...impact.directDependents, ...impact.transitiveDependents];
     }
     // Build context: changed file + top 5 connected files' smart context

package/dist/git/change-coupling.d.ts

@@ -0,0 +1,41 @@
+export interface ChangeCoupling {
+    file1: string;
+    file2: string;
+    coChangeCount: number;
+    file1Changes: number;
+    file2Changes: number;
+    confidence: number;
+    support: number;
+}
+export interface CouplingResult {
+    couplings: ChangeCoupling[];
+    fileCouplings: Map<string, ChangeCoupling[]>;
+    totalCommitsAnalyzed: number;
+    analyzedAt: number;
+}
+export interface CouplingOptions {
+    maxCommits?: number;
+    minSupport?: number;
+    minConfidence?: number;
+    maxFilesPerCommit?: number;
+}
+/**
+ * Invalidate the coupling cache. Call this when the graph is refreshed
+ * or when git history may have changed.
+ */
+export declare function invalidateCouplingCache(): void;
+/**
+ * Mine git history to find files that frequently co-change.
+ *
+ * Runs `git log --name-only` and analyzes pairwise file combinations
+ * within each commit to identify hidden logical dependencies.
+ */
+export declare function mineGitHistory(projectRoot: string, options?: CouplingOptions): Promise<CouplingResult>;
+/**
+ * Get all significant couplings for a given file path.
+ * Returns an empty array if no couplings are found.
+ *
+ * The filePath should be a relative path matching git log output format
+ * (forward slashes, relative to project root).
+ */
+export declare function getCoupledFiles(filePath: string, result: CouplingResult): ChangeCoupling[];

package/dist/git/change-coupling.js

@@ -0,0 +1,250 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.invalidateCouplingCache = invalidateCouplingCache;
+exports.mineGitHistory = mineGitHistory;
+exports.getCoupledFiles = getCoupledFiles;
+const child_process_1 = require("child_process");
+// ── Defaults ──
+const DEFAULT_MAX_COMMITS = 500;
+const DEFAULT_MIN_SUPPORT = 3;
+const DEFAULT_MIN_CONFIDENCE = 0.3;
+const DEFAULT_MAX_FILES_PER_COMMIT = 20;
+const CACHE_TTL_MS = 5 * 60 * 1000; // 5 minutes
+// ── Cache ──
+let cachedResult = null;
+let cachedProjectRoot = null;
+/**
+ * Invalidate the coupling cache. Call this when the graph is refreshed
+ * or when git history may have changed.
+ */
+function invalidateCouplingCache() {
+    cachedResult = null;
+    cachedProjectRoot = null;
+}
+// ── Git History Mining ──
+/**
+ * Check whether the given directory is inside a git repository.
+ */
+function isGitRepo(projectRoot) {
+    try {
+        (0, child_process_1.execSync)("git rev-parse --is-inside-work-tree", {
+            cwd: projectRoot,
+            encoding: "utf-8",
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Parse git log output into a list of commits, each containing
+ * the list of files changed in that commit.
+ */
+function parseGitLog(raw) {
+    const commits = [];
+    const segments = raw.split("COMMIT:");
+    for (const segment of segments) {
+        const trimmed = segment.trim();
+        if (!trimmed)
+            continue;
+        // First line is the commit hash, remaining lines are file paths
+        const lines = trimmed.split("\n");
+        const files = [];
+        for (let i = 1; i < lines.length; i++) {
+            const fileLine = lines[i].trim();
+            if (fileLine) {
+                files.push(fileLine);
+            }
+        }
+        if (files.length > 0) {
+            commits.push(files);
+        }
+    }
+    return commits;
+}
+/**
+ * Normalize a git-output path (forward slashes) to be consistent
+ * with how the dependency graph stores paths.
+ */
+function normalizePath(filePath) {
+    // Git always outputs forward slashes; normalize for consistency
+    return filePath.replace(/\\/g, "/");
+}
+/**
+ * Check if a file path looks like a source file (not binary, not config noise).
+ * We keep this broad — the dependency graph comparison will handle the real filtering.
+ */
+function isSourceFile(filePath) {
+    // Skip obviously non-source files
+    const skipPatterns = [
+        /\.lock$/,
+        /package-lock\.json$/,
+        /yarn\.lock$/,
+        /\.min\.(js|css)$/,
+        /\.map$/,
+        /\.d\.ts$/,
+        /\.png$/,
+        /\.jpg$/,
+        /\.jpeg$/,
+        /\.gif$/,
+        /\.svg$/,
+        /\.ico$/,
+        /\.woff2?$/,
+        /\.ttf$/,
+        /\.eot$/,
+        /\.pdf$/,
+        /\.zip$/,
+        /\.tar$/,
+        /\.gz$/,
+    ];
+    const normalized = filePath.toLowerCase();
+    return !skipPatterns.some((p) => p.test(normalized));
+}
+/**
+ * Create a canonical pair key for two files (order-independent).
+ */
+function pairKey(a, b) {
+    return a < b ? `${a}\0${b}` : `${b}\0${a}`;
+}
+/**
+ * Mine git history to find files that frequently co-change.
+ *
+ * Runs `git log --name-only` and analyzes pairwise file combinations
+ * within each commit to identify hidden logical dependencies.
+ */
+async function mineGitHistory(projectRoot, options) {
+    // Return cached result if still valid
+    if (cachedResult &&
+        cachedProjectRoot === projectRoot &&
+        Date.now() - cachedResult.analyzedAt < CACHE_TTL_MS) {
+        return cachedResult;
+    }
+    const maxCommits = options?.maxCommits ?? DEFAULT_MAX_COMMITS;
+    const minSupport = options?.minSupport ?? DEFAULT_MIN_SUPPORT;
+    const minConfidence = options?.minConfidence ?? DEFAULT_MIN_CONFIDENCE;
+    const maxFilesPerCommit = options?.maxFilesPerCommit ?? DEFAULT_MAX_FILES_PER_COMMIT;
+    // Empty result for non-git projects
+    const emptyResult = {
+        couplings: [],
+        fileCouplings: new Map(),
+        totalCommitsAnalyzed: 0,
+        analyzedAt: Date.now(),
+    };
+    if (!isGitRepo(projectRoot)) {
+        cachedResult = emptyResult;
+        cachedProjectRoot = projectRoot;
+        return emptyResult;
+    }
+    // Run git log
+    let raw;
+    try {
+        raw = (0, child_process_1.execSync)(`git log --name-only --format="COMMIT:%H" --max-count=${maxCommits}`, {
+            cwd: projectRoot,
+            encoding: "utf-8",
+            maxBuffer: 10 * 1024 * 1024,
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+    }
+    catch {
+        cachedResult = emptyResult;
+        cachedProjectRoot = projectRoot;
+        return emptyResult;
+    }
+    const commits = parseGitLog(raw);
+    // Track per-file change counts and per-pair co-change counts
+    const fileChangeCount = new Map();
+    const pairCoChangeCount = new Map();
+    let totalCommitsAnalyzed = 0;
+    for (const commitFiles of commits) {
+        // Filter to source files and normalize paths
+        const filtered = commitFiles
+            .map(normalizePath)
+            .filter(isSourceFile);
+        // Skip mega-commits (merge commits, large refactors)
+        if (filtered.length > maxFilesPerCommit || filtered.length < 2) {
+            if (filtered.length === 1) {
+                // Still count single-file commits for per-file totals
+                const file = filtered[0];
+                fileChangeCount.set(file, (fileChangeCount.get(file) || 0) + 1);
+            }
+            totalCommitsAnalyzed++;
+            continue;
+        }
+        totalCommitsAnalyzed++;
+        // Count per-file changes
+        for (const file of filtered) {
+            fileChangeCount.set(file, (fileChangeCount.get(file) || 0) + 1);
+        }
+        // Count pairwise co-changes
+        for (let i = 0; i < filtered.length; i++) {
+            for (let j = i + 1; j < filtered.length; j++) {
+                const key = pairKey(filtered[i], filtered[j]);
+                pairCoChangeCount.set(key, (pairCoChangeCount.get(key) || 0) + 1);
+            }
+        }
+    }
+    // Build coupling results, filtering by thresholds
+    const couplings = [];
+    for (const [key, coCount] of pairCoChangeCount) {
+        if (coCount < minSupport)
+            continue;
+        const [file1, file2] = key.split("\0");
+        const file1Changes = fileChangeCount.get(file1) || 0;
+        const file2Changes = fileChangeCount.get(file2) || 0;
+        const maxChanges = Math.max(file1Changes, file2Changes);
+        const confidence = maxChanges > 0 ? coCount / maxChanges : 0;
+        if (confidence < minConfidence)
+            continue;
+        couplings.push({
+            file1,
+            file2,
+            coChangeCount: coCount,
+            file1Changes,
+            file2Changes,
+            confidence,
+            support: coCount,
+        });
+    }
+    // Sort by confidence descending
+    couplings.sort((a, b) => b.confidence - a.confidence);
+    // Build the per-file lookup map
+    const fileCouplings = new Map();
+    for (const coupling of couplings) {
+        // Add to file1's list
+        if (!fileCouplings.has(coupling.file1)) {
+            fileCouplings.set(coupling.file1, []);
+        }
+        fileCouplings.get(coupling.file1).push(coupling);
+        // Add to file2's list
+        if (!fileCouplings.has(coupling.file2)) {
+            fileCouplings.set(coupling.file2, []);
+        }
+        fileCouplings.get(coupling.file2).push(coupling);
+    }
+    // Sort each file's couplings by confidence descending
+    for (const [, list] of fileCouplings) {
+        list.sort((a, b) => b.confidence - a.confidence);
+    }
+    const result = {
+        couplings,
+        fileCouplings,
+        totalCommitsAnalyzed,
+        analyzedAt: Date.now(),
+    };
+    cachedResult = result;
+    cachedProjectRoot = projectRoot;
+    return result;
+}
+/**
+ * Get all significant couplings for a given file path.
+ * Returns an empty array if no couplings are found.
+ *
+ * The filePath should be a relative path matching git log output format
+ * (forward slashes, relative to project root).
+ */
+function getCoupledFiles(filePath, result) {
+    const normalized = normalizePath(filePath);
+    return result.fileCouplings.get(normalized) || [];
+}

package/dist/graph/incremental.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Incremental Graph Updates for SYKE.
+ *
+ * Instead of rebuilding the entire dependency graph when a single file changes,
+ * this module re-parses only the changed file's imports and updates the
+ * forward/reverse maps in place. SCC and PageRank are recomputed fully
+ * (both are O(V+E) and fast enough) only when edges actually change.
+ *
+ * This brings update latency from O(N * parse) down to O(1 * parse + V+E)
+ * for large codebases (10K+ files).
+ */
+import { DependencyGraph } from "../graph";
+export interface IncrementalUpdateResult {
+    updatedFile: string;
+    addedEdges: [string, string][];
+    removedEdges: [string, string][];
+    edgesChanged: boolean;
+    affectedFiles: string[];
+}
+/**
+ * Update the graph for a single changed file.
+ * Re-parses only that file's imports and updates forward/reverse maps.
+ * Returns info about what changed for cache invalidation.
+ */
+export declare function updateGraphForFile(graph: DependencyGraph, filePath: string, projectRoot: string): IncrementalUpdateResult;
+/**
+ * Add a new file to the graph.
+ * Initializes forward/reverse entries, parses imports, and adds edges.
+ */
+export declare function addFileToGraph(graph: DependencyGraph, filePath: string, projectRoot: string): IncrementalUpdateResult;
+/**
+ * Remove a file from the graph.
+ * Cleans up all forward edges, reverse edges, and the files set.
+ */
+export declare function removeFileFromGraph(graph: DependencyGraph, filePath: string): IncrementalUpdateResult;

package/dist/graph/incremental.js

@@ -0,0 +1,319 @@
+"use strict";
+/**
+ * Incremental Graph Updates for SYKE.
+ *
+ * Instead of rebuilding the entire dependency graph when a single file changes,
+ * this module re-parses only the changed file's imports and updates the
+ * forward/reverse maps in place. SCC and PageRank are recomputed fully
+ * (both are O(V+E) and fast enough) only when edges actually change.
+ *
+ * This brings update latency from O(N * parse) down to O(1 * parse + V+E)
+ * for large codebases (10K+ files).
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateGraphForFile = updateGraphForFile;
+exports.addFileToGraph = addFileToGraph;
+exports.removeFileFromGraph = removeFileFromGraph;
+const path = __importStar(require("path"));
+const plugin_1 = require("../languages/plugin");
+const scc_1 = require("./scc");
+const pagerank_1 = require("../scoring/pagerank");
+const risk_scorer_1 = require("../scoring/risk-scorer");
+// ── Core Functions ──
+/**
+ * Update the graph for a single changed file.
+ * Re-parses only that file's imports and updates forward/reverse maps.
+ * Returns info about what changed for cache invalidation.
+ */
+function updateGraphForFile(graph, filePath, projectRoot) {
+    const normalized = path.normalize(filePath);
+    // If file is not in the graph, treat as a new file addition
+    if (!graph.files.has(normalized)) {
+        return addFileToGraph(graph, filePath, projectRoot);
+    }
+    // 1. Get old forward edges for this file
+    const oldDeps = graph.forward.get(normalized) || [];
+    const oldDepsSet = new Set(oldDeps);
+    // 2. Determine which language plugin handles this file
+    const plugin = (0, plugin_1.getPluginForFile)(normalized);
+    if (!plugin) {
+        // No plugin can handle this file extension - nothing to update
+        return {
+            updatedFile: normalized,
+            addedEdges: [],
+            removedEdges: [],
+            edgesChanged: false,
+            affectedFiles: [],
+        };
+    }
+    // 3. Find the appropriate source directory for this file
+    const sourceDir = findSourceDirForFile(normalized, graph);
+    // 4. Re-parse imports for this file
+    const rawImports = plugin.parseImports(normalized, projectRoot, sourceDir);
+    // 5. Filter to only include files that exist in the graph (internal deps)
+    const newDeps = rawImports.filter(imp => graph.files.has(imp));
+    const newDepsSet = new Set(newDeps);
+    // 6. Compute diff
+    const addedEdges = [];
+    const removedEdges = [];
+    for (const dep of newDeps) {
+        if (!oldDepsSet.has(dep)) {
+            addedEdges.push([normalized, dep]);
+        }
+    }
+    for (const dep of oldDeps) {
+        if (!newDepsSet.has(dep)) {
+            removedEdges.push([normalized, dep]);
+        }
+    }
+    const edgesChanged = addedEdges.length > 0 || removedEdges.length > 0;
+    // 7. Update forward map
+    graph.forward.set(normalized, newDeps);
+    // 8. Update reverse map for removed edges
+    for (const [, dep] of removedEdges) {
+        const revList = graph.reverse.get(dep);
+        if (revList) {
+            const idx = revList.indexOf(normalized);
+            if (idx !== -1) {
+                revList.splice(idx, 1);
+            }
+        }
+    }
+    // 9. Update reverse map for added edges
+    for (const [, dep] of addedEdges) {
+        const revList = graph.reverse.get(dep);
+        if (revList) {
+            if (!revList.includes(normalized)) {
+                revList.push(normalized);
+            }
+        }
+        else {
+            graph.reverse.set(dep, [normalized]);
+        }
+    }
+    // 10. Compute affected files (reverse transitive closure of the changed file)
+    const affectedFiles = computeAffectedFiles(normalized, graph);
+    // 11. If edges changed, recompute SCC and PageRank
+    if (edgesChanged) {
+        recomputeGraphMetrics(graph);
+    }
+    return {
+        updatedFile: normalized,
+        addedEdges,
+        removedEdges,
+        edgesChanged,
+        affectedFiles,
+    };
+}
+/**
+ * Add a new file to the graph.
+ * Initializes forward/reverse entries, parses imports, and adds edges.
+ */
+function addFileToGraph(graph, filePath, projectRoot) {
+    const normalized = path.normalize(filePath);
+    // Already in graph? Treat as an update instead
+    if (graph.files.has(normalized)) {
+        return updateGraphForFile(graph, filePath, projectRoot);
+    }
+    // 1. Add to the files set
+    graph.files.add(normalized);
+    // 2. Initialize forward entry
+    graph.forward.set(normalized, []);
+    // 3. Initialize reverse entry if not exists
+    if (!graph.reverse.has(normalized)) {
+        graph.reverse.set(normalized, []);
+    }
+    // 4. Determine which plugin handles this file
+    const plugin = (0, plugin_1.getPluginForFile)(normalized);
+    if (!plugin) {
+        return {
+            updatedFile: normalized,
+            addedEdges: [],
+            removedEdges: [],
+            edgesChanged: false,
+            affectedFiles: [],
+        };
+    }
+    // 5. Find source directory
+    const sourceDir = findSourceDirForFile(normalized, graph);
+    // 6. Parse imports
+    const rawImports = plugin.parseImports(normalized, projectRoot, sourceDir);
+    const newDeps = rawImports.filter(imp => graph.files.has(imp));
+    const addedEdges = [];
+    // 7. Set forward edges
+    graph.forward.set(normalized, newDeps);
+    // 8. Update reverse maps for new edges
+    for (const dep of newDeps) {
+        addedEdges.push([normalized, dep]);
+        const revList = graph.reverse.get(dep);
+        if (revList) {
+            if (!revList.includes(normalized)) {
+                revList.push(normalized);
+            }
+        }
+        else {
+            graph.reverse.set(dep, [normalized]);
+        }
+    }
+    // 9. Check if any existing file imports this new file
+    //    (their forward edges might now resolve to this file)
+    //    This is hard to detect without re-parsing all files,
+    //    so we skip it — the next full refresh will catch it.
+    //    The conservative approach is to just note that edges changed.
+    const edgesChanged = addedEdges.length > 0;
+    const affectedFiles = computeAffectedFiles(normalized, graph);
+    if (edgesChanged) {
+        recomputeGraphMetrics(graph);
+    }
+    return {
+        updatedFile: normalized,
+        addedEdges,
+        removedEdges: [],
+        edgesChanged,
+        affectedFiles,
+    };
+}
+/**
+ * Remove a file from the graph.
+ * Cleans up all forward edges, reverse edges, and the files set.
+ */
+function removeFileFromGraph(graph, filePath) {
+    const normalized = path.normalize(filePath);
+    if (!graph.files.has(normalized)) {
+        // File wasn't in graph, nothing to do
+        return {
+            updatedFile: normalized,
+            addedEdges: [],
+            removedEdges: [],
+            edgesChanged: false,
+            affectedFiles: [],
+        };
+    }
+    // Compute affected files BEFORE removing (need the reverse graph intact)
+    const affectedFiles = computeAffectedFiles(normalized, graph);
+    const removedEdges = [];
+    // 1. Remove all forward edges (this file imports X)
+    const forwardDeps = graph.forward.get(normalized) || [];
+    for (const dep of forwardDeps) {
+        removedEdges.push([normalized, dep]);
+        // Remove this file from dep's reverse list
+        const revList = graph.reverse.get(dep);
+        if (revList) {
+            const idx = revList.indexOf(normalized);
+            if (idx !== -1) {
+                revList.splice(idx, 1);
+            }
+        }
+    }
+    // 2. Remove all reverse edges (X imports this file)
+    const reverseDeps = graph.reverse.get(normalized) || [];
+    for (const src of reverseDeps) {
+        removedEdges.push([src, normalized]);
+        // Remove this file from src's forward list
+        const fwdList = graph.forward.get(src);
+        if (fwdList) {
+            const idx = fwdList.indexOf(normalized);
+            if (idx !== -1) {
+                fwdList.splice(idx, 1);
+            }
+        }
+    }
+    // 3. Clean up maps
+    graph.forward.delete(normalized);
+    graph.reverse.delete(normalized);
+    graph.files.delete(normalized);
+    const edgesChanged = removedEdges.length > 0;
+    if (edgesChanged) {
+        recomputeGraphMetrics(graph);
+    }
+    return {
+        updatedFile: normalized,
+        addedEdges: [],
+        removedEdges,
+        edgesChanged,
+        affectedFiles,
+    };
+}
+// ── Internal Helpers ──
+/**
+ * Find the source directory that contains the given file.
+ * Falls back to graph.sourceDir if no match found.
+ */
+function findSourceDirForFile(filePath, graph) {
+    for (const dir of graph.sourceDirs) {
+        if (filePath.startsWith(dir)) {
+            return dir;
+        }
+    }
+    return graph.sourceDir;
+}
+/**
+ * Compute the set of files whose cached BFS/impact results might be stale.
+ * This is the reverse transitive closure: all files that transitively depend
+ * on the changed file (including the changed file itself).
+ */
+function computeAffectedFiles(filePath, graph) {
+    const affected = new Set();
+    affected.add(filePath);
+    const queue = [filePath];
+    while (queue.length > 0) {
+        const current = queue.shift();
+        const dependents = graph.reverse.get(current) || [];
+        for (const dep of dependents) {
+            if (!affected.has(dep)) {
+                affected.add(dep);
+                queue.push(dep);
+            }
+        }
+    }
+    return [...affected];
+}
+/**
+ * Recompute SCC and PageRank after edge changes.
+ * Both are O(V+E) and fast (<100ms for 10K files).
+ */
+function recomputeGraphMetrics(graph) {
+    // Recompute SCC
+    graph.scc = (0, scc_1.computeSCC)(graph);
+    // Recompute PageRank
+    (0, pagerank_1.invalidatePageRank)();
+    graph.pageRank = (0, pagerank_1.computePageRank)(graph);
+    // Invalidate project metrics (will be recomputed lazily)
+    (0, risk_scorer_1.invalidateProjectMetrics)();
+    const cyclicCount = graph.scc.condensed.nodes.filter(n => n.isCyclic).length;
+    console.error(`[syke:incremental] Graph metrics recomputed: ${graph.files.size} files, ` +
+        `${graph.scc.components.length} SCCs (${cyclicCount} cyclic)`);
+}

package/dist/graph/memo-cache.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Memoized BFS Result Cache for SYKE.
+ *
+ * Caches impact analysis results (BFS reverse traversals) so that
+ * repeated queries for the same file return instantly.
+ *
+ * Smart invalidation: when a file changes, only cache entries that
+ * could be affected are evicted. A reverse index maps each file to
+ * the set of cache keys whose impactSet contains it, making
+ * invalidation O(affected) instead of O(cache_size).
+ *
+ * Uses LRU eviction when the cache exceeds maxSize.
+ */
+export interface MemoEntry {
+    impactSet: string[];
+    directCount: number;
+    transitiveCount: number;
+    riskLevel: string;
+    cascadeLevels?: Map<string, number>;
+    computedAt: number;
+}
+export interface MemoCacheStats {
+    size: number;
+    hits: number;
+    misses: number;
+}
+export interface MemoCache {
+    get(filePath: string): MemoEntry | undefined;
+    set(filePath: string, entry: MemoEntry): void;
+    invalidate(affectedFiles: string[]): number;
+    invalidateAll(): void;
+    stats(): MemoCacheStats;
+}
+/**
+ * Create a new MemoCache with LRU eviction and reverse-index invalidation.
+ *
+ * @param maxSize Maximum number of cached entries (default 500).
+ */
+export declare function createMemoCache(maxSize?: number): MemoCache;
+/**
+ * Get the global memo cache instance (lazy initialization).
+ */
+export declare function getMemoCache(): MemoCache;
+/**
+ * Reset the global memo cache (e.g., on full graph rebuild).
+ */
+export declare function resetMemoCache(): void;