typegraph-mcp 0.9.0 → 0.9.2

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "typegraph",
-  "version": "0.9.0",
+  "version": "0.9.2",
   "description": "Type-aware TypeScript navigation — 14 MCP tools for go-to-definition, find-references, dependency graphs, cycle detection, and impact analysis",
   "author": {
     "name": "Owen Jones"

package/.cursor-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "typegraph",
-  "version": "0.9.0",
+  "version": "0.9.2",
   "description": "Type-aware TypeScript navigation — 14 MCP tools for go-to-definition, find-references, dependency graphs, cycle detection, and impact analysis",
   "author": {
     "name": "Owen Jones"

package/cli.ts

@@ -356,7 +356,9 @@ async function selectAgents(projectRoot: string, yes: boolean): Promise<AgentId[
 // ─── Setup Command ───────────────────────────────────────────────────────────
 
 async function setup(yes: boolean): Promise<void> {
-  const sourceDir = import.meta.dirname;
+  const sourceDir = path.basename(import.meta.dirname) === "dist"
+    ? path.resolve(import.meta.dirname, "..")
+    : import.meta.dirname;
   const projectRoot = process.cwd();
 
   process.stdout.write("\x1Bc"); // Clear terminal

package/dist/check.js

@@ -0,0 +1,376 @@
+
+// check.ts
+import * as fs from "fs";
+import * as path2 from "path";
+import { createRequire } from "module";
+import { spawn } from "child_process";
+
+// config.ts
+import * as path from "path";
+function resolveConfig(toolDir) {
+  const cwd = process.cwd();
+  const projectRoot = process.env["TYPEGRAPH_PROJECT_ROOT"] ? path.resolve(cwd, process.env["TYPEGRAPH_PROJECT_ROOT"]) : path.basename(path.dirname(toolDir)) === "plugins" ? path.resolve(toolDir, "../..") : cwd;
+  const tsconfigPath = process.env["TYPEGRAPH_TSCONFIG"] || "./tsconfig.json";
+  const toolIsEmbedded = toolDir.startsWith(projectRoot + path.sep);
+  const toolRelPath = toolIsEmbedded ? path.relative(projectRoot, toolDir) : toolDir;
+  return { projectRoot, tsconfigPath, toolDir, toolIsEmbedded, toolRelPath };
+}
+
+// check.ts
+function findFirstTsFile(dir) {
+  const skipDirs = /* @__PURE__ */ new Set(["node_modules", "dist", ".git", ".wrangler", "coverage"]);
+  try {
+    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+      if (entry.isFile() && entry.name.endsWith(".ts") && !entry.name.endsWith(".d.ts")) {
+        return path2.join(dir, entry.name);
+      }
+    }
+    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+      if (entry.isDirectory() && !skipDirs.has(entry.name) && !entry.name.startsWith(".")) {
+        const found = findFirstTsFile(path2.join(dir, entry.name));
+        if (found) return found;
+      }
+    }
+  } catch {
+  }
+  return null;
+}
+function testTsserver(projectRoot) {
+  return new Promise((resolve3) => {
+    let tsserverPath;
+    try {
+      const require2 = createRequire(path2.resolve(projectRoot, "package.json"));
+      tsserverPath = require2.resolve("typescript/lib/tsserver.js");
+    } catch {
+      resolve3(false);
+      return;
+    }
+    const child = spawn("node", [tsserverPath, "--disableAutomaticTypingAcquisition"], {
+      cwd: projectRoot,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    const timeout = setTimeout(() => {
+      child.kill();
+      resolve3(false);
+    }, 1e4);
+    let buffer = "";
+    child.stdout.on("data", (chunk) => {
+      buffer += chunk.toString();
+      if (buffer.includes('"success":true')) {
+        clearTimeout(timeout);
+        child.kill();
+        resolve3(true);
+      }
+    });
+    child.on("error", () => {
+      clearTimeout(timeout);
+      resolve3(false);
+    });
+    child.on("exit", () => {
+      clearTimeout(timeout);
+    });
+    const request = JSON.stringify({
+      seq: 1,
+      type: "request",
+      command: "configure",
+      arguments: {
+        preferences: { disableSuggestions: true }
+      }
+    });
+    child.stdin.write(request + "\n");
+  });
+}
+async function main(configOverride) {
+  const { projectRoot, tsconfigPath, toolDir, toolIsEmbedded, toolRelPath } = configOverride ?? resolveConfig(import.meta.dirname);
+  let passed = 0;
+  let failed = 0;
+  let warned = 0;
+  function pass(msg) {
+    console.log(`  \u2713 ${msg}`);
+    passed++;
+  }
+  function fail(msg, fix) {
+    console.log(`  \u2717 ${msg}`);
+    console.log(`    Fix: ${fix}`);
+    failed++;
+  }
+  function warn(msg, note) {
+    console.log(`  ! ${msg}`);
+    console.log(`    ${note}`);
+    warned++;
+  }
+  function skip(msg) {
+    console.log(`  - ${msg} (skipped)`);
+  }
+  console.log("");
+  console.log("typegraph-mcp Health Check");
+  console.log("=======================");
+  console.log(`Project root: ${projectRoot}`);
+  console.log("");
+  const nodeVersion = process.version;
+  const nodeMajor = parseInt(nodeVersion.slice(1).split(".")[0], 10);
+  if (nodeMajor >= 18) {
+    pass(`Node.js ${nodeVersion} (>= 18 required)`);
+  } else {
+    fail(`Node.js ${nodeVersion} is too old`, "Upgrade Node.js to >= 18");
+  }
+  const tsxInRoot = fs.existsSync(path2.join(projectRoot, "node_modules/.bin/tsx"));
+  const tsxInTool = fs.existsSync(path2.join(toolDir, "node_modules/.bin/tsx"));
+  if (tsxInRoot || tsxInTool) {
+    pass(`tsx available (in ${tsxInRoot ? "project" : "tool"} node_modules)`);
+  } else {
+    pass("tsx available (via npx/global)");
+  }
+  let tsVersion = null;
+  try {
+    const require2 = createRequire(path2.resolve(projectRoot, "package.json"));
+    const tsserverPath = require2.resolve("typescript/lib/tsserver.js");
+    const tsPkgPath = path2.resolve(path2.dirname(tsserverPath), "..", "package.json");
+    const tsPkg = JSON.parse(fs.readFileSync(tsPkgPath, "utf-8"));
+    tsVersion = tsPkg.version;
+    pass(`TypeScript found (v${tsVersion})`);
+  } catch {
+    fail(
+      "TypeScript not found in project",
+      "Add `typescript` to devDependencies and run `pnpm install`"
+    );
+  }
+  const tsconfigAbs = path2.resolve(projectRoot, tsconfigPath);
+  if (fs.existsSync(tsconfigAbs)) {
+    pass(`tsconfig.json exists at ${tsconfigPath}`);
+  } else {
+    fail(`tsconfig.json not found at ${tsconfigPath}`, `Create a tsconfig.json at ${tsconfigPath}`);
+  }
+  const pluginMcpPath = path2.join(toolDir, ".mcp.json");
+  const hasPluginMcp = fs.existsSync(pluginMcpPath) && fs.existsSync(path2.join(toolDir, ".claude-plugin/plugin.json"));
+  if (process.env.CLAUDE_PLUGIN_ROOT) {
+    pass("MCP registered via plugin (CLAUDE_PLUGIN_ROOT set)");
+  } else if (hasPluginMcp) {
+    pass("MCP registered via plugin (.mcp.json + .claude-plugin/ present)");
+  } else {
+    const mcpJsonPath = path2.resolve(projectRoot, ".claude/mcp.json");
+    if (fs.existsSync(mcpJsonPath)) {
+      try {
+        const mcpJson = JSON.parse(fs.readFileSync(mcpJsonPath, "utf-8"));
+        const tsNav = mcpJson?.mcpServers?.["typegraph"];
+        if (tsNav) {
+          const hasCommand = tsNav.command === "npx";
+          const hasArgs = Array.isArray(tsNav.args) && tsNav.args.includes("tsx");
+          const hasEnv = tsNav.env?.["TYPEGRAPH_PROJECT_ROOT"] && tsNav.env?.["TYPEGRAPH_TSCONFIG"];
+          if (hasCommand && hasArgs && hasEnv) {
+            pass("MCP registered in .claude/mcp.json");
+          } else {
+            const issues = [];
+            if (!hasCommand) issues.push("command should be 'npx'");
+            if (!hasArgs) issues.push("args should include 'tsx'");
+            if (!hasEnv) issues.push("env should set TYPEGRAPH_PROJECT_ROOT and TYPEGRAPH_TSCONFIG");
+            fail(
+              `MCP registration incomplete: ${issues.join(", ")}`,
+              "See README for correct .claude/mcp.json format"
+            );
+          }
+        } else {
+          const serverPath = toolIsEmbedded ? `./${toolRelPath}/server.ts` : path2.resolve(toolDir, "server.ts");
+          fail(
+            "MCP entry 'typegraph' not found in .claude/mcp.json",
+            `Add to .claude/mcp.json:
+    {
+      "mcpServers": {
+        "typegraph": {
+          "command": "npx",
+          "args": ["tsx", "${serverPath}"],
+          "env": { "TYPEGRAPH_PROJECT_ROOT": ".", "TYPEGRAPH_TSCONFIG": "./tsconfig.json" }
+        }
+      }
+    }`
+          );
+        }
+      } catch (err) {
+        fail(
+          "Failed to parse .claude/mcp.json",
+          `Check JSON syntax: ${err instanceof Error ? err.message : String(err)}`
+        );
+      }
+    } else {
+      fail(".claude/mcp.json not found", `Create .claude/mcp.json with typegraph server registration`);
+    }
+  }
+  const toolNodeModules = path2.join(toolDir, "node_modules");
+  if (fs.existsSync(toolNodeModules)) {
+    const requiredPkgs = ["@modelcontextprotocol/sdk", "oxc-parser", "oxc-resolver", "zod"];
+    const missing = requiredPkgs.filter(
+      (pkg) => !fs.existsSync(path2.join(toolNodeModules, ...pkg.split("/")))
+    );
+    if (missing.length === 0) {
+      pass(`Dependencies installed (${requiredPkgs.length} packages)`);
+    } else {
+      fail(`Missing packages: ${missing.join(", ")}`, `Run \`cd ${toolRelPath} && pnpm install\``);
+    }
+  } else {
+    fail("typegraph-mcp dependencies not installed", `Run \`cd ${toolRelPath} && pnpm install\``);
+  }
+  try {
+    const oxcParserReq = createRequire(path2.join(toolDir, "package.json"));
+    const { parseSync } = await import(oxcParserReq.resolve("oxc-parser"));
+    const result = parseSync("test.ts", 'import { x } from "./y";');
+    if (result.module?.staticImports?.length === 1) {
+      pass("oxc-parser working");
+    } else {
+      fail(
+        "oxc-parser parseSync returned unexpected result",
+        `Reinstall: \`cd ${toolRelPath} && rm -rf node_modules && pnpm install\``
+      );
+    }
+  } catch (err) {
+    fail(
+      `oxc-parser failed: ${err instanceof Error ? err.message : String(err)}`,
+      `Reinstall: \`cd ${toolRelPath} && rm -rf node_modules && pnpm install\``
+    );
+  }
+  try {
+    const oxcResolverReq = createRequire(path2.join(toolDir, "package.json"));
+    const { ResolverFactory } = await import(oxcResolverReq.resolve("oxc-resolver"));
+    const resolver = new ResolverFactory({
+      tsconfig: { configFile: tsconfigAbs, references: "auto" },
+      extensions: [".ts", ".tsx", ".js"],
+      extensionAlias: { ".js": [".ts", ".tsx", ".js"] }
+    });
+    let resolveOk = false;
+    const testFile = findFirstTsFile(projectRoot);
+    if (testFile) {
+      const dir = path2.dirname(testFile);
+      const base = "./" + path2.basename(testFile);
+      const result = resolver.sync(dir, base);
+      resolveOk = !!result.path;
+    }
+    if (resolveOk) {
+      pass("oxc-resolver working");
+    } else {
+      warn(
+        "oxc-resolver loaded but couldn't resolve a test import",
+        "Check tsconfig.json is valid and has correct `references`"
+      );
+    }
+  } catch (err) {
+    fail(
+      `oxc-resolver failed: ${err instanceof Error ? err.message : String(err)}`,
+      `Reinstall: \`cd ${toolRelPath} && rm -rf node_modules && pnpm install\``
+    );
+  }
+  if (tsVersion) {
+    try {
+      const ok = await testTsserver(projectRoot);
+      if (ok) {
+        pass("tsserver responds to configure");
+      } else {
+        fail(
+          "tsserver did not respond",
+          "Verify `typescript` is installed and tsconfig.json is valid"
+        );
+      }
+    } catch (err) {
+      fail(
+        `tsserver failed to start: ${err instanceof Error ? err.message : String(err)}`,
+        "Verify `typescript` is installed and tsconfig.json is valid"
+      );
+    }
+  } else {
+    skip("tsserver test (TypeScript not found)");
+  }
+  try {
+    const { buildGraph } = await import(path2.resolve(toolDir, "module-graph.js"));
+    const start = performance.now();
+    const { graph } = await buildGraph(projectRoot, tsconfigPath);
+    const elapsed = (performance.now() - start).toFixed(0);
+    const edgeCount = [...graph.forward.values()].reduce(
+      (s, e) => s + e.length,
+      0
+    );
+    if (graph.files.size > 0 && edgeCount > 0) {
+      pass(`Module graph: ${graph.files.size} files, ${edgeCount} edges [${elapsed}ms]`);
+    } else if (graph.files.size > 0) {
+      warn(
+        `Module graph: ${graph.files.size} files but 0 edges`,
+        "Files found but no internal imports resolved. Check tsconfig references."
+      );
+    } else {
+      fail(
+        "Module graph: 0 files discovered",
+        "Check tsconfig.json includes source files and project root is correct"
+      );
+    }
+  } catch (err) {
+    fail(
+      `Module graph build failed: ${err instanceof Error ? err.message : String(err)}`,
+      "Check that oxc-parser and oxc-resolver are installed correctly"
+    );
+  }
+  if (toolIsEmbedded) {
+    const eslintConfigPath = path2.resolve(projectRoot, "eslint.config.mjs");
+    if (fs.existsSync(eslintConfigPath)) {
+      const eslintContent = fs.readFileSync(eslintConfigPath, "utf-8");
+      const parentDir = path2.basename(path2.dirname(toolDir));
+      const parentIgnorePattern = new RegExp(`["']${parentDir}\\/\\*\\*["']`);
+      const hasParentIgnore = parentIgnorePattern.test(eslintContent);
+      if (hasParentIgnore) {
+        pass(`ESLint ignores ${parentDir}/`);
+      } else {
+        fail(
+          `ESLint missing ignore: "${parentDir}/**"`,
+          `Add to the ignores array in eslint.config.mjs:
+    "${parentDir}/**",`
+        );
+      }
+    } else {
+      skip("ESLint config check (no eslint.config.mjs)");
+    }
+  } else {
+    skip("ESLint config check (typegraph-mcp is external to project)");
+  }
+  const gitignorePath = path2.resolve(projectRoot, ".gitignore");
+  if (fs.existsSync(gitignorePath)) {
+    const gitignoreContent = fs.readFileSync(gitignorePath, "utf-8");
+    const lines = gitignoreContent.split("\n").map((l) => l.trim()).filter((l) => l && !l.startsWith("#"));
+    const ignoresClaude = lines.some(
+      (l) => l === ".claude/" || l === ".claude" || l === "/.claude"
+    );
+    const parentDir = toolIsEmbedded ? path2.basename(path2.dirname(toolDir)) : null;
+    const ignoresParent = parentDir && lines.some((l) => l === `${parentDir}/` || l === parentDir || l === `/${parentDir}`);
+    if (!ignoresParent && !ignoresClaude) {
+      pass(".gitignore does not exclude .claude/" + (parentDir ? ` or ${parentDir}/` : ""));
+    } else {
+      const excluded = [];
+      if (ignoresParent) excluded.push(`${parentDir}/`);
+      if (ignoresClaude) excluded.push(".claude/");
+      warn(
+        `.gitignore excludes ${excluded.join(" and ")}`,
+        "Remove these entries so MCP config and tool source are tracked in git"
+      );
+    }
+  } else {
+    skip(".gitignore check (no .gitignore)");
+  }
+  console.log("");
+  const total = passed + failed;
+  if (failed === 0) {
+    console.log(
+      `${passed}/${total} checks passed` + (warned > 0 ? ` (${warned} warning${warned > 1 ? "s" : ""})` : "") + " -- typegraph-mcp is ready"
+    );
+  } else {
+    console.log(
+      `${passed}/${total} checks passed, ${failed} failed` + (warned > 0 ? `, ${warned} warning${warned > 1 ? "s" : ""}` : "") + " -- fix issues above"
+    );
+  }
+  console.log("");
+  return { passed, failed, warned };
+}
+var isDirectRun = process.argv[1] && fs.realpathSync(process.argv[1]) === fs.realpathSync(new URL(import.meta.url).pathname);
+if (isDirectRun) {
+  main().then((result) => process.exit(result.failed > 0 ? 1 : 0)).catch((err) => {
+    console.error("Fatal error:", err);
+    process.exit(1);
+  });
+}
+export {
+  main
+};