callgraph-mcp 1.0.0

package/README.md

@@ -0,0 +1,383 @@
+# callgraph-mcp
+
+**CallGraph MCP Server** — exposes deterministic call-graph analysis for any codebase as [Model Context Protocol](https://modelcontextprotocol.io/) tools. Give your AI agent a precise, structural map of your code — no hallucination, no guessing.
+
+Fully local. No cloud. No LLM. No telemetry.
+
+Powered by [`@codeflow-map/core`](https://www.npmjs.com/package/@codeflow-map/core) and Tree-sitter WASM parsers.
+
+**Supports:** TypeScript · JavaScript · TSX · JSX · Python · Go
+
+---
+
+## Quick Start (VS Code Copilot)
+
+Add this to `.vscode/mcp.json`:
+
+```json
+{
+  "servers": {
+    "flowmap": {
+      "type": "stdio",
+      "command": "npx",
+      "args": ["-y", "callgraph-mcp"]
+    }
+  }
+}
+```
+
+VS Code starts and stops the server automatically.
+
+---
+
+## Setup
+
+### Option 1 — VS Code Copilot via `npx` (no install required)
+
+Add to your project's `.vscode/mcp.json`:
+
+```json
+{
+  "servers": {
+    "flowmap": {
+      "type": "stdio",
+      "command": "npx",
+      "args": ["-y", "callgraph-mcp"],
+      "env": {
+        "FLOWMAP_TRANSPORT": "stdio"
+      }
+    }
+  }
+}
+```
+
+VS Code starts and stops the server automatically. WASM grammars are bundled — no environment variables needed.
+
+> **Tip:** Create `.vscode/mcp.json` via the Command Palette → **MCP: Add Server** → **stdio**.
+
+### Option 2 — Global install
+
+```bash
+npm install -g callgraph-mcp
+```
+
+```json
+{
+  "servers": {
+    "flowmap": {
+      "type": "stdio",
+      "command": "callgraph-mcp",
+      "env": {
+        "FLOWMAP_TRANSPORT": "stdio"
+      }
+    }
+  }
+}
+```
+
+### Option 3 — Claude Desktop
+
+Add to `~/Library/Application Support/Claude/claude_desktop_config.json` (macOS) or `%APPDATA%\Claude\claude_desktop_config.json` (Windows):
+
+```json
+{
+  "mcpServers": {
+    "flowmap": {
+      "command": "npx",
+      "args": ["-y", "callgraph-mcp"],
+      "env": {
+        "FLOWMAP_TRANSPORT": "stdio"
+      }
+    }
+  }
+}
+```
+
+### Option 4 — Cursor
+
+Add to your project's `.cursor/mcp.json`:
+
+```json
+{
+  "mcpServers": {
+    "flowmap": {
+      "command": "npx",
+      "args": ["-y", "callgraph-mcp"],
+      "env": {
+        "FLOWMAP_TRANSPORT": "stdio"
+      }
+    }
+  }
+}
+```
+
+### Option 5 — Cline
+
+Add to your Cline MCP settings (commonly `cline_mcp_settings.json`):
+
+```json
+{
+  "mcpServers": {
+    "flowmap": {
+      "command": "npx",
+      "args": ["-y", "callgraph-mcp"],
+      "env": {
+        "FLOWMAP_TRANSPORT": "stdio"
+      }
+    }
+  }
+}
+```
+
+### Option 6 — HTTP-SSE (shared or remote server)
+
+Use `FLOWMAP_TRANSPORT=http` for HTTP-SSE compatible clients.
+
+Start the server:
+
+```bash
+FLOWMAP_TRANSPORT=http FLOWMAP_PORT=3100 npx callgraph-mcp
+# Windows PowerShell:
+# $env:FLOWMAP_TRANSPORT="http"; $env:FLOWMAP_PORT="3100"; npx callgraph-mcp
+```
+
+Then point your client at it:
+
+```json
+{
+  "servers": {
+    "flowmap": {
+      "type": "http",
+      "url": "http://localhost:3100/mcp"
+    }
+  }
+}
+```
+
+---
+
+## Configure Environment Variables
+
+Use one of the following approaches depending on your client.
+
+### In VS Code `.vscode/mcp.json`
+
+```json
+{
+  "servers": {
+    "flowmap": {
+      "type": "stdio",
+      "command": "npx",
+      "args": ["-y", "callgraph-mcp"],
+      "env": {
+        "FLOWMAP_TRANSPORT": "http",
+        "FLOWMAP_PORT": "3100",
+        "FLOWMAP_GRAMMARS": "/absolute/path/to/grammars"
+      }
+    }
+  }
+}
+```
+
+### In Claude Desktop config
+
+```json
+{
+  "mcpServers": {
+    "flowmap": {
+      "command": "npx",
+      "args": ["-y", "callgraph-mcp"],
+      "env": {
+        "FLOWMAP_TRANSPORT": "stdio",
+        "FLOWMAP_GRAMMARS": "/absolute/path/to/grammars"
+      }
+    }
+  }
+}
+```
+
+### In Cursor `.cursor/mcp.json`
+
+```json
+{
+  "mcpServers": {
+    "flowmap": {
+      "command": "npx",
+      "args": ["-y", "callgraph-mcp"],
+      "env": {
+        "FLOWMAP_TRANSPORT": "stdio",
+        "FLOWMAP_GRAMMARS": "/absolute/path/to/grammars"
+      }
+    }
+  }
+}
+```
+
+### In Cline MCP settings
+
+```json
+{
+  "mcpServers": {
+    "flowmap": {
+      "command": "npx",
+      "args": ["-y", "callgraph-mcp"],
+      "env": {
+        "FLOWMAP_TRANSPORT": "stdio",
+        "FLOWMAP_GRAMMARS": "/absolute/path/to/grammars"
+      }
+    }
+  }
+}
+```
+
+### In your shell for one-off runs
+
+macOS / Linux:
+
+```bash
+FLOWMAP_TRANSPORT=http FLOWMAP_PORT=3100 npx callgraph-mcp
+```
+
+Windows PowerShell:
+
+```powershell
+$env:FLOWMAP_TRANSPORT="http"
+$env:FLOWMAP_PORT="3100"
+npx callgraph-mcp
+```
+
+---
+
+## Tools Reference
+
+| Tool | Required params | Optional | What it returns |
+|------|----------------|----------|-----------------|
+| `flowmap_analyze_workspace` | `workspacePath` | `exclude`, `language` | Full call graph: all nodes, edges, flows, orphans |
+| `flowmap_analyze_file` | `filePath` | — | Functions and call sites in a single file |
+| `flowmap_get_callers` | `functionName`, `workspacePath` | — | Every function across the workspace that directly calls the named function |
+| `flowmap_get_callees` | `functionName`, `workspacePath` | — | Every function the named function directly calls |
+| `flowmap_get_flow` | `functionName`, `workspacePath` | `maxDepth` (default 10) | Full BFS subgraph reachable from a function — the complete execution path |
+| `flowmap_list_entry_points` | `workspacePath` | — | All entry points: mains, route handlers, CLI commands, React roots |
+| `flowmap_find_orphans` | `workspacePath` | — | Functions unreachable from any entry point — potential dead code |
+
+**`workspacePath`** is the absolute path to the repository root (e.g. `/home/user/my-project` or `C:\projects\my-app`).
+
+---
+
+## Environment Variable Reference
+
+| Variable | Default | Description |
+|----------|---------|-------------|
+| `FLOWMAP_TRANSPORT` | `stdio` | Transport mode: `stdio` or `http` (`http` is used for HTTP-SSE clients) |
+| `FLOWMAP_PORT` | `3100` | HTTP server port (only used for `http` transport) |
+| `FLOWMAP_GRAMMARS` | *(bundled)* | Override path to Tree-sitter WASM grammar files |
+
+---
+
+## Example Use Cases
+
+### Explore an unfamiliar codebase
+
+> *"I just cloned this repo. Walk me through where execution starts and what the main flows are."*
+
+The agent calls `flowmap_list_entry_points` to find where code begins, then `flowmap_get_flow` on each entry point to trace the full execution paths. It can describe the architecture without reading every file.
+
+---
+
+### Understand the impact of a change before making it
+
+> *"I need to change the signature of `processPayment`. What will break?"*
+
+The agent calls `flowmap_get_callers("processPayment", workspacePath)` to get every call site across the entire codebase — with file paths and line numbers — so it knows exactly what needs updating before touching anything.
+
+---
+
+### Safe refactoring — find what to clean up
+
+> *"We're doing a big cleanup. What functions are safe to delete?"*
+
+The agent calls `flowmap_find_orphans(workspacePath)`. Functions with zero reachability from entry points and not exported are strong deletion candidates. Combined with `flowmap_get_callers` for verification, this gives a confident dead-code list.
+
+---
+
+### Trace a bug through the call chain
+
+> *"The `submitOrder` function is failing. What does it call, and what does each of those call?"*
+
+The agent calls `flowmap_get_flow("submitOrder", workspacePath, maxDepth: 5)` to get the full downstream call tree — showing exactly which functions are in the execution path and which files they live in.
+
+---
+
+### PR review — understand what changed
+
+> *"This PR modifies `validateUser`. What's the blast radius?"*
+
+The agent calls `flowmap_get_callers("validateUser", workspacePath)` to enumerate every caller, then `flowmap_get_flow("validateUser", workspacePath)` to show all downstream dependency. It can summarise the risk surface of the change deterministically.
+
+---
+
+### Understand a single file before editing it
+
+> *"What does `src/auth/middleware.ts` export and what does it call?"*
+
+The agent calls `flowmap_analyze_file("/abs/path/to/src/auth/middleware.ts")` to get a precise list of every function, its parameters, return type, and all outgoing calls — without needing to read the file itself.
+
+---
+
+### Agentic code generation with structural guardrails
+
+When an agent is generating new code, it can call `flowmap_analyze_workspace` before and after to verify:
+- New functions are connected to the call graph (not accidentally orphaned)
+- No existing entry points were broken
+- The intended call relationships were actually created
+
+---
+
+## Example Prompts for VS Code Copilot
+
+```
+List all entry points in this workspace
+```
+```
+What functions call `buildCallGraph` anywhere in the codebase?
+```
+```
+Show me the full execution path starting from `startServer`, up to 6 levels deep
+```
+```
+Find all dead code — functions that are never reached from any entry point
+```
+```
+What does `parseFile` directly depend on?
+```
+```
+I'm changing `connectDb`. Who calls it? Give me file paths and line numbers.
+```
+```
+Analyze just src/api/routes.ts and tell me what it exports and what it calls
+```
+
+---
+
+## How It Works
+
+1. Tree-sitter WASM grammars parse each source file into an AST — no runtime execution, no imports
+2. Functions and call sites are extracted from the AST
+3. A call graph is built by resolving call site names to function definitions (by name, suffix, and file)
+4. Entry points are detected: functions that are never called but call others
+5. The graph is partitioned into independent execution flows via BFS from each entry point
+
+Files are parsed in parallel batches of 50. Results are cached for 30 seconds — repeated calls within a session are instant.
+
+---
+
+## Links
+
+- [VS Code Extension (CallSight)](https://marketplace.visualstudio.com/items?itemName=devricky-codes.callsight)
+- [Core Package (@codeflow-map/core)](https://www.npmjs.com/package/@codeflow-map/core)
+- [Source Code](https://github.com/devricky-codes/callgraph-mcp)
+- [Report Issues](https://github.com/devricky-codes/callgraph-mcp)
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+#!/usr/bin/env node
+"use strict";var fe=Object.create;var C=Object.defineProperty;var me=Object.getOwnPropertyDescriptor;var ge=Object.getOwnPropertyNames;var ue=Object.getPrototypeOf,ye=Object.prototype.hasOwnProperty;var he=(t,r,e,o)=>{if(r&&typeof r=="object"||typeof r=="function")for(let n of ge(r))!ye.call(t,n)&&n!==e&&C(t,n,{get:()=>r[n],enumerable:!(o=me(r,n))||o.enumerable});return t};var y=(t,r,e)=>(e=t!=null?fe(ue(t)):{},he(r||!t||!t.__esModule?C(e,"default",{value:t,enumerable:!0}):e,t));var se=require("http"),ie=require("@modelcontextprotocol/sdk/server/mcp.js"),ae=require("@modelcontextprotocol/sdk/server/stdio.js"),ce=require("@modelcontextprotocol/sdk/server/streamableHttp.js"),le=require("crypto");var b=require("zod"),W=y(require("fs"));var G=y(require("path")),h=require("@codeflow-map/core");var A=new Map,xe=3e4;function L(t){let r=A.get(t);return r?Date.now()-r.cachedAt>xe?(A.delete(t),null):r.graph:null}function P(t,r){A.set(t,{graph:r,cachedAt:Date.now(),workspacePath:t})}var E=y(require("path")),U=y(require("fast-glob")),N=require("@codeflow-map/core"),Se=["**/node_modules/**","**/venv/**","**/.venv/**","**/__pycache__/**","**/vendor/**","**/target/**","**/.git/**","**/dist/**","**/build/**","**/.next/**","**/.turbo/**","**/coverage/**","**/.gradle/**","**/.cache/**","**/site-packages/**","**/.mypy_cache/**","**/.pytest_cache/**","**/out/**","**/bin/**","**/obj/**","**/tests/**","**/__tests__/**","**/spec/**","**/__specs__/**","**/test/**"];async function z(t,r={}){let{exclude:e=[],language:o}=r,n;if(o){let c=Object.entries(N.FILE_EXTENSION_MAP).filter(([,d])=>d===o).map(([d])=>d.replace(".",""));n=c.length>0?c:[]}else n=Object.keys(N.FILE_EXTENSION_MAP).map(c=>c.replace(".",""));if(n.length===0)return[];let s=n.length===1?`**/*.${n[0]}`:`**/*.{${n.join(",")}}`,a=[...Se,...e],l=t.replace(/\\/g,"/"),p=await(0,U.default)(s,{cwd:l,ignore:a,absolute:!1,dot:!1,onlyFiles:!0}),i=[];for(let c of p){let d=E.extname(c),x=N.FILE_EXTENSION_MAP[d];x&&i.push({filePath:c.replace(/\\/g,"/"),absPath:E.resolve(t,c),languageId:x})}return i}var I=50,J=!1;function R(){return process.env.FLOWMAP_GRAMMARS?process.env.FLOWMAP_GRAMMARS:G.resolve(__dirname,"..","..","grammars")}async function ve(){J||(await(0,h.initTreeSitter)(R()),J=!0)}async function g(t,r={}){let e=L(t);if(e)return e;await ve();let o=R(),n=Date.now(),s=await z(t,r),a=[],l=[],p=0;for(let S=0;S<s.length;S+=I){let u=s.slice(S,S+I),v=await Promise.all(u.map(m=>(0,h.parseFile)(m.filePath,m.absPath,o,m.languageId).catch(()=>null)));for(let m of v)m&&(a.push(...m.functions),l.push(...m.calls),p++)}let i=(0,h.buildCallGraph)(a,l);(0,h.detectEntryPoints)(a,i);let{flows:c,orphans:d}=(0,h.partitionFlows)(a,i),x={nodes:a,edges:i,flows:c,orphans:d,scannedFiles:p,durationMs:Date.now()-n};return P(t,x),x}function f(t,r,e,o,n){t.tool(r,e,o,n)}var _e=["typescript","javascript","python","java","go","rust","tsx","jsx"],Oe=["node_modules","dist",".git","__pycache__","*.test.*","*.spec.*"];function $(t){f(t,"flowmap_analyze_workspace","Scan an entire codebase and return a full call graph \u2014 all functions, their parameters, and all call relationships between them. Use this first when exploring an unfamiliar codebase.",{workspacePath:b.z.string().describe("Absolute path to the repository root"),exclude:b.z.string().optional().describe("Comma-separated glob patterns to exclude. Defaults: node_modules,dist,.git,__pycache__,*.test.*,*.spec.*"),language:b.z.string().optional().describe("Filter to a single language: typescript, javascript, python, java, go, rust, tsx, jsx. Omit to scan all.")},async({workspacePath:r,exclude:e,language:o})=>{try{if(!W.existsSync(r))return{content:[{type:"text",text:JSON.stringify({error:!0,code:"WORKSPACE_NOT_FOUND",message:`Directory does not exist: ${r}`,workspacePath:r})}]};let n=e?e.split(",").map(l=>l.trim()).filter(Boolean):Oe,s=o&&_e.includes(o)?o:void 0,a=await g(r,{exclude:n,language:s});return{content:[{type:"text",text:JSON.stringify(a)}]}}catch(n){let s=n instanceof Error?n.message:String(n);return{content:[{type:"text",text:JSON.stringify({error:!0,code:"PARSE_ERROR",message:s,workspacePath:r})}]}}})}var K=require("zod"),H=y(require("fs")),T=y(require("path")),_=require("@codeflow-map/core");var j=!1;function X(t){f(t,"flowmap_analyze_file","Scan a single file and return all functions defined in it, their parameters, and calls made within the file.",{filePath:K.z.string().describe("Absolute path to the file to analyse")},async({filePath:r})=>{try{if(!H.existsSync(r))return{content:[{type:"text",text:JSON.stringify({error:!0,code:"FILE_NOT_FOUND",message:`File does not exist: ${r}`})}]};let e=T.extname(r),o=_.FILE_EXTENSION_MAP[e];if(!o)return{content:[{type:"text",text:JSON.stringify({error:!0,code:"UNSUPPORTED_LANGUAGE",message:`Unsupported file extension: ${e}`})}]};let n=R();j||(await(0,_.initTreeSitter)(n),j=!0);let s=Date.now(),a=T.basename(r),l=await(0,_.parseFile)(a,r,n,o);return{content:[{type:"text",text:JSON.stringify({filePath:a,functions:l.functions,calls:l.calls,durationMs:Date.now()-s})}]}}catch(e){let o=e instanceof Error?e.message:String(e);return{content:[{type:"text",text:JSON.stringify({error:!0,code:"PARSE_ERROR",message:o})}]}}})}var D=require("zod"),k=y(require("fs"));function B(t){f(t,"flowmap_get_callers","Return all functions that directly call the named function. Use this for impact analysis \u2014 to understand what breaks if you change a function's signature.",{functionName:D.z.string().describe("The function name to find callers of"),workspacePath:D.z.string().describe("Absolute path to the repository root")},async({functionName:r,workspacePath:e})=>{try{if(!k.existsSync(e))return{content:[{type:"text",text:JSON.stringify({error:!0,code:"WORKSPACE_NOT_FOUND",message:`Directory does not exist: ${e}`,workspacePath:e})}]};let o=await g(e),n=o.nodes.filter(i=>i.name===r);if(n.length===0)return{content:[{type:"text",text:JSON.stringify({error:!0,code:"FUNCTION_NOT_FOUND",message:`No function named "${r}" found in the codebase.`,workspacePath:e})}]};let s=n[0],a=new Set(n.map(i=>i.id)),p=o.edges.filter(i=>a.has(i.to)).map(i=>{let c=o.nodes.find(d=>d.id===i.from);return{id:i.from,name:c?.name??"unknown",filePath:c?.filePath??"unknown",startLine:c?.startLine??0,callLine:i.line}});return{content:[{type:"text",text:JSON.stringify({target:r,targetId:s.id,callers:p,count:p.length})}]}}catch(o){let n=o instanceof Error?o.message:String(o);return{content:[{type:"text",text:JSON.stringify({error:!0,code:"PARSE_ERROR",message:n,workspacePath:e})}]}}})}var M=require("zod"),Z=y(require("fs"));function V(t){f(t,"flowmap_get_callees","Return all functions directly called by the named function. Use this to understand what a function depends on.",{functionName:M.z.string().describe("The function name to find callees of"),workspacePath:M.z.string().describe("Absolute path to the repository root")},async({functionName:r,workspacePath:e})=>{try{if(!Z.existsSync(e))return{content:[{type:"text",text:JSON.stringify({error:!0,code:"WORKSPACE_NOT_FOUND",message:`Directory does not exist: ${e}`,workspacePath:e})}]};let o=await g(e),n=o.nodes.filter(i=>i.name===r);if(n.length===0)return{content:[{type:"text",text:JSON.stringify({error:!0,code:"FUNCTION_NOT_FOUND",message:`No function named "${r}" found in the codebase.`,workspacePath:e})}]};let s=n[0],a=new Set(n.map(i=>i.id)),p=o.edges.filter(i=>a.has(i.from)).map(i=>{let c=o.nodes.find(d=>d.id===i.to);return{id:i.to,name:c?.name??"unknown",filePath:c?.filePath??"unknown",startLine:c?.startLine??0,callLine:i.line}});return{content:[{type:"text",text:JSON.stringify({target:r,targetId:s.id,callees:p,count:p.length})}]}}catch(o){let n=o instanceof Error?o.message:String(o);return{content:[{type:"text",text:JSON.stringify({error:!0,code:"PARSE_ERROR",message:n,workspacePath:e})}]}}})}var w=require("zod"),Y=y(require("fs"));function q(t){f(t,"flowmap_get_flow","Return the complete sub-graph reachable from a given function \u2014 every function it calls, every function those call, and so on recursively. Use this to understand the full execution path of a feature or entry point.",{functionName:w.z.string().describe("The starting function name"),workspacePath:w.z.string().describe("Absolute path to the repository root"),maxDepth:w.z.number().optional().describe("Maximum recursion depth. Default 10.")},async({functionName:r,workspacePath:e,maxDepth:o})=>{let n=o??10;try{if(!Y.existsSync(e))return{content:[{type:"text",text:JSON.stringify({error:!0,code:"WORKSPACE_NOT_FOUND",message:`Directory does not exist: ${e}`,workspacePath:e})}]};let s=await g(e),a=s.nodes.filter(u=>u.name===r);if(a.length===0)return{content:[{type:"text",text:JSON.stringify({error:!0,code:"FUNCTION_NOT_FOUND",message:`No function named "${r}" found in the codebase.`,workspacePath:e})}]};let l=a[0],p=new Map;for(let u of s.edges){let v=p.get(u.from)||[],m=s.nodes.find(F=>F.id===u.to);m&&(v.push({edge:u,node:m}),p.set(u.from,v))}let i=new Set,c=[],d=[],x=0,S=[l.id];for(i.add(l.id),c.push(l);S.length>0&&x<n;){let u=[];for(let v of S){let m=p.get(v)||[];for(let{edge:F,node:O}of m)d.push(F),i.has(O.id)||(i.add(O.id),c.push(O),u.push(O.id))}S=u,x++}return{content:[{type:"text",text:JSON.stringify({entryFunction:r,nodes:c,edges:d,depth:x,totalFunctions:c.length})}]}}catch(s){let a=s instanceof Error?s.message:String(s);return{content:[{type:"text",text:JSON.stringify({error:!0,code:"PARSE_ERROR",message:a,workspacePath:e})}]}}})}var Q=require("zod"),ee=y(require("fs"));function te(t){f(t,"flowmap_list_entry_points","Return all detected entry points in the codebase \u2014 main functions, HTTP route handlers, React root renders, CLI commands, etc. Always call this first when exploring a new codebase to understand where execution begins.",{workspacePath:Q.z.string().describe("Absolute path to the repository root")},async({workspacePath:r})=>{try{if(!ee.existsSync(r))return{content:[{type:"text",text:JSON.stringify({error:!0,code:"WORKSPACE_NOT_FOUND",message:`Directory does not exist: ${r}`,workspacePath:r})}]};let e=await g(r),n=e.nodes.filter(s=>s.isEntryPoint).map(s=>({id:s.id,name:s.name,filePath:s.filePath,startLine:s.startLine,language:s.language,isExported:s.isExported,isAsync:s.isAsync}));return{content:[{type:"text",text:JSON.stringify({entryPoints:n,count:n.length,durationMs:e.durationMs})}]}}catch(e){let o=e instanceof Error?e.message:String(e);return{content:[{type:"text",text:JSON.stringify({error:!0,code:"PARSE_ERROR",message:o,workspacePath:r})}]}}})}var re=require("zod"),ne=y(require("fs"));function oe(t){f(t,"flowmap_find_orphans","Return all functions that are never called from any entry point \u2014 potential dead code. Use this during refactoring to identify code that can safely be removed.",{workspacePath:re.z.string().describe("Absolute path to the repository root")},async({workspacePath:r})=>{try{if(!ne.existsSync(r))return{content:[{type:"text",text:JSON.stringify({error:!0,code:"WORKSPACE_NOT_FOUND",message:`Directory does not exist: ${r}`,workspacePath:r})}]};let e=await g(r),o=e.orphans.map(n=>{let s=e.nodes.find(a=>a.id===n);return s?{id:s.id,name:s.name,filePath:s.filePath,startLine:s.startLine,language:s.language,isExported:s.isExported}:{id:n,name:"unknown",filePath:"unknown",startLine:0}});return{content:[{type:"text",text:JSON.stringify({orphans:o,count:o.length,durationMs:e.durationMs,note:"Exported functions may be used by external consumers \u2014 verify before deleting."})}]}}catch(e){let o=e instanceof Error?e.message:String(e);return{content:[{type:"text",text:JSON.stringify({error:!0,code:"PARSE_ERROR",message:o,workspacePath:r})}]}}})}function pe(){let t=new ie.McpServer({name:"callgraph-mcp",version:"1.0.0"});return Ne(t),t}function Ne(t){$(t),X(t),B(t),V(t),q(t),te(t),oe(t)}async function de(){let t=(process.env.FLOWMAP_TRANSPORT||"stdio").toLowerCase();t==="http"||t==="sse"?await Re():await Ee()}async function Ee(){let t=pe(),r=new ae.StdioServerTransport;await t.connect(r)}async function Re(){let t=parseInt(process.env.FLOWMAP_PORT||"3100",10),r=pe(),e=new ce.StreamableHTTPServerTransport({sessionIdGenerator:()=>(0,le.randomUUID)()}),o=(0,se.createServer)(async(n,s)=>{let a=n.url||"/";a==="/mcp"||a==="/"?await e.handleRequest(n,s):s.writeHead(404).end("Not Found")});await r.connect(e),o.listen(t,()=>{process.stderr.write(`FlowMap MCP server listening on http://localhost:${t}/mcp
+`)})}de().catch(t=>{process.stderr.write(`FlowMap MCP server failed to start: ${t}
+`),process.exit(1)});

package/dist/server.d.ts

@@ -0,0 +1,3 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare function createMcpServer(): McpServer;
+export declare function startServer(): Promise<void>;

package/dist/tools/analyzeFile.d.ts

@@ -0,0 +1,2 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare function registerAnalyzeFile(server: McpServer): void;

package/dist/tools/analyzeWorkspace.d.ts

@@ -0,0 +1,2 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare function registerAnalyzeWorkspace(server: McpServer): void;

package/dist/tools/findOrphans.d.ts

@@ -0,0 +1,2 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare function registerFindOrphans(server: McpServer): void;

package/dist/tools/getCallees.d.ts

@@ -0,0 +1,2 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare function registerGetCallees(server: McpServer): void;

package/dist/tools/getCallers.d.ts

@@ -0,0 +1,2 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare function registerGetCallers(server: McpServer): void;

package/dist/tools/getFlow.d.ts

@@ -0,0 +1,2 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare function registerGetFlow(server: McpServer): void;

package/dist/tools/listEntryPoints.d.ts

@@ -0,0 +1,2 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare function registerListEntryPoints(server: McpServer): void;

package/dist/utils/analysis.d.ts

@@ -0,0 +1,6 @@
+import { Graph } from '@codeflow-map/core';
+import { DiscoveryOptions } from './fileDiscovery';
+export declare function resolveWasmDir(): string;
+export interface AnalyzeOptions extends DiscoveryOptions {
+}
+export declare function analyzeWorkspace(workspacePath: string, options?: AnalyzeOptions): Promise<Graph>;

package/dist/utils/cache.d.ts

@@ -0,0 +1,4 @@
+import { Graph } from '@codeflow-map/core';
+export declare function getCached(workspacePath: string): Graph | null;
+export declare function setCached(workspacePath: string, graph: Graph): void;
+export declare function clearCache(workspacePath?: string): void;

package/dist/utils/fileDiscovery.d.ts

@@ -0,0 +1,14 @@
+import { SupportedLanguage } from '@codeflow-map/core';
+export interface DiscoveredFile {
+    /** Relative path (forward slashes) from workspace root */
+    filePath: string;
+    /** Absolute path on disk */
+    absPath: string;
+    /** Language identified from file extension */
+    languageId: SupportedLanguage;
+}
+export interface DiscoveryOptions {
+    exclude?: string[];
+    language?: SupportedLanguage;
+}
+export declare function discoverFiles(workspacePath: string, options?: DiscoveryOptions): Promise<DiscoveredFile[]>;

package/dist/utils/formatGraph.d.ts

@@ -0,0 +1,5 @@
+import { Graph } from '@codeflow-map/core';
+/**
+ * Produce an LLM-friendly text summary of a Graph for use alongside JSON responses.
+ */
+export declare function formatGraphSummary(graph: Graph): string;

package/dist/utils/toolHelper.d.ts

@@ -0,0 +1,11 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { z } from 'zod';
+import type { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
+/**
+ * Registers a tool on the McpServer with explicit type handling to avoid
+ * TS2589 "Type instantiation is excessively deep" errors that occur with
+ * the MCP SDK 1.27.x + Zod 3.25.x combination.
+ */
+export declare function registerTool<T extends Record<string, z.ZodTypeAny>>(server: McpServer, name: string, description: string, schema: T, handler: (args: {
+    [K in keyof T]: z.infer<T[K]>;
+}) => Promise<CallToolResult>): void;

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "callgraph-mcp",
+  "version": "1.0.0",
+  "description": "MCP server for codebase call-flow analysis. Local, deterministic, language-agnostic. Powered by @codeflow-map/core.",
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "call-graph",
+    "static-analysis",
+    "code-analysis",
+    "flowmap"
+  ],
+  "license": "MIT",
+  "author": "devricky-codes",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/devricky-codes/callgraph-mcp.git",
+    "directory": "packages/mcp-server"
+  },
+  "homepage": "https://github.com/devricky-codes/callgraph-mcp#readme",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "bin": {
+    "callgraph-mcp": "./dist/index.js"
+  },
+  "files": [
+    "dist/",
+    "grammars/",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "scripts": {
+    "clean": "node -e \"require('fs').rmSync('dist',{recursive:true,force:true})\"",
+    "build:types": "tsc --emitDeclarationOnly",
+    "build:bundle": "esbuild src/index.ts --bundle --platform=node --format=cjs --target=node18 --minify --outfile=dist/index.js --banner:js=\"#!/usr/bin/env node\" --external:@codeflow-map/core --external:@modelcontextprotocol/sdk --external:fast-glob --external:zod",
+    "build": "pnpm run clean && pnpm run build:types && pnpm run build:bundle && node scripts/copy-grammars.cjs",
+    "start": "node dist/index.js",
+    "dev": "tsx src/index.ts"
+  },
+  "dependencies": {
+    "@codeflow-map/core": "^0.2.5",
+    "@modelcontextprotocol/sdk": "^1.27.0",
+    "fast-glob": "^3.3.0",
+    "zod": "^3.25.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.10.6",
+    "esbuild": "^0.27.4",
+    "typescript": "^5.3.3",
+    "tsx": "^4.0.0"
+  }
+}