@syke1/mcp-server 1.4.17 → 1.4.19

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;

package/dist/graph/memo-cache.js

@@ -0,0 +1,176 @@
+"use strict";
+/**
+ * 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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMemoCache = createMemoCache;
+exports.getMemoCache = getMemoCache;
+exports.resetMemoCache = resetMemoCache;
+// ── Implementation ──
+/**
+ * Create a new MemoCache with LRU eviction and reverse-index invalidation.
+ *
+ * @param maxSize Maximum number of cached entries (default 500).
+ */
+function createMemoCache(maxSize = 500) {
+    // Main cache: filePath -> MemoEntry
+    const cache = new Map();
+    // LRU tracking: most recently accessed key moves to the end
+    const accessOrder = [];
+    // Reverse index: maps each file to the set of cache keys whose
+    // impactSet contains that file. Used for O(affected) invalidation.
+    const reverseIndex = new Map();
+    // Stats
+    let hits = 0;
+    let misses = 0;
+    /**
+     * Move a key to the end of the access order (most recently used).
+     */
+    function touchKey(key) {
+        const idx = accessOrder.indexOf(key);
+        if (idx !== -1) {
+            accessOrder.splice(idx, 1);
+        }
+        accessOrder.push(key);
+    }
+    /**
+     * Remove a single entry from the cache and clean up the reverse index.
+     */
+    function removeEntry(key) {
+        const entry = cache.get(key);
+        if (!entry)
+            return;
+        // Remove from reverse index
+        for (const file of entry.impactSet) {
+            const keys = reverseIndex.get(file);
+            if (keys) {
+                keys.delete(key);
+                if (keys.size === 0) {
+                    reverseIndex.delete(file);
+                }
+            }
+        }
+        // Also remove the key itself from the reverse index
+        const selfKeys = reverseIndex.get(key);
+        if (selfKeys) {
+            selfKeys.delete(key);
+            if (selfKeys.size === 0) {
+                reverseIndex.delete(key);
+            }
+        }
+        cache.delete(key);
+        const orderIdx = accessOrder.indexOf(key);
+        if (orderIdx !== -1) {
+            accessOrder.splice(orderIdx, 1);
+        }
+    }
+    /**
+     * Evict the least recently used entry when cache exceeds maxSize.
+     */
+    function evictLRU() {
+        while (cache.size > maxSize && accessOrder.length > 0) {
+            const lruKey = accessOrder.shift();
+            removeEntry(lruKey);
+        }
+    }
+    /**
+     * Add a file -> cacheKey mapping to the reverse index.
+     */
+    function addToReverseIndex(file, cacheKey) {
+        let keys = reverseIndex.get(file);
+        if (!keys) {
+            keys = new Set();
+            reverseIndex.set(file, keys);
+        }
+        keys.add(cacheKey);
+    }
+    return {
+        get(filePath) {
+            const entry = cache.get(filePath);
+            if (entry) {
+                hits++;
+                touchKey(filePath);
+                return entry;
+            }
+            misses++;
+            return undefined;
+        },
+        set(filePath, entry) {
+            // If already cached, remove old reverse index entries first
+            if (cache.has(filePath)) {
+                removeEntry(filePath);
+            }
+            // Store the entry
+            cache.set(filePath, entry);
+            touchKey(filePath);
+            // Build reverse index: map each file in impactSet -> this cache key
+            for (const file of entry.impactSet) {
+                addToReverseIndex(file, filePath);
+            }
+            // Also index the key itself (if the queried file changes, its own
+            // cached result is stale)
+            addToReverseIndex(filePath, filePath);
+            // Evict LRU if over capacity
+            evictLRU();
+        },
+        invalidate(affectedFiles) {
+            const keysToInvalidate = new Set();
+            for (const file of affectedFiles) {
+                // Find all cache keys whose impactSet contains this file
+                const keys = reverseIndex.get(file);
+                if (keys) {
+                    for (const key of keys) {
+                        keysToInvalidate.add(key);
+                    }
+                }
+            }
+            // Remove all identified entries
+            for (const key of keysToInvalidate) {
+                removeEntry(key);
+            }
+            return keysToInvalidate.size;
+        },
+        invalidateAll() {
+            cache.clear();
+            accessOrder.length = 0;
+            reverseIndex.clear();
+            // Do NOT reset hits/misses — they are cumulative diagnostics
+        },
+        stats() {
+            return {
+                size: cache.size,
+                hits,
+                misses,
+            };
+        },
+    };
+}
+// ── Singleton Instance ──
+let globalMemoCache = null;
+/**
+ * Get the global memo cache instance (lazy initialization).
+ */
+function getMemoCache() {
+    if (!globalMemoCache) {
+        globalMemoCache = createMemoCache();
+    }
+    return globalMemoCache;
+}
+/**
+ * Reset the global memo cache (e.g., on full graph rebuild).
+ */
+function resetMemoCache() {
+    if (globalMemoCache) {
+        globalMemoCache.invalidateAll();
+    }
+}

package/dist/graph/scc.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Strongly Connected Components (SCC) via Tarjan's algorithm,
+ * graph condensation into a DAG, and topological sort via Kahn's algorithm.
+ *
+ * Used to detect circular dependencies and provide accurate cascade-level
+ * impact analysis on the condensed (acyclic) dependency graph.
+ */
+import { DependencyGraph } from "../graph";
+export interface SCCResult {
+    /** Each SCC as an array of absolute file paths */
+    components: string[][];
+    /** Maps each file to its SCC index in `components` */
+    nodeToComponent: Map<string, number>;
+    /** The condensed DAG built from the SCCs */
+    condensed: CondensedDAG;
+}
+export interface CondensedDAG {
+    /** One node per SCC */
+    nodes: CondensedNode[];
+    /** SCC index -> list of SCC indices that depend on it (forward = same direction as file imports) */
+    forward: Map<number, number[]>;
+    /** SCC index -> list of SCC indices it depends on */
+    reverse: Map<number, number[]>;
+    /** SCCs in topological order (dependencies before dependents) */
+    topologicalOrder: number[];
+}
+export interface CondensedNode {
+    /** Index in the `nodes` array, matches the SCC index */
+    index: number;
+    /** Absolute file paths belonging to this SCC */
+    files: string[];
+    /** Number of files in this SCC */
+    size: number;
+    /** True if this SCC has more than one file (circular dependency) */
+    isCyclic: boolean;
+}
+/**
+ * Compute all Strongly Connected Components of the dependency graph
+ * using Tarjan's algorithm. Returns SCCs, a file-to-SCC mapping,
+ * and the condensed DAG with topological ordering.
+ */
+export declare function computeSCC(graph: DependencyGraph): SCCResult;
+/**
+ * Build a DAG where each node represents one SCC.
+ * Edges between SCCs are derived from the original graph's edges
+ * between files belonging to different SCCs.
+ */
+export declare function condenseGraph(graph: DependencyGraph, components: string[][], nodeToComponent: Map<string, number>): CondensedDAG;
+/**
+ * Compute a topological ordering of the condensed DAG using Kahn's algorithm.
+ * The condensed graph is guaranteed to be acyclic after SCC condensation.
+ *
+ * Returns SCC indices in dependency order: dependencies come before dependents.
+ * This uses the `forward` edges (file A imports B means A -> B in forward),
+ * so we process nodes with no incoming forward edges first (leaf dependencies).
+ */
+export declare function topologicalSort(dag: CondensedDAG): number[];