@syke1/mcp-server 1.4.17 → 1.4.18

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[];

package/dist/graph/scc.js

@@ -0,0 +1,206 @@
+"use strict";
+/**
+ * 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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.computeSCC = computeSCC;
+exports.condenseGraph = condenseGraph;
+exports.topologicalSort = topologicalSort;
+// ── Tarjan's SCC Algorithm ──
+/**
+ * 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.
+ */
+function computeSCC(graph) {
+    // Handle empty graph
+    if (graph.files.size === 0) {
+        const emptyDAG = {
+            nodes: [],
+            forward: new Map(),
+            reverse: new Map(),
+            topologicalOrder: [],
+        };
+        return {
+            components: [],
+            nodeToComponent: new Map(),
+            condensed: emptyDAG,
+        };
+    }
+    const components = [];
+    // Tarjan state
+    let indexCounter = 0;
+    const nodeIndex = new Map();
+    const nodeLowlink = new Map();
+    const onStack = new Set();
+    const stack = [];
+    function strongConnect(node) {
+        nodeIndex.set(node, indexCounter);
+        nodeLowlink.set(node, indexCounter);
+        indexCounter++;
+        stack.push(node);
+        onStack.add(node);
+        const successors = graph.forward.get(node) || [];
+        for (const successor of successors) {
+            // Only process nodes that exist in the graph
+            if (!graph.files.has(successor))
+                continue;
+            if (!nodeIndex.has(successor)) {
+                // Successor not yet visited — recurse
+                strongConnect(successor);
+                nodeLowlink.set(node, Math.min(nodeLowlink.get(node), nodeLowlink.get(successor)));
+            }
+            else if (onStack.has(successor)) {
+                // Successor is on the stack — part of current SCC
+                nodeLowlink.set(node, Math.min(nodeLowlink.get(node), nodeIndex.get(successor)));
+            }
+        }
+        // If node is a root of an SCC, pop the stack to form a component
+        if (nodeLowlink.get(node) === nodeIndex.get(node)) {
+            const component = [];
+            let w;
+            do {
+                w = stack.pop();
+                onStack.delete(w);
+                component.push(w);
+            } while (w !== node);
+            components.push(component);
+        }
+    }
+    // Visit all nodes (handles disconnected components)
+    for (const file of graph.files) {
+        if (!nodeIndex.has(file)) {
+            strongConnect(file);
+        }
+    }
+    // Build file-to-component mapping
+    const nodeToComponent = new Map();
+    for (let i = 0; i < components.length; i++) {
+        for (const file of components[i]) {
+            nodeToComponent.set(file, i);
+        }
+    }
+    // Build the condensed DAG
+    const condensed = condenseGraph(graph, components, nodeToComponent);
+    return { components, nodeToComponent, condensed };
+}
+// ── Graph Condensation ──
+/**
+ * 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.
+ */
+function condenseGraph(graph, components, nodeToComponent) {
+    const numComponents = components.length;
+    // Build condensed nodes
+    const nodes = components.map((files, index) => ({
+        index,
+        files,
+        size: files.length,
+        isCyclic: files.length > 1,
+    }));
+    // Build forward and reverse edges between SCCs (deduplicated)
+    const forwardSets = new Map();
+    const reverseSets = new Map();
+    for (let i = 0; i < numComponents; i++) {
+        forwardSets.set(i, new Set());
+        reverseSets.set(i, new Set());
+    }
+    for (const [file, deps] of graph.forward) {
+        const srcSCC = nodeToComponent.get(file);
+        if (srcSCC === undefined)
+            continue;
+        for (const dep of deps) {
+            const dstSCC = nodeToComponent.get(dep);
+            if (dstSCC === undefined)
+                continue;
+            // Skip self-edges (within the same SCC)
+            if (srcSCC === dstSCC)
+                continue;
+            forwardSets.get(srcSCC).add(dstSCC);
+            reverseSets.get(dstSCC).add(srcSCC);
+        }
+    }
+    // Convert sets to arrays
+    const forward = new Map();
+    const reverse = new Map();
+    for (const [key, set] of forwardSets) {
+        forward.set(key, [...set]);
+    }
+    for (const [key, set] of reverseSets) {
+        reverse.set(key, [...set]);
+    }
+    const dag = {
+        nodes,
+        forward,
+        reverse,
+        topologicalOrder: [],
+    };
+    // Compute topological order
+    dag.topologicalOrder = topologicalSort(dag);
+    return dag;
+}
+// ── Topological Sort (Kahn's Algorithm) ──
+/**
+ * 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).
+ */
+function topologicalSort(dag) {
+    const numNodes = dag.nodes.length;
+    if (numNodes === 0)
+        return [];
+    // In-degree = number of dependencies (forward edges out of each node).
+    // forward[A] = [B] means A imports B, so A depends on B.
+    // For "dependencies first" ordering, nodes with zero dependencies come first.
+    const inDegree = new Map();
+    for (let i = 0; i < numNodes; i++) {
+        inDegree.set(i, 0);
+    }
+    for (const [src, dsts] of dag.forward) {
+        inDegree.set(src, (inDegree.get(src) || 0) + dsts.length);
+    }
+    // Start with nodes that have no dependencies (in-degree 0 in forward)
+    const queue = [];
+    for (const [node, degree] of inDegree) {
+        if (degree === 0) {
+            queue.push(node);
+        }
+    }
+    const order = [];
+    while (queue.length > 0) {
+        const current = queue.shift();
+        order.push(current);
+        // current has no remaining dependencies.
+        // For all nodes that depend on current (reverse edges: who imports current),
+        // decrement their in-degree.
+        const dependents = dag.reverse.get(current) || [];
+        for (const dependent of dependents) {
+            const newDegree = (inDegree.get(dependent) || 0) - 1;
+            inDegree.set(dependent, newDegree);
+            if (newDegree === 0) {
+                queue.push(dependent);
+            }
+        }
+    }
+    // If order doesn't contain all nodes, there's a bug (shouldn't happen after SCC condensation)
+    if (order.length !== numNodes) {
+        console.error(`[syke:scc] WARNING: Topological sort produced ${order.length}/${numNodes} nodes. ` +
+            `This indicates a bug in SCC condensation.`);
+        // Add remaining nodes at the end
+        const ordered = new Set(order);
+        for (let i = 0; i < numNodes; i++) {
+            if (!ordered.has(i)) {
+                order.push(i);
+            }
+        }
+    }
+    return order;
+}

