project-graph-mcp 1.0.1 → 1.1.0

package/README.md

@@ -1,6 +1,6 @@
 # project-graph-mcp
 
-**MCP server for AI agents** — project graph, code quality analysis, and framework-specific lint rules.
+**MCP server for AI agents** — multi-language project graph, code quality analysis, and framework-specific lint rules.
 
 > Developed by [RND-PRO](https://rnd-pro.com)
 
@@ -14,6 +14,7 @@ AI agents struggle with large codebases:
 
 **Project Graph MCP solves this:**
 - 📦 **10-50x compression** — skeleton view fits in context window
+- 🌐 **Multi-language** — JavaScript, TypeScript, Python, Go
 - 🔍 **Code quality analysis** — dead code, complexity, duplicates
 - 🎯 **Framework-specific rules** — auto-detect and apply (React, Vue, Express, Node.js, Symbiote)
 - ✅ **Test checklists** — track @test/@expect annotations
@@ -26,6 +27,9 @@ AI agents struggle with large codebases:
 - `deps` — Dependency tree for any symbol
 - `usages` — Find all usages of a symbol
 - `get_focus_zone` — Auto-enriched context from git diff
+- `get_call_chain` — BFS call path analysis between symbols
+
+**Supported languages:** JavaScript (AST via Acorn), TypeScript/TSX, Python, Go — all with unified ParseResult API.
 
 ### 🧪 Test Checklists (Universal)
 - `get_pending_tests` — List tests from `@test/@expect` JSDoc annotations
@@ -253,7 +257,11 @@ project-graph-mcp/
 │   ├── tool-defs.js          # MCP tool schemas
 │   ├── tools.js              # Graph tools (skeleton, expand, deps)
 │   ├── workspace.js          # Path resolution + traversal protection
-│   ├── parser.js             # AST parser (Acorn)
+│   ├── parser.js             # AST parser (Acorn) + language routing
+│   ├── lang-typescript.js    # TypeScript/TSX regex parser
+│   ├── lang-python.js        # Python regex parser
+│   ├── lang-go.js            # Go regex parser
+│   ├── lang-utils.js         # Shared: stripStringsAndComments
 │   ├── graph-builder.js      # Minified graph + legend
 │   ├── filters.js            # Exclude patterns, .gitignore
 │   ├── dead-code.js          # Unused code detection

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "project-graph-mcp",
-  "version": "1.0.1",
+  "version": "1.1.0",
   "type": "module",
-  "description": "MCP server for AI agents — AST-based project graph, code quality analysis, and framework-specific lint rules. Zero dependencies.",
+  "description": "MCP server for AI agents — multi-language project graph (JS, TS, Python, Go), code quality analysis, and framework-specific lint rules. Zero dependencies.",
   "main": "src/server.js",
   "bin": {
     "project-graph-mcp": "src/server.js"
@@ -32,7 +32,11 @@
     "dead-code",
     "complexity",
     "lint",
-    "gemini"
+    "gemini",
+    "typescript",
+    "python",
+    "golang",
+    "multi-language"
   ],
   "repository": {
     "type": "git",

package/src/.project-graph-cache.json

@@ -0,0 +1 @@
+{"version":1,"path":"/Users/v.matiyasevich/Documents/GitHub/project-graph-mcp/src","mtimes":{"/Users/v.matiyasevich/Documents/GitHub/project-graph-mcp/src/cli-handlers.js":1770656908396.6091,"/Users/v.matiyasevich/Documents/GitHub/project-graph-mcp/src/cli.js":1770402560025.795,"/Users/v.matiyasevich/Documents/GitHub/project-graph-mcp/src/complexity.js":1770659410318.8738,"/Users/v.matiyasevich/Documents/GitHub/project-graph-mcp/src/custom-rules.js":1772229894400.4248,"/Users/v.matiyasevich/Documents/GitHub/project-graph-mcp/src/dead-code.js":1771039661152.3376,"/Users/v.matiyasevich/Documents/GitHub/project-graph-mcp/src/filters.js":1773680641811.5923,"/Users/v.matiyasevich/Documents/GitHub/project-graph-mcp/src/framework-references.js":1772230204706.0527,"/Users/v.matiyasevich/Documents/GitHub/project-graph-mcp/src/full-analysis.js":1770398073907.7559,"/Users/v.matiyasevich/Documents/GitHub/project-graph-mcp/src/graph-builder.js":1773699507591.4272,"/Users/v.matiyasevich/Documents/GitHub/project-graph-mcp/src/instructions.js":1770399269998.5479,"/Users/v.matiyasevich/Documents/GitHub/project-graph-mcp/src/jsdoc-generator.js":1770659484514.0476,"/Users/v.matiyasevich/Documents/GitHub/project-graph-mcp/src/lang-go.js":1773698053155.2214,"/Users/v.matiyasevich/Documents/GitHub/project-graph-mcp/src/lang-python.js":1773699559544.998,"/Users/v.matiyasevich/Documents/GitHub/project-graph-mcp/src/lang-typescript.js":1773698053134.5566,"/Users/v.matiyasevich/Documents/GitHub/project-graph-mcp/src/lang-utils.js":1773697910333.1853,"/Users/v.matiyasevich/Documents/GitHub/project-graph-mcp/src/large-files.js":1770659415051.0068,"/Users/v.matiyasevich/Documents/GitHub/project-graph-mcp/src/mcp-server.js":1773680723694.6929,"/Users/v.matiyasevich/Documents/GitHub/project-graph-mcp/src/outdated-patterns.js":1770659431382.597,"/Users/v.matiyasevich/Documents/GitHub/project-graph-mcp/src/parser.js":1773683193338.3542,"/Users/v.matiyasevich/Documents/GitHub/project-graph-mcp/src/server.js":1773497829401.444,"/Users/v.matiyasevich/Documents/GitHub/project-graph-mcp/src/similar-functions.js":1770659421339.757,"/Users/v.matiyasevich/Documents/GitHub/project-graph-mcp/src/test-annotations.js":1772223332771.1304,"/Users/v.matiyasevich/Documents/GitHub/project-graph-mcp/src/tool-defs.js":1773680708907.4548,"/Users/v.matiyasevich/Documents/GitHub/project-graph-mcp/src/tools.js":1773699507598.5554,"/Users/v.matiyasevich/Documents/GitHub/project-graph-mcp/src/undocumented.js":1770659436429.1372,"/Users/v.matiyasevich/Documents/GitHub/project-graph-mcp/src/workspace.js":1773699468757.9526},"graph":{"v":1,"legend":{"getArg":"gA","getPath":"gP","printHelp":"pH","runCLI":"CLI","findJSFiles":"JSF","calculateComplexity":"cC","getRating":"gR","analyzeFile":"aF","getComplexity":"gC","parseGraphignore":"pG","isGraphignored":"iG","loadRuleSets":"RS","saveRuleSet":"RS1","findFiles":"fF","isExcluded":"iE","isInStringOrComment":"ISO","isWithinContext":"WC","checkFileAgainstRule":"FAR","getCustomRules":"CR","setCustomRule":"CR1","deleteCustomRule":"CR2","detectProjectRuleSets":"PRS","checkCustomRules":"CR3","findProjectRoot":"PR","analyzeFileLocals":"FL","getDeadCode":"DC","getFilters":"gF","setFilters":"sF","addExcludes":"aE","removeExcludes":"rE","resetFilters":"rF","parseGitignore":"pG1","shouldExcludeDir":"ED","shouldExcludeFile":"EF","matchWildcard":"mW","matchGitignorePattern":"GP","fetchReference":"fR","listAvailable":"lA","getFrameworkReference":"FR","calculateHealthScore":"HS","getFullAnalysis":"FA","minifyLegend":"mL","createShortName":"SN","buildGraph":"bG","createSkeleton":"cS","getInstructions":"gI","generateJSDoc":"JSD","buildJSDoc":"JSD1","extractParamName":"PN","inferParamType":"PT","generateJSDocFor":"JSD2","parseGo":"pG2","extractImports":"eI","getBody":"gB","extractCalls":"eC","parsePython":"pP","parseTypeScript":"TS","extractParams":"eP","stripStringsAndComments":"SAC","getLargeFiles":"LF","createServer":"cS1","startStdioServer":"SS","analyzeFilePatterns":"FP","analyzePackageJson":"PJ","getOutdatedPatterns":"OP","parseFile":"pF","parseProject":"pP1","parseFileByExtension":"FBE","isSourceFile":"SF","extractSignatures":"eS","buildSignature":"bS","hashBodyStructure":"BS","calculateSimilarity":"cS2","getSimilarFunctions":"SF1","parseAnnotations":"pA","getAllFeatures":"AF","getPendingTests":"PT1","markTestPassed":"TP","markTestFailed":"TF","getTestSummary":"TS1","resetTestState":"TS2","generateMarkdown":"gM","saveDiskCache":"DC1","loadDiskCache":"DC2","getGraph":"gG","detectChanges":"dC","snapshotMtimes":"sM","getSkeleton":"gS","getFocusZone":"FZ","expand":"ex","deps":"de","usages":"us","extractMethod":"eM","getCallChain":"CC","invalidateCache":"iC","extractComments":"eC1","findJSDocBefore":"JSD3","checkMissing":"cM","getUndocumented":"gU","getUndocumentedSummary":"US","setRoots":"sR","getWorkspaceRoot":"WR","resolvePath":"rP"},"reverseLegend":{"gA":"getArg","gP":"getPath","pH":"printHelp","CLI":"runCLI","JSF":"findJSFiles","cC":"calculateComplexity","gR":"getRating","aF":"analyzeFile","gC":"getComplexity","pG":"parseGraphignore","iG":"isGraphignored","RS":"loadRuleSets","RS1":"saveRuleSet","fF":"findFiles","iE":"isExcluded","ISO":"isInStringOrComment","WC":"isWithinContext","FAR":"checkFileAgainstRule","CR":"getCustomRules","CR1":"setCustomRule","CR2":"deleteCustomRule","PRS":"detectProjectRuleSets","CR3":"checkCustomRules","PR":"findProjectRoot","FL":"analyzeFileLocals","DC":"getDeadCode","gF":"getFilters","sF":"setFilters","aE":"addExcludes","rE":"removeExcludes","rF":"resetFilters","pG1":"parseGitignore","ED":"shouldExcludeDir","EF":"shouldExcludeFile","mW":"matchWildcard","GP":"matchGitignorePattern","fR":"fetchReference","lA":"listAvailable","FR":"getFrameworkReference","HS":"calculateHealthScore","FA":"getFullAnalysis","mL":"minifyLegend","SN":"createShortName","bG":"buildGraph","cS":"createSkeleton","gI":"getInstructions","JSD":"generateJSDoc","JSD1":"buildJSDoc","PN":"extractParamName","PT":"inferParamType","JSD2":"generateJSDocFor","pG2":"parseGo","eI":"extractImports","gB":"getBody","eC":"extractCalls","pP":"parsePython","TS":"parseTypeScript","eP":"extractParams","SAC":"stripStringsAndComments","LF":"getLargeFiles","cS1":"createServer","SS":"startStdioServer","FP":"analyzeFilePatterns","PJ":"analyzePackageJson","OP":"getOutdatedPatterns","pF":"parseFile","pP1":"parseProject","FBE":"parseFileByExtension","SF":"isSourceFile","eS":"extractSignatures","bS":"buildSignature","BS":"hashBodyStructure","cS2":"calculateSimilarity","SF1":"getSimilarFunctions","pA":"parseAnnotations","AF":"getAllFeatures","PT1":"getPendingTests","TP":"markTestPassed","TF":"markTestFailed","TS1":"getTestSummary","TS2":"resetTestState","gM":"generateMarkdown","DC1":"saveDiskCache","DC2":"loadDiskCache","gG":"getGraph","dC":"detectChanges","sM":"snapshotMtimes","gS":"getSkeleton","FZ":"getFocusZone","ex":"expand","de":"deps","us":"usages","eM":"extractMethod","CC":"getCallChain","iC":"invalidateCache","eC1":"extractComments","JSD3":"findJSDocBefore","cM":"checkMissing","gU":"getUndocumented","US":"getUndocumentedSummary","sR":"setRoots","WR":"getWorkspaceRoot","rP":"resolvePath"},"stats":{"files":26,"classes":0,"functions":115},"nodes":{"gA":{"t":"F","e":false,"f":"cli-handlers.js"},"gP":{"t":"F","e":false,"f":"cli-handlers.js"},"pH":{"t":"F","e":true,"f":"cli.js"},"CLI":{"t":"F","e":true,"f":"cli.js"},"JSF":{"t":"F","e":false,"f":"undocumented.js"},"cC":{"t":"F","e":false,"f":"complexity.js"},"gR":{"t":"F","e":false,"f":"complexity.js"},"aF":{"t":"F","e":false,"f":"large-files.js"},"gC":{"t":"F","e":true,"f":"complexity.js"},"pG":{"t":"F","e":false,"f":"custom-rules.js"},"iG":{"t":"F","e":false,"f":"custom-rules.js"},"RS":{"t":"F","e":false,"f":"custom-rules.js"},"RS1":{"t":"F","e":false,"f":"custom-rules.js"},"fF":{"t":"F","e":false,"f":"custom-rules.js"},"iE":{"t":"F","e":false,"f":"custom-rules.js"},"ISO":{"t":"F","e":false,"f":"custom-rules.js"},"WC":{"t":"F","e":false,"f":"custom-rules.js"},"FAR":{"t":"F","e":false,"f":"custom-rules.js"},"CR":{"t":"F","e":true,"f":"custom-rules.js"},"CR1":{"t":"F","e":true,"f":"custom-rules.js"},"CR2":{"t":"F","e":true,"f":"custom-rules.js"},"PRS":{"t":"F","e":true,"f":"custom-rules.js"},"CR3":{"t":"F","e":true,"f":"custom-rules.js"},"PR":{"t":"F","e":false,"f":"dead-code.js"},"FL":{"t":"F","e":false,"f":"dead-code.js"},"DC":{"t":"F","e":true,"f":"dead-code.js"},"gF":{"t":"F","e":true,"f":"filters.js"},"sF":{"t":"F","e":true,"f":"filters.js"},"aE":{"t":"F","e":true,"f":"filters.js"},"rE":{"t":"F","e":true,"f":"filters.js"},"rF":{"t":"F","e":true,"f":"filters.js"},"pG1":{"t":"F","e":true,"f":"filters.js"},"ED":{"t":"F","e":true,"f":"filters.js"},"EF":{"t":"F","e":true,"f":"filters.js"},"mW":{"t":"F","e":false,"f":"filters.js"},"GP":{"t":"F","e":false,"f":"filters.js"},"fR":{"t":"F","e":false,"f":"framework-references.js"},"lA":{"t":"F","e":false,"f":"framework-references.js"},"FR":{"t":"F","e":true,"f":"framework-references.js"},"HS":{"t":"F","e":false,"f":"full-analysis.js"},"FA":{"t":"F","e":true,"f":"full-analysis.js"},"mL":{"t":"F","e":true,"f":"graph-builder.js"},"SN":{"t":"F","e":false,"f":"graph-builder.js"},"bG":{"t":"F","e":true,"f":"graph-builder.js"},"cS":{"t":"F","e":true,"f":"graph-builder.js"},"gI":{"t":"F","e":true,"f":"instructions.js"},"JSD":{"t":"F","e":true,"f":"jsdoc-generator.js"},"JSD1":{"t":"F","e":false,"f":"jsdoc-generator.js"},"PN":{"t":"F","e":false,"f":"similar-functions.js"},"PT":{"t":"F","e":false,"f":"jsdoc-generator.js"},"JSD2":{"t":"F","e":true,"f":"jsdoc-generator.js"},"pG2":{"t":"F","e":true,"f":"lang-go.js"},"eI":{"t":"F","e":false,"f":"lang-go.js"},"gB":{"t":"F","e":false,"f":"lang-go.js"},"eC":{"t":"F","e":false,"f":"parser.js"},"pP":{"t":"F","e":true,"f":"lang-python.js"},"TS":{"t":"F","e":true,"f":"lang-typescript.js"},"eP":{"t":"F","e":false,"f":"lang-typescript.js"},"SAC":{"t":"F","e":true,"f":"lang-utils.js"},"LF":{"t":"F","e":true,"f":"large-files.js"},"cS1":{"t":"F","e":true,"f":"mcp-server.js"},"SS":{"t":"F","e":true,"f":"mcp-server.js"},"FP":{"t":"F","e":false,"f":"outdated-patterns.js"},"PJ":{"t":"F","e":false,"f":"outdated-patterns.js"},"OP":{"t":"F","e":true,"f":"outdated-patterns.js"},"pF":{"t":"F","e":false,"f":"undocumented.js"},"pP1":{"t":"F","e":true,"f":"parser.js"},"FBE":{"t":"F","e":false,"f":"parser.js"},"SF":{"t":"F","e":false,"f":"parser.js"},"eS":{"t":"F","e":false,"f":"similar-functions.js"},"bS":{"t":"F","e":false,"f":"similar-functions.js"},"BS":{"t":"F","e":false,"f":"similar-functions.js"},"cS2":{"t":"F","e":false,"f":"similar-functions.js"},"SF1":{"t":"F","e":true,"f":"similar-functions.js"},"pA":{"t":"F","e":true,"f":"test-annotations.js"},"AF":{"t":"F","e":true,"f":"test-annotations.js"},"PT1":{"t":"F","e":true,"f":"test-annotations.js"},"TP":{"t":"F","e":true,"f":"test-annotations.js"},"TF":{"t":"F","e":true,"f":"test-annotations.js"},"TS1":{"t":"F","e":true,"f":"test-annotations.js"},"TS2":{"t":"F","e":true,"f":"test-annotations.js"},"gM":{"t":"F","e":true,"f":"test-annotations.js"},"DC1":{"t":"F","e":false,"f":"tools.js"},"DC2":{"t":"F","e":false,"f":"tools.js"},"gG":{"t":"F","e":false,"f":"tools.js"},"dC":{"t":"F","e":false,"f":"tools.js"},"sM":{"t":"F","e":false,"f":"tools.js"},"gS":{"t":"F","e":true,"f":"tools.js"},"FZ":{"t":"F","e":true,"f":"tools.js"},"ex":{"t":"F","e":true,"f":"tools.js"},"de":{"t":"F","e":true,"f":"tools.js"},"us":{"t":"F","e":true,"f":"tools.js"},"eM":{"t":"F","e":false,"f":"tools.js"},"CC":{"t":"F","e":true,"f":"tools.js"},"iC":{"t":"F","e":true,"f":"tools.js"},"eC1":{"t":"F","e":false,"f":"undocumented.js"},"JSD3":{"t":"F","e":false,"f":"undocumented.js"},"cM":{"t":"F","e":false,"f":"undocumented.js"},"gU":{"t":"F","e":true,"f":"undocumented.js"},"US":{"t":"F","e":true,"f":"undocumented.js"},"sR":{"t":"F","e":true,"f":"workspace.js"},"WR":{"t":"F","e":true,"f":"workspace.js"},"rP":{"t":"F","e":true,"f":"workspace.js"}},"edges":[],"orphans":["getArg","getPath","findJSFiles","calculateComplexity","getRating","analyzeFile","parseGraphignore","isGraphignored","loadRuleSets","saveRuleSet","findFiles","isExcluded","isInStringOrComment","isWithinContext","checkFileAgainstRule","findProjectRoot","analyzeFileLocals","matchWildcard","matchGitignorePattern","fetchReference","listAvailable","calculateHealthScore","createShortName","buildJSDoc","extractParamName","inferParamType","extractImports","getBody","extractCalls","extractParams","analyzeFilePatterns","analyzePackageJson","parseFile","parseFileByExtension","isSourceFile","extractSignatures","buildSignature","hashBodyStructure","calculateSimilarity","saveDiskCache","loadDiskCache","getGraph","detectChanges","snapshotMtimes","extractMethod","extractComments","findJSDocBefore","checkMissing"],"duplicates":{},"files":["cli-handlers.js","cli.js","complexity.js","custom-rules.js","dead-code.js","filters.js","framework-references.js","full-analysis.js","graph-builder.js","instructions.js","jsdoc-generator.js","lang-go.js","lang-python.js","lang-typescript.js","lang-utils.js","large-files.js","mcp-server.js","outdated-patterns.js","parser.js","server.js","similar-functions.js","test-annotations.js","tool-defs.js","tools.js","undocumented.js","workspace.js"]}}

package/src/filters.js

@@ -32,6 +32,7 @@ const DEFAULT_EXCLUDE_PATTERNS = [
   '*.min.js',
   '*.bundle.js',
   '*.d.ts',
+  '.project-graph-cache.json',
 ];
 
 // Current filter configuration (mutable via MCP)

package/src/graph-builder.js

@@ -169,7 +169,7 @@ export function buildGraph(parsed) {
   }
 
   // Detect duplicates (same method name in multiple classes)
-  const methodLocations = {};
+  const methodLocations = Object.create(null);
   for (const cls of classes) {
     for (const method of cls.methods || []) {
       if (!methodLocations[method]) {

package/src/lang-go.js

@@ -0,0 +1,285 @@
+import { stripStringsAndComments } from './lang-utils.js';
+
+/**
+ * Parse Go file using regex-based structural extraction.
+ * @param {string} code - Go source code
+ * @param {string} filename - File path
+ * @returns {ParseResult}
+ */
+export function parseGo(code, filename) {
+  const result = {
+    file: filename,
+    classes: [],
+    functions: [],
+    imports: [],
+    exports: []
+  };
+
+  const { imports, packageNames } = extractImports(code);
+  result.imports = imports;
+
+  const cleanCode = stripStringsAndComments(code, {
+    singleQuote: false,
+    backtick: true,
+    templateInterpolation: false
+  });
+
+  const classesMap = new Map();
+
+  // Extract Structs (mapped to classes)
+  const structRegex = /^\s*type\s+([a-zA-Z_]\w*)\s+struct\s*\{/gm;
+  let match;
+  while ((match = structRegex.exec(cleanCode)) !== null) {
+    const name = match[1];
+    const start = match.index + match[0].length;
+    const body = getBody(cleanCode, start);
+    const line = code.substring(0, match.index).split('\n').length;
+
+    let extendsName = null;
+    const properties = [];
+
+    const lines = body.split('\n').map(l => l.trim()).filter(l => l);
+    for (const lineStr of lines) {
+      const parts = lineStr.split(/\s+/);
+      if (parts.length === 1) {
+        extendsName = parts[0].replace(/^\*/, ''); // Remove pointer if embedded
+      } else if (parts.length >= 2) {
+        const propName = parts[0].replace(/,$/, '');
+        properties.push(propName);
+      }
+    }
+
+    classesMap.set(name, {
+      name,
+      extends: extendsName,
+      methods: [],
+      properties,
+      calls: [],
+      file: filename,
+      line
+    });
+  }
+
+  // Extract Interfaces (mapped to classes)
+  const interfaceRegex = /^\s*type\s+([a-zA-Z_]\w*)\s+interface\s*\{/gm;
+  while ((match = interfaceRegex.exec(cleanCode)) !== null) {
+    const name = match[1];
+    const start = match.index + match[0].length;
+    const body = getBody(cleanCode, start);
+    const line = code.substring(0, match.index).split('\n').length;
+
+    let extendsName = null;
+    const methods = [];
+
+    const lines = body.split('\n').map(l => l.trim()).filter(l => l);
+    for (const lineStr of lines) {
+      const parenIndex = lineStr.indexOf('(');
+      if (parenIndex !== -1) {
+        const beforeParen = lineStr.substring(0, parenIndex).trim();
+        const parts = beforeParen.split(/\s+/);
+        const methodName = parts[parts.length - 1];
+        if (methodName) {
+          methods.push(methodName);
+        }
+      } else {
+        const parts = lineStr.split(/\s+/);
+        if (parts.length === 1) {
+          extendsName = parts[0];
+        }
+      }
+    }
+
+    classesMap.set(name, {
+      name,
+      extends: extendsName,
+      methods,
+      properties: [],
+      calls: [],
+      file: filename,
+      line
+    });
+  }
+
+  // Extract Methods
+  const methodRegex = /^\s*func\s+\(\s*[a-zA-Z_]\w*\s+\*?([a-zA-Z_]\w*)\s*\)\s+([a-zA-Z_]\w*)[^{]*\{/gm;
+  while ((match = methodRegex.exec(cleanCode)) !== null) {
+    const className = match[1];
+    const methodName = match[2];
+    const start = match.index + match[0].length;
+    const body = getBody(cleanCode, start);
+    const line = code.substring(0, match.index).split('\n').length;
+
+    const methodCalls = extractCalls(body, packageNames);
+
+    if (!classesMap.has(className)) {
+      classesMap.set(className, {
+        name: className,
+        extends: null,
+        methods: [],
+        properties: [],
+        calls: [],
+        file: filename,
+        line
+      });
+    }
+
+    const classInfo = classesMap.get(className);
+    classInfo.methods.push(methodName);
+    
+    for (const call of methodCalls) {
+      if (!classInfo.calls.includes(call)) {
+        classInfo.calls.push(call);
+      }
+    }
+  }
+
+  // Extract Functions (top-level)
+  const funcRegex = /^\s*func\s+([a-zA-Z_]\w*)\s*\(([^)]*)\)[^{]*\{/gm;
+  while ((match = funcRegex.exec(cleanCode)) !== null) {
+    const name = match[1];
+    const paramsStr = match[2];
+    const params = paramsStr.split(',')
+      .map(p => p.trim().split(/\s+/)[0])
+      .filter(p => p);
+
+    const exported = /^[A-Z]/.test(name);
+    const start = match.index + match[0].length;
+    const body = getBody(cleanCode, start);
+    const line = code.substring(0, match.index).split('\n').length;
+
+    const calls = extractCalls(body, packageNames);
+
+    result.functions.push({
+      name,
+      exported,
+      calls,
+      params,
+      file: filename,
+      line
+    });
+  }
+
+  result.classes = Array.from(classesMap.values());
+
+  // Extract Exports
+  for (const cls of result.classes) {
+    if (/^[A-Z]/.test(cls.name)) {
+      result.exports.push(cls.name);
+    }
+  }
+  for (const fn of result.functions) {
+    if (fn.exported) {
+      result.exports.push(fn.name);
+    }
+  }
+
+  return result;
+}
+
+function extractImports(text) {
+  const imports = [];
+  const packageNames = new Set();
+  
+  // Strip comments to avoid commented out imports
+  const noComments = text.replace(/\/\/.*/g, '').replace(/\/\*[\s\S]*?\*\//g, '');
+  
+  const importBlockRegex = /import\s*\(([\s\S]*?)\)/g;
+  let match;
+  while ((match = importBlockRegex.exec(noComments)) !== null) {
+    const block = match[1];
+    const lines = block.split('\n');
+    for (const line of lines) {
+      const lineMatch = line.match(/(?:([a-zA-Z_]\w*)\s+)?"([^"]+)"/);
+      if (lineMatch) {
+        const alias = lineMatch[1];
+        const pkgPath = lineMatch[2];
+        if (alias) {
+          if (!imports.includes(alias)) {
+            imports.push(alias);
+            packageNames.add(alias);
+          }
+        } else {
+          if (!imports.includes(pkgPath)) {
+            imports.push(pkgPath);
+            const parts = pkgPath.split('/');
+            packageNames.add(parts[parts.length - 1]);
+          }
+        }
+      }
+    }
+  }
+  
+  const singleImportRegex = /import\s+(?:([a-zA-Z_]\w*)\s+)?"([^"]+)"/g;
+  while ((match = singleImportRegex.exec(noComments)) !== null) {
+    const alias = match[1];
+    const pkgPath = match[2];
+    if (alias) {
+      if (!imports.includes(alias)) {
+        imports.push(alias);
+        packageNames.add(alias);
+      }
+    } else {
+      if (!imports.includes(pkgPath)) {
+        imports.push(pkgPath);
+        const parts = pkgPath.split('/');
+        packageNames.add(parts[parts.length - 1]);
+      }
+    }
+  }
+  
+  return { imports, packageNames };
+}
+
+/**
+ * Extract block body correctly handling nested braces.
+ * @param {string} code
+ * @param {number} startIndex
+ * @returns {string}
+ */
+function getBody(code, startIndex) {
+  let braces = 1;
+  let end = startIndex;
+  while (end < code.length && braces > 0) {
+    if (code[end] === '{') braces++;
+    else if (code[end] === '}') braces--;
+    end++;
+  }
+  return code.substring(startIndex, end - 1);
+}
+
+/**
+ * Extract method calls from a block of code, filtering out Go keywords.
+ * @param {string} body
+ * @param {Set<string>} packageNames
+ * @returns {string[]}
+ */
+function extractCalls(body, packageNames) {
+  const calls = [];
+  const callRegex = /([a-zA-Z_]\w*(?:\.[a-zA-Z_]\w*)?)\s*\(/g;
+  let match;
+  while ((match = callRegex.exec(body)) !== null) {
+    let callName = match[1];
+    
+    const keywords = [
+      'if', 'for', 'switch', 'func', 'panic', 'recover', 'len', 'cap', 
+      'make', 'new', 'append', 'copy', 'delete', 'close',
+      'int', 'string', 'bool', 'byte', 'rune', 'float32', 'float64', 
+      'int32', 'int64', 'uint32', 'uint64', 'complex64', 'complex128'
+    ];
+    if (keywords.includes(callName)) continue;
+
+    if (callName.includes('.')) {
+      const parts = callName.split('.');
+      // If the first part is a known package name, keep it (e.g., fmt.Println)
+      // Otherwise, assume it's a method call on a variable and strip it (e.g., s.Handle -> Handle)
+      if (!packageNames.has(parts[0])) {
+        callName = parts[1];
+      }
+    }
+
+    if (!calls.includes(callName)) {
+      calls.push(callName);
+    }
+  }
+  return calls;
+}

package/src/lang-python.js

@@ -0,0 +1,197 @@
+import { stripStringsAndComments } from './lang-utils.js';
+
+/**
+ * Parse Python file using regex-based structural extraction.
+ * @param {string} code - Python source code
+ * @param {string} filename - File path
+ * @returns {ParseResult}
+ */
+export function parsePython(code = '', filename = '') {
+  const result = {
+    file: filename,
+    classes: [],
+    functions: [],
+    imports: [],
+    exports: []
+  };
+
+  // Pre-process: remove docstrings, triple-quoted strings, and line comments
+  const cleanCode = stripStringsAndComments(code, {
+    singleQuote: true,
+    hashComment: true,
+    tripleQuote: true
+  });
+
+  const lines = cleanCode.split('\n');
+  
+  let currentClass = null;
+  let currentFunc = null;
+  let classIndent = -1;
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (!line.trim()) continue;
+
+    const indentMatch = line.match(/^([ \t]*)/);
+    const indent = indentMatch ? indentMatch[1].length : 0;
+
+    // Check if we exited a class scope
+    if (currentClass && indent <= classIndent) {
+      currentClass = null;
+      classIndent = -1;
+    }
+
+    // Check if we exited a function scope
+    if (currentFunc && indent === 0) {
+      currentFunc = null;
+    }
+
+    // Match Class (top-level)
+    const classMatch = line.match(/^class\s+([a-zA-Z_]\w*)(?:\s*\((.*?)\))?\s*:/);
+    if (classMatch) {
+      currentClass = {
+        name: classMatch[1],
+        extends: classMatch[2] ? classMatch[2].trim() : null,
+        methods: [],
+        properties: [],
+        calls: [],
+        file: filename,
+        line: i + 1
+      };
+      result.classes.push(currentClass);
+      classIndent = indent;
+      currentFunc = null;
+      continue;
+    }
+
+    // Match top-level function
+    const funcMatch = line.match(/^(?:async\s+)?def\s+([a-zA-Z_]\w*)\s*\(([^)]*)\)?/);
+    if (funcMatch) {
+      const paramsStr = funcMatch[2] || '';
+      const params = paramsStr.split(',')
+        .map(p => p.split(/[:=]/)[0].trim())
+        .filter(p => p && p !== 'self' && p !== 'cls');
+
+      currentFunc = {
+        name: funcMatch[1],
+        exported: true, // we'll adjust later if __all__ is present
+        calls: [],
+        params: params,
+        file: filename,
+        line: i + 1
+      };
+      result.functions.push(currentFunc);
+      currentClass = null;
+      continue;
+    }
+
+    // Match Method (inside class)
+    const methodMatch = line.match(/^[ \t]+(?:async\s+)?def\s+([a-zA-Z_]\w*)\s*\(/);
+    if (methodMatch && currentClass && indent > classIndent) {
+      const methodName = methodMatch[1];
+      if (methodName !== '__init__') {
+        currentClass.methods.push(methodName);
+      }
+      currentFunc = null; // not a top-level function
+      continue;
+    }
+
+    // Match Imports
+    const importMatch = line.match(/^\s*import\s+(.+)/);
+    if (importMatch) {
+      const parts = importMatch[1].split(',');
+      for (const part of parts) {
+        const p = part.trim();
+        const asMatch = p.match(/(?:.+)\s+as\s+([a-zA-Z_]\w*)/);
+        if (asMatch) {
+          result.imports.push(asMatch[1]);
+        } else {
+          result.imports.push(p.split('.')[0]); // take root module
+        }
+      }
+      continue;
+    }
+
+    const fromImportMatch = line.match(/^\s*from\s+([.\w]+)\s+import\s*(.*)/);
+    if (fromImportMatch) {
+      let imported = fromImportMatch[2];
+      if (imported.includes('(') && !imported.includes(')')) {
+        let j = i + 1;
+        while (j < lines.length) {
+          imported += ' ' + lines[j];
+          if (lines[j].includes(')')) {
+            i = j;
+            break;
+          }
+          j++;
+        }
+      }
+      imported = imported.replace(/[()]/g, '');
+      const parts = imported.split(',');
+      for (const part of parts) {
+        const p = part.trim();
+        if (!p) continue;
+        const asMatch = p.match(/(?:.+)\s+as\s+([a-zA-Z_]\w*)/);
+        if (asMatch) {
+          result.imports.push(asMatch[1]);
+        } else {
+          result.imports.push(p);
+        }
+      }
+      continue;
+    }
+
+    // Extract calls: look for func(...)
+    const callRegex = /([a-zA-Z_][\w.]*)\s*\(/g;
+    let match;
+    const keywords = new Set(['if', 'while', 'for', 'elif', 'return', 'yield', 'def', 'class', 'and', 'or', 'not', 'in', 'is', 'print']);
+    while ((match = callRegex.exec(line)) !== null) {
+      const callName = match[1];
+      if (keywords.has(callName)) continue;
+      
+      let cleanCallName = callName;
+      if (cleanCallName.startsWith('self.')) {
+        cleanCallName = cleanCallName.substring(5);
+      }
+      
+      if (currentFunc) {
+        if (!currentFunc.calls.includes(cleanCallName)) {
+          currentFunc.calls.push(cleanCallName);
+        }
+      } else if (currentClass) {
+        if (!currentClass.calls.includes(cleanCallName)) {
+          currentClass.calls.push(cleanCallName);
+        }
+      }
+    }
+  }
+
+  // Handle Exports (__all__)
+  const allMatch = code.match(/__all__\s*=\s*\[(.*?)\]/s);
+  if (allMatch) {
+    const exportsRaw = allMatch[1];
+    const exportRegex = /['"]([^'"]+)['"]/g;
+    let exMatch;
+    while ((exMatch = exportRegex.exec(exportsRaw)) !== null) {
+      result.exports.push(exMatch[1]);
+    }
+    // Update exported flags for functions
+    for (const fn of result.functions) {
+      fn.exported = result.exports.includes(fn.name);
+    }
+  } else {
+    // Implicit exports: all top-level functions and classes are exported
+    for (const cls of result.classes) {
+      result.exports.push(cls.name);
+    }
+    for (const fn of result.functions) {
+      result.exports.push(fn.name);
+      fn.exported = true;
+    }
+  }
+  
+  // Deduplicate imports
+  result.imports = [...new Set(result.imports)];
+
+  return result;
+}

package/src/lang-typescript.js

@@ -0,0 +1,190 @@
+import { stripStringsAndComments } from './lang-utils.js';
+
+/**
+ * TypeScript/TSX regex-based parser.
+ * Extracts structural information (classes, functions, imports, exports, calls)
+ * directly from TypeScript code without relying on Acorn.
+ *
+ * Strategy: Instead of stripping TS syntax to feed Acorn (which causes
+ * catastrophic backtracking in regex), parse structural elements directly
+ * — same approach as lang-python.js and lang-go.js.
+ *
+ * @param {string} code - TypeScript source code
+ * @param {string} filename - File path for the result
+ * @returns {ParseResult}
+ */
+export function parseTypeScript(code, filename) {
+  const result = {
+    file: filename,
+    classes: [],
+    functions: [],
+    imports: [],
+    exports: [],
+  };
+
+  // Strip strings, template literals, and comments to avoid false matches
+  const cleaned = stripStringsAndComments(code);
+  const lines = cleaned.split('\n');
+
+  let currentClass = null;
+  let currentFunc = null;
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const lineNum = i + 1;
+
+    // --- Imports ---
+    // import { A, B } from 'module'
+    const importFromMatch = line.match(/^\s*import\s+(?:type\s+)?(?:\{([^}]+)\}|(\w+))\s+from\s/);
+    if (importFromMatch) {
+      if (importFromMatch[1]) {
+        importFromMatch[1].split(',').forEach(s => {
+          const name = s.trim().replace(/\s+as\s+\w+/, '').replace(/^type\s+/, '');
+          if (name) result.imports.push(name);
+        });
+      } else if (importFromMatch[2]) {
+        result.imports.push(importFromMatch[2]);
+      }
+      continue;
+    }
+    // import * as name from 'module'
+    const importStarMatch = line.match(/^\s*import\s+\*\s+as\s+(\w+)\s+from\s/);
+    if (importStarMatch) {
+      result.imports.push(importStarMatch[1]);
+      continue;
+    }
+
+    // --- Exports ---
+    const exportMatch = line.match(/^\s*export\s+(?:default\s+)?(?:class|function|const|let|var|type|interface|enum|abstract)\s+(\w+)/);
+    if (exportMatch) {
+      result.exports.push(exportMatch[1]);
+    }
+    // export { A, B }
+    const exportBraceMatch = line.match(/^\s*export\s+\{([^}]+)\}/);
+    if (exportBraceMatch) {
+      exportBraceMatch[1].split(',').forEach(s => {
+        const name = s.trim().replace(/\s+as\s+\w+/, '');
+        if (name) result.exports.push(name);
+      });
+    }
+
+    // Skip type-only declarations (no runtime code)
+    if (/^\s*(type|interface)\s+\w+/.test(line)) {
+      continue;
+    }
+
+    // --- Classes ---
+    const classMatch = line.match(/^\s*(?:export\s+)?(?:default\s+)?(?:abstract\s+)?class\s+(\w+)(?:\s+extends\s+(\w+))?/);
+    if (classMatch) {
+      currentClass = {
+        name: classMatch[1],
+        extends: classMatch[2] || null,
+        methods: [],
+        properties: [],
+        calls: [],
+        file: filename,
+        line: lineNum,
+      };
+      result.classes.push(currentClass);
+      currentFunc = null;
+      continue;
+    }
+
+    // Detect end of class or function (closing brace at col 0)
+    if (/^}/.test(line)) {
+      currentClass = null;
+      currentFunc = null;
+      continue;
+    }
+
+    // --- Methods (inside class) ---
+    if (currentClass) {
+      // public/private/protected/static/async methodName(
+      const methodMatch = line.match(/^\s+(?:(?:public|private|protected|static|readonly|abstract|override|async)\s+)*(\w+)\s*(?:<[^>]*>)?\s*\(/);
+      if (methodMatch && methodMatch[1] !== 'if' && methodMatch[1] !== 'for' &&
+          methodMatch[1] !== 'while' && methodMatch[1] !== 'switch' &&
+          methodMatch[1] !== 'catch' && methodMatch[1] !== 'return' &&
+          methodMatch[1] !== 'new' && methodMatch[1] !== 'constructor' &&
+          methodMatch[1] !== 'super') {
+        currentClass.methods.push(methodMatch[1]);
+      }
+      // constructor
+      if (/^\s+constructor\s*\(/.test(line)) {
+        currentClass.methods.push('constructor');
+      }
+      // Property: name: Type or name = value
+      const propMatch = line.match(/^\s+(?:(?:public|private|protected|static|readonly|declare|override|abstract)\s+)*(\w+)\s*[?!]?\s*[:=]/);
+      if (propMatch && !methodMatch && propMatch[1] !== 'if' && propMatch[1] !== 'const' &&
+          propMatch[1] !== 'let' && propMatch[1] !== 'var' && propMatch[1] !== 'return') {
+        currentClass.properties.push(propMatch[1]);
+      }
+    }
+
+    // --- Functions (top-level) ---
+    if (!currentClass) {
+      // function name(, async function name(, export function, export default function
+      const fnMatch = line.match(/^\s*(?:export\s+)?(?:default\s+)?(?:async\s+)?function\s+(\w+)/);
+      if (fnMatch) {
+        currentFunc = {
+          name: fnMatch[1],
+          exported: /^\s*export\s+/.test(line),
+          calls: [],
+          params: extractParams(line),
+          file: filename,
+          line: lineNum,
+        };
+        result.functions.push(currentFunc);
+        continue;
+      }
+      // Arrow functions: const name = (...) => or export const name = (
+      const arrowMatch = line.match(/^\s*(?:export\s+)?(?:const|let|var)\s+(\w+)\s*=\s*(?:async\s+)?(?:\([^)]*\)|[a-zA-Z_]\w*)\s*(?::\s*\w+(?:<[^>]*>)?)?\s*=>/);
+      if (arrowMatch) {
+        currentFunc = {
+          name: arrowMatch[1],
+          exported: /^\s*export\s+/.test(line),
+          calls: [],
+          params: extractParams(line),
+          file: filename,
+          line: lineNum,
+        };
+        result.functions.push(currentFunc);
+        continue;
+      }
+    }
+
+    // --- Calls ---
+    const callRegex = /\b([a-zA-Z_$]\w*)\s*(?:<[^>]*>)?\s*\(/g;
+    let callMatch;
+    while ((callMatch = callRegex.exec(line)) !== null) {
+      const name = callMatch[1];
+      // Skip keywords and common built-ins
+      if (['if', 'for', 'while', 'switch', 'catch', 'return', 'new', 'throw',
+           'typeof', 'delete', 'void', 'import', 'export', 'class', 'function',
+           'const', 'let', 'var', 'async', 'await', 'super', 'this',
+           'interface', 'type', 'enum', 'declare', 'abstract'].includes(name)) {
+        continue;
+      }
+      if (currentClass) {
+        currentClass.calls.push(name);
+      } else if (currentFunc) {
+        currentFunc.calls.push(name);
+      }
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Extract parameter names from a function signature line.
+ * @param {string} line
+ * @returns {string[]}
+ */
+function extractParams(line) {
+  const match = line.match(/\(([^)]*)\)/);
+  if (!match) return [];
+  return match[1]
+    .split(',')
+    .map(p => p.trim().replace(/[?!]?\s*:.*$/, '').replace(/\s*=.*$/, '').trim())
+    .filter(p => p && !p.startsWith('...'));
+}

package/src/lang-utils.js

@@ -0,0 +1,124 @@
+/**
+ * Strip strings, template literals, and comments from source code.
+ * Preserves line structure (newlines are kept) and character positions.
+ * @param {string} code
+ * @param {Object} [options]
+ * @param {boolean} [options.singleQuote=true] - Handle single-quoted strings
+ * @param {boolean} [options.backtick=true] - Handle backtick strings/templates
+ * @param {boolean} [options.hashComment=false] - Handle # comments (Python)
+ * @param {boolean} [options.tripleQuote=false] - Handle ''' and """ (Python)
+ * @param {boolean} [options.templateInterpolation=true] - Handle ${} in backticks
+ * @returns {string}
+ */
+export function stripStringsAndComments(code, options = {}) {
+  const {
+    singleQuote = true,
+    backtick = true,
+    hashComment = false,
+    tripleQuote = false,
+    templateInterpolation = true
+  } = options;
+
+  let result = '';
+  let i = 0;
+
+  while (i < code.length) {
+    // Hash comment
+    if (hashComment && code[i] === '#') {
+      while (i < code.length && code[i] !== '\n') {
+        result += ' ';
+        i++;
+      }
+      continue;
+    }
+
+    // Triple quotes
+    if (tripleQuote && (
+      (code[i] === "'" && code[i+1] === "'" && code[i+2] === "'") ||
+      (code[i] === '"' && code[i+1] === '"' && code[i+2] === '"')
+    )) {
+      const quote = code[i];
+      result += '   ';
+      i += 3;
+      while (i < code.length) {
+        if (code[i] === '\\') {
+          result += '  ';
+          i += 2;
+          continue;
+        }
+        if (code[i] === quote && code[i+1] === quote && code[i+2] === quote) {
+          result += '   ';
+          i += 3;
+          break;
+        }
+        result += code[i] === '\n' ? '\n' : ' ';
+        i++;
+      }
+      continue;
+    }
+
+    // Single-line comment //
+    if (!hashComment && code[i] === '/' && code[i + 1] === '/') {
+      while (i < code.length && code[i] !== '\n') {
+        result += ' ';
+        i++;
+      }
+      continue;
+    }
+
+    // Multi-line comment /* ... */
+    if (!hashComment && code[i] === '/' && code[i + 1] === '*') {
+      i += 2;
+      result += '  ';
+      while (i < code.length && !(code[i] === '*' && code[i + 1] === '/')) {
+        result += code[i] === '\n' ? '\n' : ' ';
+        i++;
+      }
+      if (i < code.length) { result += '  '; i += 2; }
+      continue;
+    }
+
+    // String literals
+    if (code[i] === '"' || (singleQuote && code[i] === "'") || (backtick && code[i] === '`')) {
+      const quote = code[i];
+      result += ' ';
+      i++;
+      while (i < code.length) {
+        if (code[i] === '\\') {
+          result += '  ';
+          i += 2;
+          continue;
+        }
+        if (code[i] === quote) {
+          result += ' ';
+          i++;
+          break;
+        }
+        // Template literal: ${...} — keep the expression
+        if (templateInterpolation && quote === '`' && code[i] === '$' && code[i + 1] === '{') {
+          result += '${';
+          i += 2;
+          let depth = 1;
+          while (i < code.length && depth > 0) {
+            if (code[i] === '{') depth++;
+            if (code[i] === '}') depth--;
+            if (depth > 0) {
+              result += code[i] === '\n' ? '\n' : code[i];
+            } else {
+              result += '}';
+            }
+            i++;
+          }
+          continue;
+        }
+        result += code[i] === '\n' ? '\n' : ' ';
+        i++;
+      }
+      continue;
+    }
+    result += code[i];
+    i++;
+  }
+
+  return result;
+}

package/src/mcp-server.js

@@ -7,7 +7,7 @@
  */
 
 import { TOOLS } from './tool-defs.js';
-import { getSkeleton, getFocusZone, expand, deps, usages, invalidateCache } from './tools.js';
+import { getSkeleton, getFocusZone, expand, deps, usages, invalidateCache, getCallChain } from './tools.js';
 import { getPendingTests, markTestPassed, markTestFailed, getTestSummary, resetTestState } from './test-annotations.js';
 import { getFilters, setFilters, addExcludes, removeExcludes, resetFilters } from './filters.js';
 import { getInstructions } from './instructions.js';
@@ -34,6 +34,7 @@ const TOOL_HANDLERS = {
   expand: (args) => expand(args.symbol),
   deps: (args) => deps(args.symbol),
   usages: (args) => usages(args.symbol),
+  get_call_chain: (args) => getCallChain({ from: args.from, to: args.to, path: args.path ? resolvePath(args.path) : undefined }),
   invalidate_cache: () => { invalidateCache(); return { success: true }; },
 
   // Test Checklist Tools
@@ -115,6 +116,13 @@ const RESPONSE_HINTS = {
     '💡 Use usages() for cross-project reference search.',
   ],
 
+  get_call_chain: (result) => {
+    if (result.error) return [];
+    return [
+      '💡 Use expand() on intermediate steps to understand how data is passed along the chain.',
+    ];
+  },
+
   invalidate_cache: () => [
     '✅ Cache cleared. Run get_skeleton() to rebuild the project graph.',
   ],

package/src/parser.js

@@ -8,6 +8,12 @@ import { join, relative, resolve } from 'path';
 import { parse } from '../vendor/acorn.mjs';
 import * as walk from '../vendor/walk.mjs';
 import { shouldExcludeDir, shouldExcludeFile, parseGitignore } from './filters.js';
+import { parseTypeScript } from './lang-typescript.js';
+import { parsePython } from './lang-python.js';
+import { parseGo } from './lang-go.js';
+
+/** Supported source file extensions */
+const SOURCE_EXTENSIONS = ['.js', '.ts', '.tsx', '.py', '.go'];
 
 /**
  * @typedef {Object} ClassInfo
@@ -239,7 +245,7 @@ export async function parseProject(dir) {
   for (const file of files) {
     const content = readFileSync(file, 'utf-8');
     const relPath = relative(resolvedDir, file);
-    const parsed = await parseFile(content, relPath);
+    const parsed = await parseFileByExtension(content, relPath);
 
     result.files.push(relPath);
     result.classes.push(...parsed.classes);
@@ -255,13 +261,46 @@ export async function parseProject(dir) {
   return result;
 }
 
+/**
+ * Route file to appropriate parser based on extension.
+ * @param {string} code
+ * @param {string} filename
+ * @returns {Promise<ParseResult>}
+ */
+async function parseFileByExtension(code, filename) {
+  if (filename.endsWith('.py')) {
+    return parsePython(code, filename);
+  }
+  if (filename.endsWith('.go')) {
+    return parseGo(code, filename);
+  }
+  if (filename.endsWith('.ts') || filename.endsWith('.tsx')) {
+    return parseTypeScript(code, filename);
+  }
+  // Default: JS via Acorn
+  return parseFile(code, filename);
+}
+
+/**
+ * Check if file is a supported source file.
+ * @param {string} filename
+ * @returns {boolean}
+ */
+function isSourceFile(filename) {
+  // Exclude Symbiote.js presentation files
+  if (filename.endsWith('.css.js') || filename.endsWith('.tpl.js')) {
+    return false;
+  }
+  return SOURCE_EXTENSIONS.some(ext => filename.endsWith(ext));
+}
+
 /**
  * Find all JS files recursively (uses filter configuration)
  * @param {string} dir 
  * @param {string} [rootDir] - Root directory for relative path calculation
  * @returns {string[]}
  */
-function findJSFiles(dir, rootDir = dir) {
+export function findJSFiles(dir, rootDir = dir) {
   // Parse gitignore on first call
   if (dir === rootDir) {
     parseGitignore(rootDir);
@@ -279,7 +318,7 @@ function findJSFiles(dir, rootDir = dir) {
         if (!shouldExcludeDir(entry, relativePath)) {
           files.push(...findJSFiles(fullPath, rootDir));
         }
-      } else if (entry.endsWith('.js') && !entry.endsWith('.css.js') && !entry.endsWith('.tpl.js')) {
+      } else if (isSourceFile(entry)) {
         if (!shouldExcludeFile(entry, relativePath)) {
           files.push(fullPath);
         }

package/src/tool-defs.js

@@ -73,6 +73,19 @@ export const TOOLS = [
       required: ['symbol'],
     },
   },
+  {
+    name: 'get_call_chain',
+    description: 'Find the shortest call chain from one function/class to another through the dependency graph.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        from: { type: 'string', description: 'Starting symbol (e.g., "authMiddleware")' },
+        to: { type: 'string', description: 'Target symbol (e.g., "renderDashboard")' },
+        path: { type: 'string', description: 'Path to scan (optional)' }
+      },
+      required: ['from', 'to'],
+    },
+  },
   {
     name: 'invalidate_cache',
     description: 'Invalidate the cached graph. Use after making code changes.',

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();
 }