typegraph-mcp 0.9.44 → 0.9.45

package/dist/benchmark.js

@@ -25,6 +25,7 @@ var TsServerClient = class {
   shuttingDown = false;
   restartCount = 0;
   maxRestarts = 3;
+  projectsDirty = false;
   // ─── Path Resolution ────────────────────────────────────────────────────
   resolvePath(file) {
     return path.isAbsolute(file) ? file : path.resolve(this.projectRoot, file);
@@ -201,6 +202,24 @@ var TsServerClient = class {
     this.sendNotification("open", { file: absPath });
     await new Promise((r) => setTimeout(r, 50));
   }
+  /**
+   * Mark tsserver's view of the disk as stale (a file changed that is NOT open
+   * in tsserver). tsserver's own disk watching silently decays in long-lived
+   * instances at monorepo scale, leaving closed-file contents frozen at project
+   * load time and new files unassigned (they land in single-file inferred
+   * projects, producing definition-only reference results). The next query
+   * forces a `reloadProjects`, which re-globs configs and re-reads closed files
+   * from disk. Open files are unaffected by design — their content is
+   * protocol-owned and refreshed via reloadOpenFile().
+   */
+  markProjectsDirty() {
+    this.projectsDirty = true;
+  }
+  refreshIfDirty() {
+    if (!this.projectsDirty) return;
+    this.projectsDirty = false;
+    this.sendNotification("reloadProjects");
+  }
   async reloadOpenFile(file) {
     const absPath = this.resolvePath(file);
     if (!this.openFiles.has(absPath)) return false;
@@ -218,6 +237,7 @@ var TsServerClient = class {
   }
   // ─── Public API ────────────────────────────────────────────────────────
   async definition(file, line, offset) {
+    this.refreshIfDirty();
     const absPath = this.resolvePath(file);
     await this.ensureOpen(absPath);
     const body = await this.sendRequest("definition", {
@@ -232,6 +252,7 @@ var TsServerClient = class {
     }));
   }
   async references(file, line, offset) {
+    this.refreshIfDirty();
     const absPath = this.resolvePath(file);
     await this.ensureOpen(absPath);
     const body = await this.sendRequest("references", {
@@ -246,6 +267,7 @@ var TsServerClient = class {
     }));
   }
   async quickinfo(file, line, offset) {
+    this.refreshIfDirty();
     const absPath = this.resolvePath(file);
     await this.ensureOpen(absPath);
     try {
@@ -260,6 +282,7 @@ var TsServerClient = class {
     }
   }
   async navto(searchValue, maxResults = 10, file) {
+    this.refreshIfDirty();
     if (file) await this.ensureOpen(file);
     const args = {
       searchValue,
@@ -274,6 +297,7 @@ var TsServerClient = class {
     }));
   }
   async navbar(file) {
+    this.refreshIfDirty();
     const absPath = this.resolvePath(file);
     await this.ensureOpen(absPath);
     const body = await this.sendRequest("navbar", {

package/dist/cli.js

@@ -954,6 +954,7 @@ var init_tsserver_client = __esm({
       shuttingDown = false;
       restartCount = 0;
       maxRestarts = 3;
+      projectsDirty = false;
       // ─── Path Resolution ────────────────────────────────────────────────────
       resolvePath(file) {
         return path4.isAbsolute(file) ? file : path4.resolve(this.projectRoot, file);
@@ -1130,6 +1131,24 @@ var init_tsserver_client = __esm({
         this.sendNotification("open", { file: absPath2 });
         await new Promise((r) => setTimeout(r, 50));
       }
+      /**
+       * Mark tsserver's view of the disk as stale (a file changed that is NOT open
+       * in tsserver). tsserver's own disk watching silently decays in long-lived
+       * instances at monorepo scale, leaving closed-file contents frozen at project
+       * load time and new files unassigned (they land in single-file inferred
+       * projects, producing definition-only reference results). The next query
+       * forces a `reloadProjects`, which re-globs configs and re-reads closed files
+       * from disk. Open files are unaffected by design — their content is
+       * protocol-owned and refreshed via reloadOpenFile().
+       */
+      markProjectsDirty() {
+        this.projectsDirty = true;
+      }
+      refreshIfDirty() {
+        if (!this.projectsDirty) return;
+        this.projectsDirty = false;
+        this.sendNotification("reloadProjects");
+      }
       async reloadOpenFile(file) {
         const absPath2 = this.resolvePath(file);
         if (!this.openFiles.has(absPath2)) return false;
@@ -1147,6 +1166,7 @@ var init_tsserver_client = __esm({
       }
       // ─── Public API ────────────────────────────────────────────────────────
       async definition(file, line, offset) {
+        this.refreshIfDirty();
         const absPath2 = this.resolvePath(file);
         await this.ensureOpen(absPath2);
         const body = await this.sendRequest("definition", {
@@ -1161,6 +1181,7 @@ var init_tsserver_client = __esm({
         }));
       }
       async references(file, line, offset) {
+        this.refreshIfDirty();
         const absPath2 = this.resolvePath(file);
         await this.ensureOpen(absPath2);
         const body = await this.sendRequest("references", {
@@ -1175,6 +1196,7 @@ var init_tsserver_client = __esm({
         }));
       }
       async quickinfo(file, line, offset) {
+        this.refreshIfDirty();
         const absPath2 = this.resolvePath(file);
         await this.ensureOpen(absPath2);
         try {
@@ -1189,6 +1211,7 @@ var init_tsserver_client = __esm({
         }
       }
       async navto(searchValue, maxResults = 10, file) {
+        this.refreshIfDirty();
         if (file) await this.ensureOpen(file);
         const args2 = {
           searchValue,
@@ -1203,6 +1226,7 @@ var init_tsserver_client = __esm({
         }));
       }
       async navbar(file) {
+        this.refreshIfDirty();
         const absPath2 = this.resolvePath(file);
         await this.ensureOpen(absPath2);
         const body = await this.sendRequest("navbar", {
@@ -2697,11 +2721,18 @@ async function main4() {
   moduleGraph = graphResult.graph;
   moduleResolver = graphResult.resolver;
   startWatcher(projectRoot2, moduleGraph, graphResult.resolver, {
-    onFileUpdated: (filePath) => client.reloadOpenFile(filePath).catch((err) => {
-      log3(`Failed to reload open file ${relPath2(filePath)}:`, err);
-    }),
+    onFileUpdated: (filePath) => client.reloadOpenFile(filePath).then(
+      (wasOpen) => {
+        if (!wasOpen) client.markProjectsDirty();
+      },
+      (err) => {
+        client.markProjectsDirty();
+        log3(`Failed to reload open file ${relPath2(filePath)}:`, err);
+      }
+    ),
     onFileDeleted: (filePath) => {
       client.closeFile(filePath);
+      client.markProjectsDirty();
     }
   });
   const transport = new StdioServerTransport();

package/dist/server.js

@@ -26,6 +26,7 @@ var TsServerClient = class {
   shuttingDown = false;
   restartCount = 0;
   maxRestarts = 3;
+  projectsDirty = false;
   // ─── Path Resolution ────────────────────────────────────────────────────
   resolvePath(file) {
     return path.isAbsolute(file) ? file : path.resolve(this.projectRoot, file);
@@ -202,6 +203,24 @@ var TsServerClient = class {
     this.sendNotification("open", { file: absPath2 });
     await new Promise((r) => setTimeout(r, 50));
   }
+  /**
+   * Mark tsserver's view of the disk as stale (a file changed that is NOT open
+   * in tsserver). tsserver's own disk watching silently decays in long-lived
+   * instances at monorepo scale, leaving closed-file contents frozen at project
+   * load time and new files unassigned (they land in single-file inferred
+   * projects, producing definition-only reference results). The next query
+   * forces a `reloadProjects`, which re-globs configs and re-reads closed files
+   * from disk. Open files are unaffected by design — their content is
+   * protocol-owned and refreshed via reloadOpenFile().
+   */
+  markProjectsDirty() {
+    this.projectsDirty = true;
+  }
+  refreshIfDirty() {
+    if (!this.projectsDirty) return;
+    this.projectsDirty = false;
+    this.sendNotification("reloadProjects");
+  }
   async reloadOpenFile(file) {
     const absPath2 = this.resolvePath(file);
     if (!this.openFiles.has(absPath2)) return false;
@@ -219,6 +238,7 @@ var TsServerClient = class {
   }
   // ─── Public API ────────────────────────────────────────────────────────
   async definition(file, line, offset) {
+    this.refreshIfDirty();
     const absPath2 = this.resolvePath(file);
     await this.ensureOpen(absPath2);
     const body = await this.sendRequest("definition", {
@@ -233,6 +253,7 @@ var TsServerClient = class {
     }));
   }
   async references(file, line, offset) {
+    this.refreshIfDirty();
     const absPath2 = this.resolvePath(file);
     await this.ensureOpen(absPath2);
     const body = await this.sendRequest("references", {
@@ -247,6 +268,7 @@ var TsServerClient = class {
     }));
   }
   async quickinfo(file, line, offset) {
+    this.refreshIfDirty();
     const absPath2 = this.resolvePath(file);
     await this.ensureOpen(absPath2);
     try {
@@ -261,6 +283,7 @@ var TsServerClient = class {
     }
   }
   async navto(searchValue, maxResults = 10, file) {
+    this.refreshIfDirty();
     if (file) await this.ensureOpen(file);
     const args = {
       searchValue,
@@ -275,6 +298,7 @@ var TsServerClient = class {
     }));
   }
   async navbar(file) {
+    this.refreshIfDirty();
     const absPath2 = this.resolvePath(file);
     await this.ensureOpen(absPath2);
     const body = await this.sendRequest("navbar", {
@@ -1695,11 +1719,18 @@ async function main() {
   moduleGraph = graphResult.graph;
   moduleResolver = graphResult.resolver;
   startWatcher(projectRoot, moduleGraph, graphResult.resolver, {
-    onFileUpdated: (filePath) => client.reloadOpenFile(filePath).catch((err) => {
-      log3(`Failed to reload open file ${relPath(filePath)}:`, err);
-    }),
+    onFileUpdated: (filePath) => client.reloadOpenFile(filePath).then(
+      (wasOpen) => {
+        if (!wasOpen) client.markProjectsDirty();
+      },
+      (err) => {
+        client.markProjectsDirty();
+        log3(`Failed to reload open file ${relPath(filePath)}:`, err);
+      }
+    ),
     onFileDeleted: (filePath) => {
       client.closeFile(filePath);
+      client.markProjectsDirty();
     }
   });
   const transport = new StdioServerTransport();

package/dist/smoke-test.js

@@ -24,6 +24,7 @@ var TsServerClient = class {
   shuttingDown = false;
   restartCount = 0;
   maxRestarts = 3;
+  projectsDirty = false;
   // ─── Path Resolution ────────────────────────────────────────────────────
   resolvePath(file) {
     return path.isAbsolute(file) ? file : path.resolve(this.projectRoot, file);
@@ -200,6 +201,24 @@ var TsServerClient = class {
     this.sendNotification("open", { file: absPath });
     await new Promise((r) => setTimeout(r, 50));
   }
+  /**
+   * Mark tsserver's view of the disk as stale (a file changed that is NOT open
+   * in tsserver). tsserver's own disk watching silently decays in long-lived
+   * instances at monorepo scale, leaving closed-file contents frozen at project
+   * load time and new files unassigned (they land in single-file inferred
+   * projects, producing definition-only reference results). The next query
+   * forces a `reloadProjects`, which re-globs configs and re-reads closed files
+   * from disk. Open files are unaffected by design — their content is
+   * protocol-owned and refreshed via reloadOpenFile().
+   */
+  markProjectsDirty() {
+    this.projectsDirty = true;
+  }
+  refreshIfDirty() {
+    if (!this.projectsDirty) return;
+    this.projectsDirty = false;
+    this.sendNotification("reloadProjects");
+  }
   async reloadOpenFile(file) {
     const absPath = this.resolvePath(file);
     if (!this.openFiles.has(absPath)) return false;
@@ -217,6 +236,7 @@ var TsServerClient = class {
   }
   // ─── Public API ────────────────────────────────────────────────────────
   async definition(file, line, offset) {
+    this.refreshIfDirty();
     const absPath = this.resolvePath(file);
     await this.ensureOpen(absPath);
     const body = await this.sendRequest("definition", {
@@ -231,6 +251,7 @@ var TsServerClient = class {
     }));
   }
   async references(file, line, offset) {
+    this.refreshIfDirty();
     const absPath = this.resolvePath(file);
     await this.ensureOpen(absPath);
     const body = await this.sendRequest("references", {
@@ -245,6 +266,7 @@ var TsServerClient = class {
     }));
   }
   async quickinfo(file, line, offset) {
+    this.refreshIfDirty();
     const absPath = this.resolvePath(file);
     await this.ensureOpen(absPath);
     try {
@@ -259,6 +281,7 @@ var TsServerClient = class {
     }
   }
   async navto(searchValue, maxResults = 10, file) {
+    this.refreshIfDirty();
     if (file) await this.ensureOpen(file);
     const args = {
       searchValue,
@@ -273,6 +296,7 @@ var TsServerClient = class {
     }));
   }
   async navbar(file) {
+    this.refreshIfDirty();
     const absPath = this.resolvePath(file);
     await this.ensureOpen(absPath);
     const body = await this.sendRequest("navbar", {

package/dist/tsserver-client.js

@@ -19,6 +19,7 @@ var TsServerClient = class {
   shuttingDown = false;
   restartCount = 0;
   maxRestarts = 3;
+  projectsDirty = false;
   // ─── Path Resolution ────────────────────────────────────────────────────
   resolvePath(file) {
     return path.isAbsolute(file) ? file : path.resolve(this.projectRoot, file);
@@ -195,6 +196,24 @@ var TsServerClient = class {
     this.sendNotification("open", { file: absPath });
     await new Promise((r) => setTimeout(r, 50));
   }
+  /**
+   * Mark tsserver's view of the disk as stale (a file changed that is NOT open
+   * in tsserver). tsserver's own disk watching silently decays in long-lived
+   * instances at monorepo scale, leaving closed-file contents frozen at project
+   * load time and new files unassigned (they land in single-file inferred
+   * projects, producing definition-only reference results). The next query
+   * forces a `reloadProjects`, which re-globs configs and re-reads closed files
+   * from disk. Open files are unaffected by design — their content is
+   * protocol-owned and refreshed via reloadOpenFile().
+   */
+  markProjectsDirty() {
+    this.projectsDirty = true;
+  }
+  refreshIfDirty() {
+    if (!this.projectsDirty) return;
+    this.projectsDirty = false;
+    this.sendNotification("reloadProjects");
+  }
   async reloadOpenFile(file) {
     const absPath = this.resolvePath(file);
     if (!this.openFiles.has(absPath)) return false;
@@ -212,6 +231,7 @@ var TsServerClient = class {
   }
   // ─── Public API ────────────────────────────────────────────────────────
   async definition(file, line, offset) {
+    this.refreshIfDirty();
     const absPath = this.resolvePath(file);
     await this.ensureOpen(absPath);
     const body = await this.sendRequest("definition", {
@@ -226,6 +246,7 @@ var TsServerClient = class {
     }));
   }
   async references(file, line, offset) {
+    this.refreshIfDirty();
     const absPath = this.resolvePath(file);
     await this.ensureOpen(absPath);
     const body = await this.sendRequest("references", {
@@ -240,6 +261,7 @@ var TsServerClient = class {
     }));
   }
   async quickinfo(file, line, offset) {
+    this.refreshIfDirty();
     const absPath = this.resolvePath(file);
     await this.ensureOpen(absPath);
     try {
@@ -254,6 +276,7 @@ var TsServerClient = class {
     }
   }
   async navto(searchValue, maxResults = 10, file) {
+    this.refreshIfDirty();
     if (file) await this.ensureOpen(file);
     const args = {
       searchValue,
@@ -268,6 +291,7 @@ var TsServerClient = class {
     }));
   }
   async navbar(file) {
+    this.refreshIfDirty();
     const absPath = this.resolvePath(file);
     await this.ensureOpen(absPath);
     const body = await this.sendRequest("navbar", {

package/engine-sync-test.ts

@@ -114,6 +114,12 @@ async function main(): Promise<void> {
   );
   writeFile(projectRoot, "src/test.ts", "export const oldName = 1 as const;\n");
   writeFile(projectRoot, "src/util.ts", "export const helper = 1 as const;\n");
+  writeFile(projectRoot, "src/closed.ts", "export const closedValue = 1 as const;\n");
+  writeFile(
+    projectRoot,
+    "src/closed-consumer.ts",
+    'import { closedValue } from "./closed";\nexport const observed = closedValue;\n'
+  );
 
   fs.mkdirSync(path.join(projectRoot, "node_modules"), { recursive: true });
   fs.symlinkSync(
@@ -196,6 +202,25 @@ async function main(): Promise<void> {
       assert.ok(!exportsResult.exports.some((item) => item.symbol === "oldName"));
     });
 
+    // Change a file that tsserver has not opened. The watcher should mark
+    // projects dirty so the next semantic query reloads closed-file contents.
+    writeFile(projectRoot, "src/closed.ts", "export const closedValue = 2 as const;\n");
+
+    await waitFor("closed file update to refresh semantic project state", async () => {
+      const deps = await callTool<DependencyTreeResult>("ts_dependency_tree", {
+        file: "src/closed-consumer.ts",
+      });
+      const normalizedDeps = deps.files.map(normalize);
+      assert.ok(normalizedDeps.includes("src/closed.ts"), `Expected src/closed.ts in ${normalizedDeps}`);
+
+      const typeInfo = await callTool<TypeInfoResult>("ts_type_info", {
+        file: "src/closed-consumer.ts",
+        line: 2,
+        column: 14,
+      });
+      assert.match(typeInfo.type ?? "", /\b2\b/);
+    });
+
     // 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",
@@ -223,6 +248,7 @@ async function main(): Promise<void> {
     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("  ✓ closed-file edits refresh tsserver project state");
     console.log("  ✓ deleted open files do not survive as tsserver ghost snapshots");
   } finally {
     await transport.close().catch(() => {});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "typegraph-mcp",
-  "version": "0.9.44",
+  "version": "0.9.45",
   "description": "Type-aware codebase navigation for AI coding agents — 14 MCP tools powered by tsserver + oxc",
   "license": "MIT",
   "type": "module",

package/server.ts

@@ -1134,11 +1134,20 @@ async function main() {
   moduleResolver = graphResult.resolver;
   startWatcher(projectRoot, moduleGraph, graphResult.resolver, {
     onFileUpdated: (filePath) =>
-      client.reloadOpenFile(filePath).catch((err) => {
-        log(`Failed to reload open file ${relPath(filePath)}:`, err);
-      }),
+      client.reloadOpenFile(filePath).then(
+        (wasOpen) => {
+          // Closed files: tsserver's own disk watching decays in long-lived
+          // instances; force a projects reload before the next query.
+          if (!wasOpen) client.markProjectsDirty();
+        },
+        (err) => {
+          client.markProjectsDirty();
+          log(`Failed to reload open file ${relPath(filePath)}:`, err);
+        }
+      ),
     onFileDeleted: (filePath) => {
       client.closeFile(filePath);
+      client.markProjectsDirty();
     },
   });
 

package/tsserver-client.ts

@@ -90,6 +90,7 @@ export class TsServerClient {
   private shuttingDown = false;
   private restartCount = 0;
   private readonly maxRestarts = 3;
+  private projectsDirty = false;
 
   constructor(
     private readonly projectRoot: string,
@@ -323,6 +324,29 @@ export class TsServerClient {
     await new Promise((r) => setTimeout(r, 50));
   }
 
+  /**
+   * Mark tsserver's view of the disk as stale (a file changed that is NOT open
+   * in tsserver). tsserver's own disk watching silently decays in long-lived
+   * instances at monorepo scale, leaving closed-file contents frozen at project
+   * load time and new files unassigned (they land in single-file inferred
+   * projects, producing definition-only reference results). The next query
+   * forces a `reloadProjects`, which re-globs configs and re-reads closed files
+   * from disk. Open files are unaffected by design — their content is
+   * protocol-owned and refreshed via reloadOpenFile().
+   */
+  markProjectsDirty(): void {
+    this.projectsDirty = true;
+  }
+
+  private refreshIfDirty(): void {
+    if (!this.projectsDirty) return;
+    this.projectsDirty = false;
+    // reloadProjects sends no response (notRequired), so fire it as a
+    // notification; the following request queues behind the reload on
+    // tsserver's single-threaded loop.
+    this.sendNotification("reloadProjects");
+  }
+
   async reloadOpenFile(file: string): Promise<boolean> {
     const absPath = this.resolvePath(file);
     if (!this.openFiles.has(absPath)) return false;
@@ -343,6 +367,7 @@ export class TsServerClient {
   // ─── Public API ────────────────────────────────────────────────────────
 
   async definition(file: string, line: number, offset: number): Promise<DefinitionResult[]> {
+    this.refreshIfDirty();
     const absPath = this.resolvePath(file);
     await this.ensureOpen(absPath);
 
@@ -361,6 +386,7 @@ export class TsServerClient {
   }
 
   async references(file: string, line: number, offset: number): Promise<ReferenceEntry[]> {
+    this.refreshIfDirty();
     const absPath = this.resolvePath(file);
     await this.ensureOpen(absPath);
 
@@ -379,6 +405,7 @@ export class TsServerClient {
   }
 
   async quickinfo(file: string, line: number, offset: number): Promise<QuickInfoResult | null> {
+    this.refreshIfDirty();
     const absPath = this.resolvePath(file);
     await this.ensureOpen(absPath);
 
@@ -398,6 +425,7 @@ export class TsServerClient {
   }
 
   async navto(searchValue: string, maxResults = 10, file?: string): Promise<NavToItem[]> {
+    this.refreshIfDirty();
     // If a file is specified, open it first so tsserver knows about it
     if (file) await this.ensureOpen(file);
 
@@ -418,6 +446,7 @@ export class TsServerClient {
   }
 
   async navbar(file: string): Promise<NavBarItem[]> {
+    this.refreshIfDirty();
     const absPath = this.resolvePath(file);
     await this.ensureOpen(absPath);