package/dist/graph.d.ts

@@ -1,3 +1,5 @@
+import { SCCResult } from "./graph/scc";
+import { PageRankResult } from "./scoring/pagerank";
 export interface DependencyGraph {
     forward: Map<string, string[]>;
     reverse: Map<string, string[]>;
@@ -7,6 +9,10 @@ export interface DependencyGraph {
     sourceDirs: string[];
     /** backward compat: first source directory */
     sourceDir: string;
+    /** Strongly Connected Components — computed after graph build */
+    scc?: SCCResult;
+    /** PageRank importance scores — computed after graph build */
+    pageRank?: PageRankResult;
 }
 export declare function buildGraph(projectRoot: string, packageName?: string): DependencyGraph;
 export declare function getGraph(projectRoot: string, packageName?: string): DependencyGraph;

package/dist/graph.js

@@ -39,6 +39,10 @@ exports.refreshGraph = refreshGraph;
 const path = __importStar(require("path"));
 const plugin_1 = require("./languages/plugin");
 const typescript_1 = require("./languages/typescript");
+const scc_1 = require("./graph/scc");
+const risk_scorer_1 = require("./scoring/risk-scorer");
+const pagerank_1 = require("./scoring/pagerank");
+const memo_cache_1 = require("./graph/memo-cache");
 let cachedGraph = null;
 function buildGraph(projectRoot, packageName) {
     const detectedPlugins = (0, plugin_1.detectLanguages)(projectRoot);
@@ -85,8 +89,17 @@ function buildGraph(projectRoot, packageName) {
         sourceDirs: allSourceDirs,
         sourceDir,
     };
+    // Invalidate memo cache (full rebuild means all cached BFS results are stale)
+    (0, memo_cache_1.resetMemoCache)();
+    // Compute SCC and attach to graph
+    const scc = (0, scc_1.computeSCC)(graph);
+    graph.scc = scc;
+    // Compute PageRank importance scores
+    (0, pagerank_1.invalidatePageRank)();
+    graph.pageRank = (0, pagerank_1.computePageRank)(graph);
+    const cyclicCount = scc.condensed.nodes.filter(n => n.isCyclic).length;
     cachedGraph = graph;
-    console.error(`[syke] Graph built (${languages.join("+")}): ${files.size} files, ${countEdges(forward)} edges`);
+    console.error(`[syke] Graph built (${languages.join("+")}): ${files.size} files, ${countEdges(forward)} edges, ${scc.components.length} SCCs (${cyclicCount} cyclic)`);
     return graph;
 }
 function countEdges(forward) {
@@ -105,5 +118,8 @@ function getGraph(projectRoot, packageName) {
 function refreshGraph(projectRoot, packageName) {
     cachedGraph = null;
     (0, typescript_1.clearAliasCache)();
+    (0, risk_scorer_1.invalidateProjectMetrics)();
+    (0, pagerank_1.invalidatePageRank)();
+    (0, memo_cache_1.resetMemoCache)();
     return buildGraph(projectRoot, packageName);
 }