typegraph-mcp 0.9.46 → 0.9.48

package/module-graph.ts

@@ -55,8 +55,22 @@ const SKIP_FILES = new Set(["routeTree.gen.ts"]);
 
 // ─── File Discovery ──────────────────────────────────────────────────────────
 
-export function discoverFiles(rootDir: string): string[] {
+function normalizeExcludedPaths(rootDir: string, excludedPaths: string[]): string[] {
+  return excludedPaths.map((excludedPath) =>
+    path.resolve(rootDir, excludedPath)
+  );
+}
+
+function isExcluded(filePath: string, excludedPaths: string[]): boolean {
+  return excludedPaths.some(
+    (excludedPath) =>
+      filePath === excludedPath || filePath.startsWith(excludedPath + path.sep)
+  );
+}
+
+export function discoverFiles(rootDir: string, excludedPaths: string[] = []): string[] {
   const files: string[] = [];
+  const normalizedExclusions = normalizeExcludedPaths(rootDir, excludedPaths);
 
   function walk(dir: string): void {
     let entries: fs.Dirent[];
@@ -71,7 +85,9 @@ export function discoverFiles(rootDir: string): string[] {
         if (SKIP_DIRS.has(entry.name)) continue;
         // Skip hidden directories (except the root)
         if (entry.name.startsWith(".") && dir !== rootDir) continue;
-        walk(path.join(dir, entry.name));
+        const childDir = path.join(dir, entry.name);
+        if (isExcluded(childDir, normalizedExclusions)) continue;
+        walk(childDir);
       } else if (entry.isFile()) {
         const name = entry.name;
         if (SKIP_FILES.has(name)) continue;
@@ -240,11 +256,11 @@ export function resolveProjectImport(
 }
 
 export function createResolver(projectRoot: string, tsconfigPath: string): ResolverFactory {
+  const configFile = path.resolve(projectRoot, tsconfigPath);
   return new ResolverFactory({
-    tsconfig: {
-      configFile: path.resolve(projectRoot, tsconfigPath),
-      references: "auto",
-    },
+    ...(fs.existsSync(configFile)
+      ? { tsconfig: { configFile, references: "auto" as const } }
+      : {}),
     extensions: [".ts", ".tsx", ".mts", ".cts", ".js", ".jsx", ".mjs", ".cjs"],
     extensionAlias: {
       ".js": [".ts", ".tsx", ".js"],
@@ -328,12 +344,13 @@ function buildReverseMap(forward: Map<string, ImportEdge[]>): Map<string, Import
 
 export async function buildGraph(
   projectRoot: string,
-  tsconfigPath: string
+  tsconfigPath: string,
+  excludedPaths: string[] = []
 ): Promise<BuildGraphResult> {
   const startTime = performance.now();
 
   const resolver = createResolver(projectRoot, tsconfigPath);
-  const fileList = discoverFiles(projectRoot);
+  const fileList = discoverFiles(projectRoot, excludedPaths);
 
   log(`Discovered ${fileList.length} source files`);
 
@@ -464,9 +481,11 @@ export function startWatcher(
   hooks?: {
     onFileUpdated?: (filePath: string) => void | Promise<void>;
     onFileDeleted?: (filePath: string) => void | Promise<void>;
-  }
+  },
+  excludedPaths: string[] = []
 ): void {
   try {
+    const normalizedExclusions = normalizeExcludedPaths(projectRoot, excludedPaths);
     const watcher = fs.watch(
       projectRoot,
       { recursive: true },
@@ -489,6 +508,7 @@ export function startWatcher(
           return;
 
         const absPath = path.resolve(projectRoot, filename);
+        if (isExcluded(absPath, normalizedExclusions)) return;
 
         if (fs.existsSync(absPath)) {
           // File created or modified

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "typegraph-mcp",
-  "version": "0.9.46",
+  "version": "0.9.48",
   "description": "Type-aware codebase navigation for AI coding agents — 14 MCP tools powered by tsserver + oxc",
   "license": "MIT",
   "type": "module",
@@ -33,8 +33,9 @@
   ],
   "scripts": {
     "build": "tsup",
+    "setup:self": "tsx scripts/self-install.ts",
     "start": "tsx server.ts",
-    "test": "tsx smoke-test.ts && tsx export-surface-test.ts && tsx engine-sync-test.ts && tsx install-oxlint-test.ts",
+    "test": "tsx tests/smoke-test-selection-test.ts && tsx tests/biome-config-test.ts && tsx tests/self-install-test.ts && tsx tests/tsserver-resolution-test.ts && tsx tests/export-surface-test.ts && tsx tests/engine-sync-test.ts && tsx tests/install-oxlint-test.ts",
     "check": "tsx check.ts"
   },
   "dependencies": {
@@ -42,12 +43,12 @@
     "@modelcontextprotocol/sdk": "^1.26.0",
     "oxc-parser": "^0.114.0",
     "oxc-resolver": "^11.17.1",
+    "typescript": "^5.9.3",
     "zod": "^4.3.6"
   },
   "devDependencies": {
     "@types/node": "^25.3.0",
     "tsup": "^8.5.0",
-    "tsx": "^4.21.0",
-    "typescript": "^5.8.0"
+    "tsx": "^4.21.0"
   }
 }

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

@@ -13,7 +13,11 @@
 
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { TsServerClient, type NavBarItem } from "./tsserver-client.js";
+import {
+  TsServerClient,
+  type NavBarItem,
+  type QuickInfoResult,
+} from "./tsserver-client.js";
 import { buildGraph, type ModuleGraph } from "./module-graph.js";
 import {
   dependencyTree,
@@ -54,6 +58,81 @@ function findInNavBar(
   return null;
 }
 
+function symbolPositions(
+  symbol: NavBarItem,
+  sourceLines: string[]
+): Array<{ line: number; offset: number }> {
+  const span = symbol.spans[0]!;
+  const positions: Array<{ line: number; offset: number }> = [];
+  const lineText = sourceLines[span.start.line - 1];
+
+  if (lineText) {
+    const nameIndex = lineText.indexOf(symbol.text, Math.max(0, span.start.offset - 1));
+    if (nameIndex >= 0) {
+      positions.push({ line: span.start.line, offset: nameIndex + 1 });
+    }
+  }
+
+  if (!positions.some((position) => position.offset === span.start.offset)) {
+    positions.push(span.start);
+  }
+
+  return positions;
+}
+
+async function probeQuickInfo(
+  client: Pick<TsServerClient, "quickinfo">,
+  file: string,
+  symbol: NavBarItem,
+  sourceLines: string[]
+): Promise<{
+  info: QuickInfoResult;
+  position: { line: number; offset: number };
+} | null> {
+  for (const position of symbolPositions(symbol, sourceLines)) {
+    const info = await client.quickinfo(file, position.line, position.offset);
+    if (info) return { info, position };
+  }
+  return null;
+}
+
+export async function selectQuickInfoSymbol(
+  client: Pick<TsServerClient, "quickinfo">,
+  file: string,
+  symbols: NavBarItem[],
+  sourceLines: string[]
+): Promise<{
+  symbol: NavBarItem;
+  info: QuickInfoResult;
+  position: { line: number; offset: number };
+} | null> {
+  const kindPriority = new Map([
+    ["const", 0],
+    ["let", 1],
+    ["var", 2],
+    ["class", 3],
+    ["enum", 4],
+    ["function", 5],
+    ["method", 6],
+  ]);
+  const concreteSymbols = symbols
+    .map((symbol, index) => ({ symbol, index }))
+    .filter(({ symbol }) => kindPriority.has(symbol.kind))
+    .sort(
+      (a, b) =>
+        kindPriority.get(a.symbol.kind)! - kindPriority.get(b.symbol.kind)! ||
+        a.index - b.index
+    )
+    .map(({ symbol }) => symbol);
+
+  for (const symbol of concreteSymbols) {
+    const probe = await probeQuickInfo(client, file, symbol, sourceLines);
+    if (probe) return { symbol, ...probe };
+  }
+
+  return null;
+}
+
 const SKIP_DIRS = new Set([
   "node_modules",
   "dist",
@@ -65,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;
@@ -79,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"))
@@ -87,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 {
@@ -120,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;
@@ -152,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 };
@@ -171,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);
@@ -309,10 +397,21 @@ export async function main(configOverride?: TypegraphConfig): Promise<SmokeTestR
     fail("navbar", `No symbols found in ${testFileRel}`, navbarMs);
   }
 
-  // Prefer concrete symbols (const, function, class) — interfaces/types may not
-  // return quickinfo at their span start position (points to the keyword, not the name)
-  const concreteKinds = new Set(["const", "function", "class", "var", "let", "enum"]);
-  const sym = allSymbols.find((s) => concreteKinds.has(s.kind)) ?? allSymbols[0];
+  // Prefer a concrete symbol that quickinfo can actually resolve. Navbar may
+  // include synthetic entries such as "Alpine.data(...) callback" that are
+  // useful for navigation but do not correspond to a hoverable source token.
+  const source = fs.readFileSync(testFile, "utf-8");
+  const sourceLines = source.split(/\r?\n/);
+  const quickInfoSelection = await selectQuickInfoSymbol(
+    client,
+    testFileRel,
+    allSymbols,
+    sourceLines
+  );
+  const sym = quickInfoSelection?.symbol ?? allSymbols[0];
+  const selectedQuickInfo = quickInfoSelection?.info ?? null;
+  const selectedPosition = quickInfoSelection?.position ?? sym?.spans[0]?.start;
+
   if (!sym) {
     const toolNames = [
       "find_symbol",
@@ -327,6 +426,7 @@ export async function main(configOverride?: TypegraphConfig): Promise<SmokeTestR
     for (const name of toolNames) skip(name, "No symbol discovered");
   } else {
     const span = sym.spans[0]!;
+    const point = selectedPosition ?? span.start;
 
     // find_symbol
     t0 = performance.now();
@@ -343,7 +443,7 @@ export async function main(configOverride?: TypegraphConfig): Promise<SmokeTestR
 
     // definition
     t0 = performance.now();
-    const defs = await client.definition(testFileRel, span.start.line, span.start.offset);
+    const defs = await client.definition(testFileRel, point.line, point.offset);
     if (defs.length > 0) {
       const def = defs[0]!;
       pass("definition", `${sym.text} -> ${def.file}:${def.start.line}`, performance.now() - t0);
@@ -353,7 +453,7 @@ export async function main(configOverride?: TypegraphConfig): Promise<SmokeTestR
 
     // references
     t0 = performance.now();
-    const refs = await client.references(testFileRel, span.start.line, span.start.offset);
+    const refs = await client.references(testFileRel, point.line, point.offset);
     const refFiles = new Set(refs.map((r) => r.file));
     pass(
       "references",
@@ -363,7 +463,10 @@ export async function main(configOverride?: TypegraphConfig): Promise<SmokeTestR
 
     // type_info
     t0 = performance.now();
-    let info = await client.quickinfo(testFileRel, span.start.line, span.start.offset);
+    let info = selectedQuickInfo;
+    if (!info) {
+      info = await client.quickinfo(testFileRel, point.line, point.offset);
+    }
     // Span start may point to a keyword (class, function) — retry at the name position
     if (!info && defs.length > 0) {
       const def = defs[0]!;
@@ -376,7 +479,7 @@ export async function main(configOverride?: TypegraphConfig): Promise<SmokeTestR
           : info.displayString;
       pass("type_info", typeStr, performance.now() - t0);
     } else {
-      fail("type_info", `No type info for ${sym.text}`, performance.now() - t0);
+      skip("type_info", `No discovered symbol returned type info`);
     }
 
     // navigate_to
@@ -416,7 +519,6 @@ export async function main(configOverride?: TypegraphConfig): Promise<SmokeTestR
 
     // trace_chain — follow an import to its source
     t0 = performance.now();
-    const source = fs.readFileSync(testFile, "utf-8");
     const importMatch = source.match(/^import\s+\{([^}]+)\}\s+from\s+["']([^"']+)["']/m);
     if (importMatch) {
       const firstName = importMatch[1]!
@@ -488,4 +590,3 @@ export async function main(configOverride?: TypegraphConfig): Promise<SmokeTestR
 
   return { passed, failed, skipped };
 }
-

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]`);
   }