typegraph-mcp 0.9.47 → 0.9.48

package/scripts/self-install.ts

@@ -0,0 +1,78 @@
+#!/usr/bin/env npx tsx
+
+import { spawnSync } from "node:child_process";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+
+export const SELF_INSTALL_IGNORES = [
+  "/plugins/typegraph-mcp/",
+  "/.agents/",
+  "/.codex/",
+  "/AGENTS.md",
+  "/CLAUDE.md",
+] as const;
+
+export function isGitWorkTree(projectRoot: string): boolean {
+  const result = spawnSync("git", ["-C", projectRoot, "rev-parse", "--is-inside-work-tree"], {
+    encoding: "utf-8",
+    stdio: ["ignore", "pipe", "ignore"],
+  });
+  return result.status === 0 && result.stdout.trim() === "true";
+}
+
+export function ensureSelfInstallIgnores(projectRoot: string): string[] {
+  if (!isGitWorkTree(projectRoot)) return [];
+
+  const gitignorePath = path.join(projectRoot, ".gitignore");
+  const existing = fs.existsSync(gitignorePath)
+    ? fs.readFileSync(gitignorePath, "utf-8")
+    : "";
+  const existingLines = new Set(existing.split(/\r?\n/));
+  const added = SELF_INSTALL_IGNORES.filter((pattern) => !existingLines.has(pattern));
+
+  if (added.length > 0) {
+    const separator = existing.length > 0 && !existing.endsWith("\n") ? "\n" : "";
+    fs.writeFileSync(gitignorePath, `${existing}${separator}${added.join("\n")}\n`);
+  }
+
+  return [...added];
+}
+
+function ensureAgentMarkers(projectRoot: string): void {
+  for (const fileName of ["AGENTS.md", "CLAUDE.md"]) {
+    const filePath = path.join(projectRoot, fileName);
+    if (!fs.existsSync(filePath)) fs.writeFileSync(filePath, "");
+  }
+}
+
+function main(): void {
+  const projectRoot = path.resolve(import.meta.dirname, "..");
+  const addedIgnores = ensureSelfInstallIgnores(projectRoot);
+
+  if (isGitWorkTree(projectRoot)) {
+    console.log(
+      addedIgnores.length > 0
+        ? `Added ${addedIgnores.length} self-install entries to .gitignore`
+        : "Self-install artifacts are already ignored"
+    );
+  } else {
+    console.log("Git worktree not found; skipping .gitignore update");
+  }
+
+  ensureAgentMarkers(projectRoot);
+
+  const tsxPath = path.join(projectRoot, "node_modules/.bin/tsx");
+  const cliPath = path.join(projectRoot, "cli.ts");
+  const result = spawnSync(tsxPath, [cliPath, "setup", "--yes"], {
+    cwd: projectRoot,
+    stdio: "inherit",
+  });
+
+  if (result.error) throw result.error;
+  process.exit(result.status ?? 1);
+}
+
+if (process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
+  main();
+}

package/server.ts

@@ -41,7 +41,8 @@ import { resolveConfig } from "./config.js";
 
 // ─── Configuration ───────────────────────────────────────────────────────────
 
-const { projectRoot, tsconfigPath } = resolveConfig(import.meta.dirname);
+const { projectRoot, tsconfigPath, toolDir, toolIsEmbedded } = resolveConfig(import.meta.dirname);
+const excludedPaths = toolIsEmbedded ? [toolDir] : [];
 
 const log = (...args: unknown[]) => console.error("[typegraph]", ...args);
 
@@ -1127,29 +1128,35 @@ async function main() {
   // Start tsserver and build module graph concurrently
   const [, graphResult] = await Promise.all([
     client.start(),
-    buildGraph(projectRoot, tsconfigPath),
+    buildGraph(projectRoot, tsconfigPath, excludedPaths),
   ]);
 
   moduleGraph = graphResult.graph;
   moduleResolver = graphResult.resolver;
-  startWatcher(projectRoot, moduleGraph, graphResult.resolver, {
-    onFileUpdated: (filePath) =>
-      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();
+  startWatcher(
+    projectRoot,
+    moduleGraph,
+    graphResult.resolver,
+    {
+      onFileUpdated: (filePath) =>
+        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();
+      },
     },
-  });
+    excludedPaths
+  );
 
   const transport = new StdioServerTransport();
   await mcpServer.connect(transport);

package/smoke-test.ts

@@ -144,8 +144,9 @@ const SKIP_DIRS = new Set([
 ]);
 
 /** Find a file with imports and exported symbols (good test candidate) */
