project-graph-mcp 1.5.0 → 2.1.0

package/src/tools.js

@@ -1,470 +0,0 @@
-/**
- * MCP Tools for Project Graph
- */
-
-import { parseProject, parseFile, findJSFiles } from './parser.js';
-import { buildGraph, createSkeleton } from './graph-builder.js';
-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;
-
-/** @type {string|null} */
-let cachedPath = null;
-
-/** @type {Map<string, number>} file path -> mtimeMs */
-let cachedMtimes = new Map();
-
-/**
- * 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>}
- */
-export async function getGraph(path) {
-  // Different path = full rebuild
-  if (cachedGraph && cachedPath === path) {
-    // 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 
- * @returns {Promise<Object>}
- */
-export async function getSkeleton(path) {
-  const graph = await getGraph(path);
-  return createSkeleton(graph);
-}
-
-/**
- * Get enriched focus zone based on recent activity
- * @param {Object} options
- * @param {string[]} [options.recentFiles]
- * @param {boolean} [options.useGitDiff]
- * @returns {Promise<Object>}
- */
-export async function getFocusZone(options = {}) {
-  const path = options.path || 'src/components';
-  const graph = await getGraph(path);
-
-  let focusFiles = options.recentFiles || [];
-
-  // Auto-detect from git diff
-  if (options.useGitDiff) {
-    try {
-      const diff = execSync('git diff --name-only HEAD~5', { encoding: 'utf-8' });
-      focusFiles = diff.split('\n').filter(f => f.endsWith('.js'));
-    } catch (e) {
-      // Git not available or not a repo
-    }
-  }
-
-  const expanded = {};
-
-  for (const file of focusFiles) {
-    // Find classes in this file
-    const content = readFileSync(file, 'utf-8');
-    const parsed = await parseFile(content, file);
-
-    for (const cls of parsed.classes) {
-      const shortName = graph.legend[cls.name];
-      if (shortName && graph.nodes[shortName]) {
-        expanded[shortName] = {
-          ...graph.nodes[shortName],
-          methods: cls.methods,
-          properties: cls.properties,
-          file: cls.file,
-          line: cls.line,
-        };
-      }
-    }
-  }
-
-  return {
-    focusFiles,
-    expanded,
-    expandable: Object.keys(graph.nodes).filter(k => !expanded[k]),
-  };
-}
-
-/**
- * Expand a symbol to full details
- * @param {string} symbol - Minified symbol like 'SN' or 'SN.tP'
- * @returns {Promise<Object>}
- */
-export async function expand(symbol) {
-  const path = cachedPath || 'src/components';
-  const graph = await getGraph(path);
-
-  const [nodeKey, methodKey] = symbol.split('.');
-  const fullName = graph.reverseLegend[nodeKey];
-
-  if (!fullName) {
-    return { error: `Unknown symbol: ${symbol}. Run get_skeleton on your project first, then use symbols from the L (Legend) field.` };
-  }
-
-  // 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 && !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 && cls) {
-    const methodName = graph.reverseLegend[methodKey] || methodKey;
-    const content = readFileSync(cls.file, 'utf-8');
-    const methodCode = extractMethod(content, methodName);
-
-    return {
-      symbol,
-      fullName: `${fullName}.${methodName}`,
-      file: cls.file,
-      line: cls.line, // TODO: get actual method line
-      code: methodCode,
-    };
-  }
-
-  // Return full class info
-  return {
-    symbol,
-    fullName,
-    file: cls.file,
-    line: cls.line,
-    extends: cls.extends,
-    methods: cls.methods,
-    properties: cls.properties,
-    calls: cls.calls,
-  };
-}
-
-/**
- * Get dependency tree for a symbol
- * @param {string} symbol 
- * @returns {Promise<Object>}
- */
-export async function deps(symbol) {
-  const path = cachedPath || 'src/components';
-  const graph = await getGraph(path);
-
-  const node = graph.nodes[symbol];
-  if (!node) {
-    return { error: `Unknown symbol: ${symbol}. Run get_skeleton on your project first, then use symbols from the L (Legend) field.` };
-  }
-
-  // Find incoming edges (usedBy)
-  const usedBy = graph.edges
-    .filter(e => e[2].startsWith(symbol))
-    .map(e => e[0]);
-
-  // Find outgoing edges (calls)
-  const calls = graph.edges
-    .filter(e => e[0] === symbol)
-    .map(e => e[2]);
-
-  return {
-    symbol,
-    imports: node.i || [],
-    usedBy: [...new Set(usedBy)],
-    calls: [...new Set(calls)],
-  };
-}
-
-/**
- * Find all usages of a symbol
- * @param {string} symbol 
- * @returns {Promise<Array>}
- */
-export async function usages(symbol) {
-  const path = cachedPath || 'src/components';
-  const graph = await getGraph(path);
-  const parsed = await parseProject(path);
-
-  const fullName = graph.reverseLegend[symbol] || symbol;
-  const results = [];
-
-  for (const cls of parsed.classes) {
-    if (cls.calls?.includes(fullName) || cls.calls?.some(c => c.includes(fullName))) {
-      results.push({
-        file: cls.file,
-        line: cls.line,
-        context: `${cls.name} calls ${fullName}`,
-      });
-    }
-  }
-
-  return results;
-}
-
-/**
- * Extract method code from file content
- * @param {string} content 
- * @param {string} methodName 
- * @returns {string}
- */
-function extractMethod(content, methodName) {
-  const regex = new RegExp(`((?:\\/\\*\\*[\\s\\S]*?\\*\\/\\s*)?)(?:async\\s+)?${methodName}\\s*\\([^)]*\\)\\s*{`, 'g');
-  const match = regex.exec(content);
-
-  if (!match) return '';
-
-  const start = match.index;
-  let depth = 0;
-  let i = match.index + match[0].length - 1;
-
-  while (i < content.length) {
-    if (content[i] === '{') depth++;
-    else if (content[i] === '}') {
-      depth--;
-      if (depth === 0) {
-        return content.slice(start, i + 1);
-      }
-    }
-    i++;
-  }
-
-  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();
-}

package/src/type-checker.js

@@ -1,188 +0,0 @@
-/**
- * Optional Type Checker (tsc wrapper)
- * Provides JSDoc type validation via TypeScript compiler
- * 
- * Requires `tsc` in PATH (npm i -g typescript)
- * Graceful fallback if not available
- */
-
-import { execSync, spawn } from 'child_process';
-import { existsSync } from 'fs';
-import { resolve, join } from 'path';
-
-/**
- * @typedef {Object} TypeDiagnostic
- * @property {string} file
- * @property {number} line
- * @property {number} column
- * @property {'error'|'warning'} severity
- * @property {string} message
- * @property {string} code - TS error code (e.g. "TS2345")
- */
-
-/**
- * Check if tsc is available
- * @returns {{ available: boolean, version: string|null, path: string|null }}
- */
-function detectTsc() {
-  try {
-    const version = execSync('tsc --version', { encoding: 'utf-8', timeout: 5000 }).trim();
-    const tscPath = execSync('which tsc', { encoding: 'utf-8', timeout: 5000 }).trim();
-    return { available: true, version, path: tscPath };
-  } catch (e) {
-    // Try npx
-    try {
-      const version = execSync('npx tsc --version', { encoding: 'utf-8', timeout: 15000 }).trim();
-      return { available: true, version, path: 'npx tsc' };
-    } catch (e2) {
-      return { available: false, version: null, path: null };
-    }
-  }
-}
-
-/**
- * Parse tsc output line into structured diagnostic
- * @param {string} line
- * @param {string} baseDir
- * @returns {TypeDiagnostic|null}
- */
-function parseDiagnosticLine(line, baseDir) {
-  // Format: file.js(line,col): error TS1234: message
-  const match = line.match(/^(.+?)\((\d+),(\d+)\):\s+(error|warning)\s+(TS\d+):\s+(.+)$/);
-  if (!match) return null;
-
-  return {
-    file: match[1],
-    line: parseInt(match[2]),
-    column: parseInt(match[3]),
-    severity: match[4],
-    message: match[6],
-    code: match[5],
-  };
-}
-
-/**
- * Build tsc arguments
- * @param {string} dir
- * @param {Object} options
- * @returns {string[]}
- */
-function buildArgs(dir, options = {}) {
-  const args = ['--noEmit'];
-
-  // Check for existing config
-  const tsconfig = join(dir, 'tsconfig.json');
-  const jsconfig = join(dir, 'jsconfig.json');
-
-  if (existsSync(tsconfig)) {
-    args.push('--project', tsconfig);
-  } else if (existsSync(jsconfig)) {
-    args.push('--project', jsconfig);
-  } else {
-    // No config — use sensible defaults for JS projects
-    args.push('--allowJs', '--checkJs');
-    args.push('--target', 'ESNext');
-    args.push('--module', 'NodeNext');
-    args.push('--moduleResolution', 'NodeNext');
-    args.push('--skipLibCheck');
-
-    // Include the directory
-    if (options.files?.length) {
-      args.push(...options.files);
-    } else {
-      args.push('--rootDir', dir);
-    }
-  }
-
-  return args;
-}
-
-/**
- * Run type checking on a directory
- * @param {string} dir - Directory to check
- * @param {Object} [options]
- * @param {string[]} [options.files] - Specific files to check
- * @param {number} [options.maxDiagnostics=50] - Max diagnostics to return
- * @returns {Promise<{ available: boolean, version: string|null, diagnostics: TypeDiagnostic[], summary: Object, hint: string|null }>}
- */
-export async function checkTypes(dir, options = {}) {
-  const maxDiagnostics = options.maxDiagnostics || 50;
-  const resolvedDir = resolve(dir);
-
-  // Detect tsc
-  const tsc = detectTsc();
-  if (!tsc.available) {
-    return {
-      available: false,
-      version: null,
-      diagnostics: [],
-      summary: { total: 0, errors: 0, warnings: 0 },
-      hint: 'TypeScript not found. Install: npm i -g typescript',
-    };
-  }
-
-  // Build and run command
-  const args = buildArgs(resolvedDir, options);
-  const cmd = tsc.path.includes('npx') ? 'npx' : 'tsc';
-  const cmdArgs = tsc.path.includes('npx') ? ['tsc', ...args] : args;
-
-  const result = await new Promise((res) => {
-    const child = spawn(cmd, cmdArgs, {
-      cwd: resolvedDir,
-      stdio: ['ignore', 'pipe', 'pipe'],
-    });
-
-    let stdout = '';
-    let stderr = '';
-    child.stdout.on('data', (d) => { stdout += d; });
-    child.stderr.on('data', (d) => { stderr += d; });
-
-    const timer = setTimeout(() => {
-      child.kill('SIGTERM');
-      res({ stdout, stderr, killed: true });
-    }, 60000);
-
-    child.on('close', () => {
-      clearTimeout(timer);
-      res({ stdout, stderr, killed: false });
-    });
-
-    child.on('error', (e) => {
-      clearTimeout(timer);
-      res({ stdout: '', stderr: e.message, killed: false });
-    });
-  });
-
-  // Parse output (tsc exits with 1 on errors, stdout has diagnostics)
-  const output = (result.stdout || '') + (result.stderr || '');
-  const lines = output.split('\n').filter(l => l.trim());
-
-  const diagnostics = [];
-  for (const line of lines) {
-    const diag = parseDiagnosticLine(line, resolvedDir);
-    if (diag && diagnostics.length < maxDiagnostics) {
-      diagnostics.push(diag);
-    }
-  }
-
-  const errors = diagnostics.filter(d => d.severity === 'error').length;
-  const warnings = diagnostics.filter(d => d.severity === 'warning').length;
-
-  const byFile = {};
-  for (const d of diagnostics) {
-    byFile[d.file] = (byFile[d.file] || 0) + 1;
-  }
-
-  return {
-    available: true,
-    version: tsc.version,
-    diagnostics,
-    summary: {
-      total: diagnostics.length,
-      errors,
-      warnings,
-      byFile,
-    },
-    hint: null,
-  };
-}