typegraph-mcp 0.9.41 → 0.9.43

package/dist/benchmark.js

@@ -201,6 +201,21 @@ var TsServerClient = class {
     this.sendNotification("open", { file: absPath });
     await new Promise((r) => setTimeout(r, 50));
   }
+  async reloadOpenFile(file) {
+    const absPath = this.resolvePath(file);
+    if (!this.openFiles.has(absPath)) return false;
+    await this.sendRequest("reload", {
+      file: absPath,
+      tmpfile: absPath
+    });
+    return true;
+  }
+  closeFile(file) {
+    const absPath = this.resolvePath(file);
+    if (!this.openFiles.delete(absPath)) return false;
+    this.sendNotification("close", { file: absPath });
+    return true;
+  }
   // ─── Public API ────────────────────────────────────────────────────────
   async definition(file, line, offset) {
     const absPath = this.resolvePath(file);

package/dist/check.js

@@ -301,7 +301,7 @@ function removeFile(graph, filePath) {
   graph.reverse.delete(filePath);
   graph.files.delete(filePath);
 }
-function startWatcher(projectRoot, graph, resolver) {
+function startWatcher(projectRoot, graph, resolver, hooks) {
   try {
     const watcher = fs.watch(
       projectRoot,
@@ -318,8 +318,10 @@ function startWatcher(projectRoot, graph, resolver) {
         const absPath = path2.resolve(projectRoot, filename);
         if (fs.existsSync(absPath)) {
           updateFile(graph, absPath, resolver, projectRoot);
+          void hooks?.onFileUpdated?.(absPath);
         } else {
           removeFile(graph, absPath);
+          void hooks?.onFileDeleted?.(absPath);
         }
       }
     );

package/dist/cli.js

@@ -317,7 +317,7 @@ function removeFile(graph, filePath) {
   graph.reverse.delete(filePath);
   graph.files.delete(filePath);
 }
-function startWatcher(projectRoot3, graph, resolver) {
+function startWatcher(projectRoot3, graph, resolver, hooks) {
   try {
     const watcher = fs.watch(
       projectRoot3,
@@ -334,8 +334,10 @@ function startWatcher(projectRoot3, graph, resolver) {
         const absPath2 = path2.resolve(projectRoot3, filename);
         if (fs.existsSync(absPath2)) {
           updateFile(graph, absPath2, resolver, projectRoot3);
+          void hooks?.onFileUpdated?.(absPath2);
         } else {
           removeFile(graph, absPath2);
+          void hooks?.onFileDeleted?.(absPath2);
         }
       }
     );
@@ -1087,6 +1089,21 @@ var init_tsserver_client = __esm({
         this.sendNotification("open", { file: absPath2 });
         await new Promise((r) => setTimeout(r, 50));
       }
+      async reloadOpenFile(file) {
+        const absPath2 = this.resolvePath(file);
+        if (!this.openFiles.has(absPath2)) return false;
+        await this.sendRequest("reload", {
+          file: absPath2,
+          tmpfile: absPath2
+        });
+        return true;
+      }
+      closeFile(file) {
+        const absPath2 = this.resolvePath(file);
+        if (!this.openFiles.delete(absPath2)) return false;
+        this.sendNotification("close", { file: absPath2 });
+        return true;
+      }
       // ─── Public API ────────────────────────────────────────────────────────
       async definition(file, line, offset) {
         const absPath2 = this.resolvePath(file);
@@ -2638,7 +2655,14 @@ async function main4() {
   ]);
   moduleGraph = graphResult.graph;
   moduleResolver = graphResult.resolver;
-  startWatcher(projectRoot2, moduleGraph, graphResult.resolver);
+  startWatcher(projectRoot2, moduleGraph, graphResult.resolver, {
+    onFileUpdated: (filePath) => client.reloadOpenFile(filePath).catch((err) => {
+      log3(`Failed to reload open file ${relPath2(filePath)}:`, err);
+    }),
+    onFileDeleted: (filePath) => {
+      client.closeFile(filePath);
+    }
+  });
   const transport = new StdioServerTransport();
   await mcpServer.connect(transport);
   log3("MCP server connected and ready");

package/dist/module-graph.js

@@ -297,7 +297,7 @@ function removeFile(graph, filePath) {
   graph.reverse.delete(filePath);
   graph.files.delete(filePath);
 }
-function startWatcher(projectRoot, graph, resolver) {
+function startWatcher(projectRoot, graph, resolver, hooks) {
   try {
     const watcher = fs.watch(
       projectRoot,
@@ -314,8 +314,10 @@ function startWatcher(projectRoot, graph, resolver) {
         const absPath = path.resolve(projectRoot, filename);
         if (fs.existsSync(absPath)) {
           updateFile(graph, absPath, resolver, projectRoot);
+          void hooks?.onFileUpdated?.(absPath);
         } else {
           removeFile(graph, absPath);
+          void hooks?.onFileDeleted?.(absPath);
         }
       }
     );

package/dist/server.js

@@ -202,6 +202,21 @@ var TsServerClient = class {
     this.sendNotification("open", { file: absPath2 });
     await new Promise((r) => setTimeout(r, 50));
   }
+  async reloadOpenFile(file) {
+    const absPath2 = this.resolvePath(file);
+    if (!this.openFiles.has(absPath2)) return false;
+    await this.sendRequest("reload", {
+      file: absPath2,
+      tmpfile: absPath2
+    });
+    return true;
+  }
+  closeFile(file) {
+    const absPath2 = this.resolvePath(file);
+    if (!this.openFiles.delete(absPath2)) return false;
+    this.sendNotification("close", { file: absPath2 });
+    return true;
+  }
   // ─── Public API ────────────────────────────────────────────────────────
   async definition(file, line, offset) {
     const absPath2 = this.resolvePath(file);
@@ -568,7 +583,7 @@ function removeFile(graph, filePath) {
   graph.reverse.delete(filePath);
   graph.files.delete(filePath);
 }
-function startWatcher(projectRoot2, graph, resolver) {
+function startWatcher(projectRoot2, graph, resolver, hooks) {
   try {
     const watcher = fs2.watch(
       projectRoot2,
@@ -585,8 +600,10 @@ function startWatcher(projectRoot2, graph, resolver) {
         const absPath2 = path2.resolve(projectRoot2, filename);
         if (fs2.existsSync(absPath2)) {
           updateFile(graph, absPath2, resolver, projectRoot2);
+          void hooks?.onFileUpdated?.(absPath2);
         } else {
           removeFile(graph, absPath2);
+          void hooks?.onFileDeleted?.(absPath2);
         }
       }
     );
@@ -1677,7 +1694,14 @@ async function main() {
   ]);
   moduleGraph = graphResult.graph;
   moduleResolver = graphResult.resolver;
-  startWatcher(projectRoot, moduleGraph, graphResult.resolver);
+  startWatcher(projectRoot, moduleGraph, graphResult.resolver, {
+    onFileUpdated: (filePath) => client.reloadOpenFile(filePath).catch((err) => {
+      log3(`Failed to reload open file ${relPath(filePath)}:`, err);
+    }),
+    onFileDeleted: (filePath) => {
+      client.closeFile(filePath);
+    }
+  });
   const transport = new StdioServerTransport();
   await mcpServer.connect(transport);
   log3("MCP server connected and ready");

package/dist/smoke-test.js

@@ -200,6 +200,21 @@ var TsServerClient = class {
     this.sendNotification("open", { file: absPath });
     await new Promise((r) => setTimeout(r, 50));
   }
+  async reloadOpenFile(file) {
+    const absPath = this.resolvePath(file);
+    if (!this.openFiles.has(absPath)) return false;
+    await this.sendRequest("reload", {
+      file: absPath,
+      tmpfile: absPath
+    });
+    return true;
+  }
+  closeFile(file) {
+    const absPath = this.resolvePath(file);
+    if (!this.openFiles.delete(absPath)) return false;
+    this.sendNotification("close", { file: absPath });
+    return true;
+  }
   // ─── Public API ────────────────────────────────────────────────────────
   async definition(file, line, offset) {
     const absPath = this.resolvePath(file);

package/dist/tsserver-client.js

@@ -195,6 +195,21 @@ var TsServerClient = class {
     this.sendNotification("open", { file: absPath });
     await new Promise((r) => setTimeout(r, 50));
   }
+  async reloadOpenFile(file) {
+    const absPath = this.resolvePath(file);
+    if (!this.openFiles.has(absPath)) return false;
+    await this.sendRequest("reload", {
+      file: absPath,
+      tmpfile: absPath
+    });
+    return true;
+  }
+  closeFile(file) {
+    const absPath = this.resolvePath(file);
+    if (!this.openFiles.delete(absPath)) return false;
+    this.sendNotification("close", { file: absPath });
+    return true;
+  }
   // ─── Public API ────────────────────────────────────────────────────────
   async definition(file, line, offset) {
     const absPath = this.resolvePath(file);

package/engine-sync-test.ts

@@ -0,0 +1,236 @@
+#!/usr/bin/env npx tsx
+
+import * as assert from "node:assert/strict";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { CallToolResultSchema } from "@modelcontextprotocol/sdk/types.js";
+
+type DependencyTreeResult = {
+  root: string;
+  nodes: number;
+  files: string[];
+};
+
+type TypeInfoResult = {
+  type: string | null;
+  documentation: string | null;
+  kind?: string;
+  source?: string;
+};
+
+type ModuleExportsResult = {
+  file: string;
+  exports: Array<{
+    symbol: string;
+    type: string | null;
+  }>;
+  count: number;
+};
+
+function normalize(file: string): string {
+  return file.replaceAll("\\", "/");
+}
+
+function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+async function waitFor(
+  description: string,
+  fn: () => Promise<void>,
+  timeoutMs = 5_000,
+  intervalMs = 50
+): Promise<void> {
+  const start = Date.now();
+  let lastError: unknown;
+
+  while (Date.now() - start < timeoutMs) {
+    try {
+      await fn();
+      return;
+    } catch (err) {
+      lastError = err;
+      await sleep(intervalMs);
+    }
+  }
+
+  throw new Error(
+    `${description} did not stabilize within ${timeoutMs}ms: ${String(lastError)}`
+  );
+}
+
+function writeFile(root: string, relativePath: string, content: string): void {
+  const absPath = path.join(root, relativePath);
+  fs.mkdirSync(path.dirname(absPath), { recursive: true });
+  fs.writeFileSync(absPath, content);
+}
+
+async function main(): Promise<void> {
+  const repoRoot = import.meta.dirname;
+  const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), "typegraph-engine-sync-"));
+  const projectRoot = path.join(tempRoot, "project");
+
+  fs.mkdirSync(projectRoot, { recursive: true });
+  writeFile(
+    projectRoot,
+    "package.json",
+    JSON.stringify(
+      {
+        name: "typegraph-engine-sync-fixture",
+        private: true,
+        type: "module",
+      },
+      null,
+      2
+    ) + "\n"
+  );
+  writeFile(
+    projectRoot,
+    "tsconfig.json",
+    JSON.stringify(
+      {
+        compilerOptions: {
+          target: "ES2022",
+          module: "ESNext",
+          moduleResolution: "Bundler",
+          strict: true,
+        },
+        include: ["src/**/*.ts"],
+      },
+      null,
+      2
+    ) + "\n"
+  );
+
+  writeFile(projectRoot, "src/a.ts", 'export const current = "a" as const;\n');
+  writeFile(projectRoot, "src/b.ts", 'export const current = "b" as const;\n');
+  writeFile(
+    projectRoot,
+    "src/main.ts",
+    'import { current } from "./a";\nexport const value = current;\n'
+  );
+  writeFile(projectRoot, "src/test.ts", "export const oldName = 1 as const;\n");
+  writeFile(projectRoot, "src/util.ts", "export const helper = 1 as const;\n");
+
+  fs.mkdirSync(path.join(projectRoot, "node_modules"), { recursive: true });
+  fs.symlinkSync(
+    path.join(repoRoot, "node_modules/typescript"),
+    path.join(projectRoot, "node_modules/typescript"),
+    "dir"
+  );
+
+  const client = new Client({ name: "engine-sync-test", version: "1.0.0" });
+  const transport = new StdioClientTransport({
+    command: path.join(repoRoot, "node_modules/.bin/tsx"),
+    args: [path.join(repoRoot, "server.ts")],
+    cwd: projectRoot,
+    env: {
+      TYPEGRAPH_PROJECT_ROOT: projectRoot,
+      TYPEGRAPH_TSCONFIG: path.join(projectRoot, "tsconfig.json"),
+    },
+  });
+
+  async function callTool<T>(name: string, args: Record<string, unknown>): Promise<T> {
+    const result = await client.request(
+      {
+        method: "tools/call",
+        params: {
+          name,
+          arguments: args,
+        },
+      },
+      CallToolResultSchema
+    );
+
+    const content = result.content[0];
+    assert.ok(content?.type === "text", `Expected text response from ${name}`);
+    return JSON.parse(content.text) as T;
+  }
+
+  try {
+    await client.connect(transport);
+
+    const initialType = await callTool<TypeInfoResult>("ts_type_info", {
+      file: "src/main.ts",
+      line: 2,
+      column: 14,
+    });
+    assert.match(initialType.type ?? "", /"a"/);
+
+    writeFile(projectRoot, "src/main.ts", 'import { current } from "./b";\nexport const value = current;\n');
+
+    await waitFor("import swap to synchronize graph and tsserver", async () => {
+      const deps = await callTool<DependencyTreeResult>("ts_dependency_tree", {
+        file: "src/main.ts",
+      });
+      const normalizedDeps = deps.files.map(normalize);
+      assert.ok(normalizedDeps.includes("src/b.ts"), `Expected src/b.ts in ${normalizedDeps}`);
+      assert.ok(!normalizedDeps.includes("src/a.ts"), `Expected src/a.ts to be removed from ${normalizedDeps}`);
+
+      const typeInfo = await callTool<TypeInfoResult>("ts_type_info", {
+        file: "src/main.ts",
+        line: 2,
+        column: 14,
+      });
+      assert.match(typeInfo.type ?? "", /"b"/);
+    });
+
+    // Open test.ts through ts_module_exports, then rename the export on disk.
+    const initialExports = await callTool<ModuleExportsResult>("ts_module_exports", {
+      file: "src/test.ts",
+    });
+    assert.ok(initialExports.exports.some((item) => item.symbol === "oldName"));
+
+    writeFile(projectRoot, "src/test.ts", "export const newName = 1 as const;\n");
+
+    await waitFor("symbol rename to refresh mixed export metadata", async () => {
+      const exportsResult = await callTool<ModuleExportsResult>("ts_module_exports", {
+        file: "src/test.ts",
+      });
+      const next = exportsResult.exports.find((item) => item.symbol === "newName");
+      assert.ok(next, `Expected newName in ${JSON.stringify(exportsResult.exports)}`);
+      assert.match(next.type ?? "", /\bnewName\b/);
+      assert.ok(!exportsResult.exports.some((item) => item.symbol === "oldName"));
+    });
+
+    // Open util.ts directly so tsserver tracks it, then delete it from disk.
+    const utilInfo = await callTool<TypeInfoResult>("ts_type_info", {
+      file: "src/util.ts",
+      line: 1,
+      column: 14,
+    });
+    assert.match(utilInfo.type ?? "", /\bhelper: 1\b/);
+    fs.rmSync(path.join(projectRoot, "src/util.ts"));
+
+    await waitFor("deleted file to disappear from semantic answers", async () => {
+      const deletedInfo = await callTool<TypeInfoResult>("ts_type_info", {
+        file: "src/util.ts",
+        line: 1,
+        column: 14,
+      });
+      assert.equal(
+        deletedInfo.type,
+        null,
+        `Expected deleted file to have no type info, got ${JSON.stringify(deletedInfo)}`
+      );
+    });
+
+    console.log("");
+    console.log("typegraph-mcp Engine Sync Test");
+    console.log("==============================");
+    console.log("  ✓ import swaps keep dependency_tree and type_info aligned");
+    console.log("  ✓ export renames refresh ts_module_exports semantic metadata");
+    console.log("  ✓ deleted open files do not survive as tsserver ghost snapshots");
+  } finally {
+    await transport.close().catch(() => {});
+    fs.rmSync(tempRoot, { recursive: true, force: true });
+  }
+}
+
+main().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});

package/module-graph.ts

@@ -460,7 +460,11 @@ export function removeFile(graph: ModuleGraph, filePath: string): void {
 export function startWatcher(
   projectRoot: string,
   graph: ModuleGraph,
-  resolver: ResolverFactory
+  resolver: ResolverFactory,
+  hooks?: {
+    onFileUpdated?: (filePath: string) => void | Promise<void>;
+    onFileDeleted?: (filePath: string) => void | Promise<void>;
+  }
 ): void {
   try {
     const watcher = fs.watch(
@@ -489,9 +493,11 @@ export function startWatcher(
         if (fs.existsSync(absPath)) {
           // File created or modified
           updateFile(graph, absPath, resolver, projectRoot);
+          void hooks?.onFileUpdated?.(absPath);
         } else {
           // File deleted
           removeFile(graph, absPath);
+          void hooks?.onFileDeleted?.(absPath);
         }
       }
     );

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "typegraph-mcp",
-  "version": "0.9.41",
+  "version": "0.9.43",
   "description": "Type-aware codebase navigation for AI coding agents — 14 MCP tools powered by tsserver + oxc",
   "license": "MIT",
   "type": "module",
@@ -34,7 +34,7 @@
   "scripts": {
     "build": "tsup",
     "start": "tsx server.ts",
-    "test": "tsx smoke-test.ts && tsx export-surface-test.ts && tsx install-oxlint-test.ts",
+    "test": "tsx smoke-test.ts && tsx export-surface-test.ts && tsx engine-sync-test.ts && tsx install-oxlint-test.ts",
     "check": "tsx check.ts"
   },
   "dependencies": {

package/server.ts

@@ -1132,7 +1132,15 @@ async function main() {
 
   moduleGraph = graphResult.graph;
   moduleResolver = graphResult.resolver;
-  startWatcher(projectRoot, moduleGraph, graphResult.resolver);
+  startWatcher(projectRoot, moduleGraph, graphResult.resolver, {
+    onFileUpdated: (filePath) =>
+      client.reloadOpenFile(filePath).catch((err) => {
+        log(`Failed to reload open file ${relPath(filePath)}:`, err);
+      }),
+    onFileDeleted: (filePath) => {
+      client.closeFile(filePath);
+    },
+  });
 
   const transport = new StdioServerTransport();
   await mcpServer.connect(transport);

package/tsserver-client.ts

@@ -323,6 +323,23 @@ export class TsServerClient {
     await new Promise((r) => setTimeout(r, 50));
   }
 
+  async reloadOpenFile(file: string): Promise<boolean> {
+    const absPath = this.resolvePath(file);
+    if (!this.openFiles.has(absPath)) return false;
+    await this.sendRequest("reload", {
+      file: absPath,
+      tmpfile: absPath,
+    });
+    return true;
+  }
+
+  closeFile(file: string): boolean {
+    const absPath = this.resolvePath(file);
+    if (!this.openFiles.delete(absPath)) return false;
+    this.sendNotification("close", { file: absPath });
+    return true;
+  }
+
   // ─── Public API ────────────────────────────────────────────────────────
 
   async definition(file: string, line: number, offset: number): Promise<DefinitionResult[]> {