project-graph-mcp 1.0.1 → 1.2.0

package/src/tools.js

@@ -2,10 +2,11 @@
  * MCP Tools for Project Graph
  */
 
-import { parseProject, parseFile } from './parser.js';
+import { parseProject, parseFile, findJSFiles } from './parser.js';
 import { buildGraph, createSkeleton } from './graph-builder.js';
-import { readFileSync } from 'fs';
+import { readFileSync, statSync, writeFileSync, existsSync, unlinkSync } from 'fs';
 import { execSync } from 'child_process';
+import { join } from 'path';
 
 /** @type {import('./graph-builder.js').Graph|null} */
 let cachedGraph = null;
@@ -13,23 +14,158 @@ let cachedGraph = null;
 /** @type {string|null} */
 let cachedPath = null;
 
+/** @type {Map<string, number>} file path -> mtimeMs */
+let cachedMtimes = new Map();
+
 /**
- * Get or build graph with caching
+ * Save cache to disk
+ * @param {string} path 
+ * @param {import('./graph-builder.js').Graph} graph 
+ */
+function saveDiskCache(path, graph) {
+  try {
+    const cachePath = join(path, '.project-graph-cache.json');
+    const cacheData = {
+      version: 1,
+      path: path,
+      mtimes: Object.fromEntries(cachedMtimes),
+      graph: graph
+    };
+    writeFileSync(cachePath, JSON.stringify(cacheData), 'utf-8');
+  } catch (e) {
+    // Ignore cache save errors
+  }
+}
+
+/**
+ * Load cache from disk
+ * @param {string} path 
+ * @returns {boolean} true if cache was successfully loaded and is valid
+ */
+function loadDiskCache(path) {
+  try {
+    const cachePath = join(path, '.project-graph-cache.json');
+    if (!existsSync(cachePath)) return false;
+
+    const content = readFileSync(cachePath, 'utf-8');
+    const data = JSON.parse(content);
+
+    if (data.version !== 1 || data.path !== path) return false;
+
+    cachedMtimes.clear();
+    for (const [file, mtime] of Object.entries(data.mtimes)) {
+      cachedMtimes.set(file, mtime);
+    }
+
+    cachedGraph = data.graph;
+    cachedPath = path;
+
+    const changed = detectChanges(path);
+    if (changed) {
+      cachedGraph = null;
+      cachedPath = null;
+      cachedMtimes.clear();
+      return false;
+    }
+
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+
+/**
+ * Get or build graph with smart mtime-based caching.
+ * On first call: full parse + build.
+ * On subsequent calls: check file mtimes, rebuild only if changes detected.
  * @param {string} path 
  * @returns {Promise<import('./graph-builder.js').Graph>}
  */
 async function getGraph(path) {
+  // Different path = full rebuild
   if (cachedGraph && cachedPath === path) {
-    return cachedGraph;
+    // Check for file changes via mtime
+    const changed = detectChanges(path);
+    if (!changed) {
+      return cachedGraph;
+    }
+    // Files changed - full rebuild (incremental would need graph-builder changes)
+  } else if (!cachedGraph) {
+    if (loadDiskCache(path)) {
+      return cachedGraph;
+    }
   }
 
   const parsed = await parseProject(path);
   cachedGraph = buildGraph(parsed);
   cachedPath = path;
 
+  // Snapshot mtimes for all parsed files
+  snapshotMtimes(path);
+  saveDiskCache(path, cachedGraph);
+
   return cachedGraph;
 }
 
+/**
+ * Detect if any JS files changed since last snapshot.
+ * Checks: new files, deleted files, modified files (via mtimeMs).
+ * @param {string} path
+ * @returns {boolean} true if changes detected
+ */
+function detectChanges(path) {
+  if (cachedMtimes.size === 0) return true;
+
+  try {
+    const currentFiles = findJSFiles(path);
+    const currentSet = new Set(currentFiles);
+    const cachedSet = new Set(cachedMtimes.keys());
+
+    // New or deleted files
+    if (currentFiles.length !== cachedMtimes.size) return true;
+    for (const f of currentFiles) {
+      if (!cachedSet.has(f)) return true;
+    }
+    for (const f of cachedSet) {
+      if (!currentSet.has(f)) return true;
+    }
+
+    // Check mtimes
+    for (const file of currentFiles) {
+      try {
+        const mtime = statSync(file).mtimeMs;
+        if (mtime !== cachedMtimes.get(file)) return true;
+      } catch {
+        return true; // File gone or unreadable
+      }
+    }
+
+    return false;
+  } catch {
+    return true; // Safety: rebuild on error
+  }
+}
+
+/**
+ * Snapshot current mtimes for all JS files in path.
+ * @param {string} path
+ */
+function snapshotMtimes(path) {
+  cachedMtimes.clear();
+  try {
+    const files = findJSFiles(path);
+    for (const file of files) {
+      try {
+        cachedMtimes.set(file, statSync(file).mtimeMs);
+      } catch {
+        // Skip unreadable files
+      }
+    }
+  } catch {
+    // Ignore errors
+  }
+}
+
 /**
  * Get compact project skeleton
  * @param {string} path 
@@ -110,13 +246,26 @@ export async function expand(symbol) {
   // Find the source file
   const parsed = await parseProject(path);
   const cls = parsed.classes.find(c => c.name === fullName);
+  const fn = parsed.functions.find(f => f.name === fullName);
 
-  if (!cls) {
-    return { error: `Class not found: ${fullName}` };
+  if (!cls && !fn) {
+    return { error: `Symbol not found: ${fullName}` };
+  }
+
+  if (fn && !methodKey) {
+    return {
+      symbol,
+      fullName,
+      type: 'function',
+      file: fn.file,
+      line: fn.line,
+      exported: fn.exported,
+      calls: fn.calls,
+    };
   }
 
   // If method specified, extract method code
-  if (methodKey) {
+  if (methodKey && cls) {
     const methodName = graph.reverseLegend[methodKey] || methodKey;
     const content = readFileSync(cls.file, 'utf-8');
     const methodCode = extractMethod(content, methodName);
@@ -231,10 +380,91 @@ function extractMethod(content, methodName) {
   return content.slice(start);
 }
 
+/**
+ * Find call chain from one symbol to another
+ * @param {Object} options 
+ * @param {string} options.from - Starting symbol (full or minified)
+ * @param {string} options.to - Target symbol (full or minified)
+ * @param {string} [options.path] - Project path
+ * @returns {Promise<string[]|Object>}
+ */
+export async function getCallChain(options = {}) {
+  const { from, to, path } = options;
+  if (!from || !to) {
+    return { error: 'Both "from" and "to" parameters are required' };
+  }
+
+  const projectPath = path || cachedPath || 'src/components';
+  const graph = await getGraph(projectPath);
+
+  const fromSym = graph.legend[from] || from;
+  const toSym = graph.legend[to] || to;
+
+  // Build adjacency list for fast lookup
+  const adj = {};
+  for (const [caller, _, target] of graph.edges) {
+    if (!adj[caller]) adj[caller] = [];
+    adj[caller].push(target);
+  }
+
+  // Queue stores { current: string, path: string[] }
+  const queue = [{ current: fromSym, path: [fromSym] }];
+  const visitedNodes = new Set();
+  const expandedBases = new Set();
+  visitedNodes.add(fromSym);
+
+  while (queue.length > 0) {
+    const { current, path: currentPath } = queue.shift();
+
+    const currentBase = current.split('.')[0];
+    const currentMethod = current.split('.')[1];
+
+    if (current === toSym || currentBase === toSym || currentMethod === toSym) {
+      const fullPath = currentPath.map(sym => {
+        const parts = sym.split('.');
+        const base = graph.reverseLegend[parts[0]] || parts[0];
+        if (parts.length === 2) {
+          const method = graph.reverseLegend[parts[1]] || parts[1];
+          return `${base}.${method}`;
+        }
+        return base;
+      });
+      return fullPath;
+    }
+
+    if (expandedBases.has(currentBase)) {
+      continue;
+    }
+    expandedBases.add(currentBase);
+
+    const neighbors = adj[currentBase] || [];
+    for (const neighbor of neighbors) {
+      if (!visitedNodes.has(neighbor)) {
+        visitedNodes.add(neighbor);
+        queue.push({
+          current: neighbor,
+          path: [...currentPath, neighbor]
+        });
+      }
+    }
+  }
+
+  return { error: `No call path found from "${from}" to "${to}"` };
+}
+
 /**
  * Invalidate cache
  */
 export function invalidateCache() {
+  if (cachedPath) {
+    try {
+      const cachePath = join(cachedPath, '.project-graph-cache.json');
+      if (existsSync(cachePath)) {
+        unlinkSync(cachePath);
+      }
+    } catch (e) {}
+  }
   cachedGraph = null;
   cachedPath = null;
+  cachedMtimes.clear();
 }