-function findTestFile(rootDir: string): string | null {
+function findTestFile(rootDir: string, excludedPaths: string[] = []): string | null {
   const candidates: Array<{ file: string; size: number }> = [];
+  const normalizedExclusions = excludedPaths.map((excludedPath) => path.resolve(excludedPath));
 
   function walk(dir: string, depth: number): void {
     if (depth > 5 || candidates.length >= 30) return;
@@ -158,7 +159,14 @@ function findTestFile(rootDir: string): string | null {
     for (const entry of entries) {
       if (entry.isDirectory()) {
         if (SKIP_DIRS.has(entry.name) || entry.name.startsWith(".")) continue;
-        walk(path.join(dir, entry.name), depth + 1);
+        const childDir = path.join(dir, entry.name);
+        if (
+          normalizedExclusions.some(
+            (excludedPath) =>
+              childDir === excludedPath || childDir.startsWith(excludedPath + path.sep)
+          )
+        ) continue;
+        walk(childDir, depth + 1);
       } else if (entry.isFile()) {
         const name = entry.name;
         if (name.endsWith(".d.ts") || name.endsWith(".test.ts") || name.endsWith(".spec.ts"))
@@ -166,7 +174,7 @@ function findTestFile(rootDir: string): string | null {
         if (!name.endsWith(".ts") && !name.endsWith(".tsx")) continue;
         try {
           const stat = fs.statSync(path.join(dir, name));
-          if (stat.size > 200 && stat.size < 50000) {
+          if (stat.size > 0 && stat.size < 50000) {
             candidates.push({ file: path.join(dir, name), size: stat.size });
           }
         } catch {
@@ -199,8 +207,9 @@ function findImporter(graph: ModuleGraph, file: string): string | null {
 // ─── Main ────────────────────────────────────────────────────────────────────
 
 export async function main(configOverride?: TypegraphConfig): Promise<SmokeTestResult> {
-  const { projectRoot, tsconfigPath } =
+  const { projectRoot, tsconfigPath, toolDir, toolIsEmbedded } =
     configOverride ?? resolveConfig(import.meta.dirname);
+  const excludedPaths = toolIsEmbedded ? [toolDir] : [];
 
   let passed = 0;
   let failed = 0;
@@ -231,7 +240,7 @@ export async function main(configOverride?: TypegraphConfig): Promise<SmokeTestR
 
   // ─── Discover a test file ───────────────────────────────────────────────
 
-  const testFile = findTestFile(projectRoot);
+  const testFile = findTestFile(projectRoot, excludedPaths);
   if (!testFile) {
     console.log("  No suitable .ts file found in project. Cannot run smoke tests.");
     return { passed, failed: failed + 1, skipped };
@@ -250,7 +259,7 @@ export async function main(configOverride?: TypegraphConfig): Promise<SmokeTestR
   // Graph build
   t0 = performance.now();
   try {
-    const result = await buildGraph(projectRoot, tsconfigPath);
+    const result = await buildGraph(projectRoot, tsconfigPath, excludedPaths);
     graph = result.graph;
     const ms = performance.now() - t0;
     const edgeCount = [...graph.forward.values()].reduce((s, e) => s + e.length, 0);

package/tsserver-client.ts

@@ -80,6 +80,43 @@ interface PendingRequest {
   command: string;
 }
 
+export interface TsServerResolution {
+  path: string;
+  version: string;
+  source: "project" | "typegraph";
+  projectVersion?: string;
+}
+
+function readPackageVersion(packagePath: string): string {
+  const pkg = JSON.parse(fs.readFileSync(packagePath, "utf-8")) as { version?: string };
+  return pkg.version ?? "unknown";
+}
+
+/** Resolve legacy tsserver, falling back when the project uses TypeScript 7's LSP runtime. */
+export function resolveTsServer(projectRoot: string): TsServerResolution {
+  const projectRequire = createRequire(path.resolve(projectRoot, "package.json"));
+  let projectVersion: string | undefined;
+
+  try {
+    const packagePath = projectRequire.resolve("typescript/package.json");
+    projectVersion = readPackageVersion(packagePath);
+    const serverPath = projectRequire.resolve("typescript/lib/tsserver.js");
+    return { path: serverPath, version: projectVersion, source: "project" };
+  } catch {
+    // TypeScript 7 is installed without the legacy tsserver entrypoint.
+  }
+
+  const toolRequire = createRequire(import.meta.url);
+  const packagePath = toolRequire.resolve("typescript/package.json");
+  const serverPath = toolRequire.resolve("typescript/lib/tsserver.js");
+  return {
+    path: serverPath,
+    version: readPackageVersion(packagePath),
+    source: "typegraph",
+    projectVersion,
+  };
+}
+
 export class TsServerClient {
   private child: ChildProcess | null = null;
   private seq = 0;
@@ -124,11 +161,15 @@ export class TsServerClient {
   async start(): Promise<void> {
     if (this.child) return;
 
-    // Resolve tsserver from the TARGET project's node_modules, not the MCP server's
-    const require = createRequire(path.resolve(this.projectRoot, "package.json"));
-    const tsserverPath = require.resolve("typescript/lib/tsserver.js");
+    const resolution = resolveTsServer(this.projectRoot);
+    const tsserverPath = resolution.path;
 
-    log(`Spawning tsserver: ${tsserverPath}`);
+    const fallbackNote = resolution.projectVersion
+      ? `; project TypeScript ${resolution.projectVersion} has no legacy tsserver`
+      : "";
+    log(
+      `Spawning tsserver: ${tsserverPath} (TypeScript ${resolution.version}, ${resolution.source}${fallbackNote})`
+    );
     log(`Project root: ${this.projectRoot}`);
     log(`tsconfig: ${this.tsconfigPath}`);
 
@@ -164,14 +205,11 @@ export class TsServerClient {
       },
     });
 
-    // Warm up by opening the tsconfig's root file
+    // Keep inferred projects useful when the target has no tsconfig or a file sits outside it.
     const warmStart = performance.now();
-    const tsconfigAbs = this.resolvePath(this.tsconfigPath);
-    if (fs.existsSync(tsconfigAbs)) {
-      await this.sendRequest("compilerOptionsForInferredProjects", {
-        options: { allowJs: true, checkJs: false },
-      });
-    }
+    await this.sendRequest("compilerOptionsForInferredProjects", {
+      options: { allowJs: true, checkJs: false },
+    });
     this.ready = true;
     log(`Ready [${(performance.now() - warmStart).toFixed(0)}ms configure]`);
   }

package/engine-sync-test.ts

@@ -1,262 +0,0 @@
-#!/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");
-  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(
-    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"));
-    });
-
-    // 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",
-      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("  ✓ closed-file edits refresh tsserver project state");
-    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);
-});