typegraph-mcp 0.9.46 → 0.9.48

package/dist/module-graph.js

@@ -18,8 +18,19 @@ var SKIP_DIRS = /* @__PURE__ */ new Set([
   "coverage"
 ]);
 var SKIP_FILES = /* @__PURE__ */ new Set(["routeTree.gen.ts"]);
-function discoverFiles(rootDir) {
+function normalizeExcludedPaths(rootDir, excludedPaths) {
+  return excludedPaths.map(
+    (excludedPath) => path.resolve(rootDir, excludedPath)
+  );
+}
+function isExcluded(filePath, excludedPaths) {
+  return excludedPaths.some(
+    (excludedPath) => filePath === excludedPath || filePath.startsWith(excludedPath + path.sep)
+  );
+}
+function discoverFiles(rootDir, excludedPaths = []) {
   const files = [];
+  const normalizedExclusions = normalizeExcludedPaths(rootDir, excludedPaths);
   function walk(dir) {
     let entries;
     try {
@@ -31,7 +42,9 @@ function discoverFiles(rootDir) {
       if (entry.isDirectory()) {
         if (SKIP_DIRS.has(entry.name)) continue;
         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;
@@ -132,11 +145,9 @@ function resolveProjectImport(resolver, fromDir, specifier, projectRoot) {
   return null;
 }
 function createResolver(projectRoot, tsconfigPath) {
+  const configFile = path.resolve(projectRoot, tsconfigPath);
   return new ResolverFactory({
-    tsconfig: {
-      configFile: path.resolve(projectRoot, tsconfigPath),
-      references: "auto"
-    },
+    ...fs.existsSync(configFile) ? { tsconfig: { configFile, references: "auto" } } : {},
     extensions: [".ts", ".tsx", ".mts", ".cts", ".js", ".jsx", ".mjs", ".cjs"],
     extensionAlias: {
       ".js": [".ts", ".tsx", ".js"],
@@ -202,10 +213,10 @@ function buildReverseMap(forward) {
   }
   return reverse;
 }
-async function buildGraph(projectRoot, tsconfigPath) {
+async function buildGraph(projectRoot, tsconfigPath, excludedPaths = []) {
   const startTime = performance.now();
   const resolver = createResolver(projectRoot, tsconfigPath);
-  const fileList = discoverFiles(projectRoot);
+  const fileList = discoverFiles(projectRoot, excludedPaths);
   log(`Discovered ${fileList.length} source files`);
   const { forward, parseFailures } = buildForwardEdges(fileList, resolver, projectRoot);
   const reverse = buildReverseMap(forward);
@@ -297,8 +308,9 @@ function removeFile(graph, filePath) {
   graph.reverse.delete(filePath);
   graph.files.delete(filePath);
 }
-function startWatcher(projectRoot, graph, resolver, hooks) {
+function startWatcher(projectRoot, graph, resolver, hooks, excludedPaths = []) {
   try {
+    const normalizedExclusions = normalizeExcludedPaths(projectRoot, excludedPaths);
     const watcher = fs.watch(
       projectRoot,
       { recursive: true },
@@ -312,6 +324,7 @@ function startWatcher(projectRoot, graph, resolver, hooks) {
         if (filename.endsWith(".d.ts") || filename.endsWith(".d.mts") || filename.endsWith(".d.cts"))
           return;
         const absPath = path.resolve(projectRoot, filename);
+        if (isExcluded(absPath, normalizedExclusions)) return;
         if (fs.existsSync(absPath)) {
           updateFile(graph, absPath, resolver, projectRoot);
           void hooks?.onFileUpdated?.(absPath);

package/dist/server.js

@@ -12,6 +12,30 @@ import * as fs from "fs";
 import { createRequire } from "module";
 var log = (...args) => console.error("[typegraph/tsserver]", ...args);
 var REQUEST_TIMEOUT_MS = 1e4;
+function readPackageVersion(packagePath) {
+  const pkg = JSON.parse(fs.readFileSync(packagePath, "utf-8"));
+  return pkg.version ?? "unknown";
+}
+function resolveTsServer(projectRoot2) {
+  const projectRequire = createRequire(path.resolve(projectRoot2, "package.json"));
+  let projectVersion;
+  try {
+    const packagePath2 = projectRequire.resolve("typescript/package.json");
+    projectVersion = readPackageVersion(packagePath2);
+    const serverPath2 = projectRequire.resolve("typescript/lib/tsserver.js");
+    return { path: serverPath2, version: projectVersion, source: "project" };
+  } catch {
+  }
+  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
+  };
+}
 var TsServerClient = class {
   constructor(projectRoot2, tsconfigPath2 = "./tsconfig.json") {
     this.projectRoot = projectRoot2;
@@ -48,9 +72,12 @@ var TsServerClient = class {
   // ─── Lifecycle ──────────────────────────────────────────────────────────
   async start() {
     if (this.child) return;
-    const require2 = createRequire(path.resolve(this.projectRoot, "package.json"));
-    const tsserverPath = require2.resolve("typescript/lib/tsserver.js");
-    log(`Spawning tsserver: ${tsserverPath}`);
+    const resolution = resolveTsServer(this.projectRoot);
+    const tsserverPath = resolution.path;
+    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}`);
     this.child = spawn("node", [tsserverPath, "--disableAutomaticTypingAcquisition"], {
@@ -79,12 +106,9 @@ var TsServerClient = class {
       }
     });
     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]`);
   }
@@ -328,8 +352,19 @@ var SKIP_DIRS = /* @__PURE__ */ new Set([
   "coverage"
 ]);
 var SKIP_FILES = /* @__PURE__ */ new Set(["routeTree.gen.ts"]);
-function discoverFiles(rootDir) {
+function normalizeExcludedPaths(rootDir, excludedPaths2) {
+  return excludedPaths2.map(
+    (excludedPath) => path2.resolve(rootDir, excludedPath)
+  );
+}
+function isExcluded(filePath, excludedPaths2) {
+  return excludedPaths2.some(
+    (excludedPath) => filePath === excludedPath || filePath.startsWith(excludedPath + path2.sep)
+  );
+}
+function discoverFiles(rootDir, excludedPaths2 = []) {
   const files = [];
+  const normalizedExclusions = normalizeExcludedPaths(rootDir, excludedPaths2);
   function walk(dir) {
     let entries;
     try {
@@ -341,7 +376,9 @@ function discoverFiles(rootDir) {
       if (entry.isDirectory()) {
         if (SKIP_DIRS.has(entry.name)) continue;
         if (entry.name.startsWith(".") && dir !== rootDir) continue;
-        walk(path2.join(dir, entry.name));
+        const childDir = path2.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;
@@ -442,11 +479,9 @@ function resolveProjectImport(resolver, fromDir, specifier, projectRoot2) {
   return null;
 }
 function createResolver(projectRoot2, tsconfigPath2) {
+  const configFile = path2.resolve(projectRoot2, tsconfigPath2);
   return new ResolverFactory({
-    tsconfig: {
-      configFile: path2.resolve(projectRoot2, tsconfigPath2),
-      references: "auto"
-    },
+    ...fs2.existsSync(configFile) ? { tsconfig: { configFile, references: "auto" } } : {},
     extensions: [".ts", ".tsx", ".mts", ".cts", ".js", ".jsx", ".mjs", ".cjs"],
     extensionAlias: {
       ".js": [".ts", ".tsx", ".js"],
@@ -512,10 +547,10 @@ function buildReverseMap(forward) {
   }
   return reverse;
 }
-async function buildGraph(projectRoot2, tsconfigPath2) {
+async function buildGraph(projectRoot2, tsconfigPath2, excludedPaths2 = []) {
   const startTime = performance.now();
   const resolver = createResolver(projectRoot2, tsconfigPath2);
-  const fileList = discoverFiles(projectRoot2);
+  const fileList = discoverFiles(projectRoot2, excludedPaths2);
   log2(`Discovered ${fileList.length} source files`);
   const { forward, parseFailures } = buildForwardEdges(fileList, resolver, projectRoot2);
   const reverse = buildReverseMap(forward);
@@ -607,8 +642,9 @@ function removeFile(graph, filePath) {
   graph.reverse.delete(filePath);
   graph.files.delete(filePath);
 }
-function startWatcher(projectRoot2, graph, resolver, hooks) {
+function startWatcher(projectRoot2, graph, resolver, hooks, excludedPaths2 = []) {
   try {
+    const normalizedExclusions = normalizeExcludedPaths(projectRoot2, excludedPaths2);
     const watcher = fs2.watch(
       projectRoot2,
       { recursive: true },
@@ -622,6 +658,7 @@ function startWatcher(projectRoot2, graph, resolver, hooks) {
         if (filename.endsWith(".d.ts") || filename.endsWith(".d.mts") || filename.endsWith(".d.cts"))
           return;
         const absPath2 = path2.resolve(projectRoot2, filename);
+        if (isExcluded(absPath2, normalizedExclusions)) return;
         if (fs2.existsSync(absPath2)) {
           updateFile(graph, absPath2, resolver, projectRoot2);
           void hooks?.onFileUpdated?.(absPath2);
@@ -917,17 +954,18 @@ import * as path5 from "path";
 
 // config.ts
 import * as path4 from "path";
-function resolveConfig(toolDir) {
+function resolveConfig(toolDir2) {
   const cwd = process.cwd();
-  const projectRoot2 = process.env["TYPEGRAPH_PROJECT_ROOT"] ? path4.resolve(cwd, process.env["TYPEGRAPH_PROJECT_ROOT"]) : path4.basename(path4.dirname(toolDir)) === "plugins" ? path4.resolve(toolDir, "../..") : cwd;
+  const projectRoot2 = process.env["TYPEGRAPH_PROJECT_ROOT"] ? path4.resolve(cwd, process.env["TYPEGRAPH_PROJECT_ROOT"]) : path4.basename(path4.dirname(toolDir2)) === "plugins" ? path4.resolve(toolDir2, "../..") : cwd;
   const tsconfigPath2 = process.env["TYPEGRAPH_TSCONFIG"] || "./tsconfig.json";
-  const toolIsEmbedded = toolDir.startsWith(projectRoot2 + path4.sep);
-  const toolRelPath = toolIsEmbedded ? path4.relative(projectRoot2, toolDir) : toolDir;
-  return { projectRoot: projectRoot2, tsconfigPath: tsconfigPath2, toolDir, toolIsEmbedded, toolRelPath };
+  const toolIsEmbedded2 = toolDir2.startsWith(projectRoot2 + path4.sep);
+  const toolRelPath = toolIsEmbedded2 ? path4.relative(projectRoot2, toolDir2) : toolDir2;
+  return { projectRoot: projectRoot2, tsconfigPath: tsconfigPath2, toolDir: toolDir2, toolIsEmbedded: toolIsEmbedded2, toolRelPath };
 }
 
 // server.ts
-var { projectRoot, tsconfigPath } = resolveConfig(import.meta.dirname);
+var { projectRoot, tsconfigPath, toolDir, toolIsEmbedded } = resolveConfig(import.meta.dirname);
+var excludedPaths = toolIsEmbedded ? [toolDir] : [];
 var log3 = (...args) => console.error("[typegraph]", ...args);
 var client = new TsServerClient(projectRoot, tsconfigPath);
 var moduleGraph;
@@ -1714,25 +1752,31 @@ async function main() {
   log3(`tsconfig: ${tsconfigPath}`);
   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) => {
-        if (!wasOpen) client.markProjectsDirty();
-      },
-      (err) => {
+  startWatcher(
+    projectRoot,
+    moduleGraph,
+    graphResult.resolver,
+    {
+      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();
-        log3(`Failed to reload open file ${relPath(filePath)}:`, err);
       }
-    ),
-    onFileDeleted: (filePath) => {
-      client.closeFile(filePath);
-      client.markProjectsDirty();
-    }
-  });
+    },
+    excludedPaths
+  );
   const transport = new StdioServerTransport();
   await mcpServer.connect(transport);
   log3("MCP server connected and ready");

package/dist/smoke-test.js

@@ -10,6 +10,30 @@ import * as fs from "fs";
 import { createRequire } from "module";
 var log = (...args) => console.error("[typegraph/tsserver]", ...args);
 var REQUEST_TIMEOUT_MS = 1e4;
+function readPackageVersion(packagePath) {
+  const pkg = JSON.parse(fs.readFileSync(packagePath, "utf-8"));
+  return pkg.version ?? "unknown";
+}
+function resolveTsServer(projectRoot) {
+  const projectRequire = createRequire(path.resolve(projectRoot, "package.json"));
+  let projectVersion;
+  try {
+    const packagePath2 = projectRequire.resolve("typescript/package.json");
+    projectVersion = readPackageVersion(packagePath2);
+    const serverPath2 = projectRequire.resolve("typescript/lib/tsserver.js");
+    return { path: serverPath2, version: projectVersion, source: "project" };
+  } catch {
+  }
+  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
+  };
+}
 var TsServerClient = class {
   constructor(projectRoot, tsconfigPath = "./tsconfig.json") {
     this.projectRoot = projectRoot;
@@ -46,9 +70,12 @@ var TsServerClient = class {
   // ─── Lifecycle ──────────────────────────────────────────────────────────
   async start() {
     if (this.child) return;
-    const require2 = createRequire(path.resolve(this.projectRoot, "package.json"));
-    const tsserverPath = require2.resolve("typescript/lib/tsserver.js");
-    log(`Spawning tsserver: ${tsserverPath}`);
+    const resolution = resolveTsServer(this.projectRoot);
+    const tsserverPath = resolution.path;
+    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}`);
     this.child = spawn("node", [tsserverPath, "--disableAutomaticTypingAcquisition"], {
@@ -77,12 +104,9 @@ var TsServerClient = class {
       }
     });
     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]`);
   }
@@ -177,12 +201,12 @@ var TsServerClient = class {
       command,
       arguments: args
     };
-    return new Promise((resolve5, reject) => {
+    return new Promise((resolve6, reject) => {
       const timer = setTimeout(() => {
         this.pending.delete(seq);
         reject(new Error(`tsserver ${command} timed out after ${REQUEST_TIMEOUT_MS}ms`));
       }, REQUEST_TIMEOUT_MS);
-      this.pending.set(seq, { resolve: resolve5, reject, timer, command });
+      this.pending.set(seq, { resolve: resolve6, reject, timer, command });
       this.child.stdin.write(JSON.stringify(request) + "\n");
     });
   }
@@ -326,8 +350,19 @@ var SKIP_DIRS = /* @__PURE__ */ new Set([
   "coverage"
 ]);
 var SKIP_FILES = /* @__PURE__ */ new Set(["routeTree.gen.ts"]);
-function discoverFiles(rootDir) {
+function normalizeExcludedPaths(rootDir, excludedPaths) {
+  return excludedPaths.map(
+    (excludedPath) => path2.resolve(rootDir, excludedPath)
+  );
+}
+function isExcluded(filePath, excludedPaths) {
+  return excludedPaths.some(
+    (excludedPath) => filePath === excludedPath || filePath.startsWith(excludedPath + path2.sep)
+  );
+}
+function discoverFiles(rootDir, excludedPaths = []) {
   const files = [];
+  const normalizedExclusions = normalizeExcludedPaths(rootDir, excludedPaths);
   function walk(dir) {
     let entries;
     try {
@@ -339,7 +374,9 @@ function discoverFiles(rootDir) {
       if (entry.isDirectory()) {
         if (SKIP_DIRS.has(entry.name)) continue;
         if (entry.name.startsWith(".") && dir !== rootDir) continue;
-        walk(path2.join(dir, entry.name));
+        const childDir = path2.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;
@@ -440,11 +477,9 @@ function resolveProjectImport(resolver, fromDir, specifier, projectRoot) {
   return null;
 }
 function createResolver(projectRoot, tsconfigPath) {
+  const configFile = path2.resolve(projectRoot, tsconfigPath);
   return new ResolverFactory({
-    tsconfig: {
-      configFile: path2.resolve(projectRoot, tsconfigPath),
-      references: "auto"
-    },
+    ...fs2.existsSync(configFile) ? { tsconfig: { configFile, references: "auto" } } : {},
     extensions: [".ts", ".tsx", ".mts", ".cts", ".js", ".jsx", ".mjs", ".cjs"],
     extensionAlias: {
       ".js": [".ts", ".tsx", ".js"],
@@ -510,10 +545,10 @@ function buildReverseMap(forward) {
   }
   return reverse;
 }
-async function buildGraph(projectRoot, tsconfigPath) {
+async function buildGraph(projectRoot, tsconfigPath, excludedPaths = []) {
   const startTime = performance.now();
   const resolver = createResolver(projectRoot, tsconfigPath);
-  const fileList = discoverFiles(projectRoot);
+  const fileList = discoverFiles(projectRoot, excludedPaths);
   log2(`Discovered ${fileList.length} source files`);
   const { forward, parseFailures } = buildForwardEdges(fileList, resolver, projectRoot);
   const reverse = buildReverseMap(forward);
@@ -827,6 +862,47 @@ function findInNavBar(items, predicate) {
   }
   return null;
 }
+function symbolPositions(symbol, sourceLines) {
+  const span = symbol.spans[0];
+  const positions = [];
+  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, file, symbol, sourceLines) {
+  for (const position of symbolPositions(symbol, sourceLines)) {
+    const info = await client.quickinfo(file, position.line, position.offset);
+    if (info) return { info, position };
+  }
+  return null;
+}
+async function selectQuickInfoSymbol(client, file, symbols, sourceLines) {
+  const kindPriority = /* @__PURE__ */ 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;
+}
 var SKIP_DIRS2 = /* @__PURE__ */ new Set([
   "node_modules",
   "dist",
@@ -836,8 +912,9 @@ var SKIP_DIRS2 = /* @__PURE__ */ new Set([
   "coverage",
   "out"
 ]);
-function findTestFile(rootDir) {
+function findTestFile(rootDir, excludedPaths = []) {
   const candidates = [];
+  const normalizedExclusions = excludedPaths.map((excludedPath) => path5.resolve(excludedPath));
   function walk(dir, depth) {
     if (depth > 5 || candidates.length >= 30) return;
     let entries;
@@ -849,7 +926,11 @@ function findTestFile(rootDir) {
     for (const entry of entries) {
       if (entry.isDirectory()) {
         if (SKIP_DIRS2.has(entry.name) || entry.name.startsWith(".")) continue;
-        walk(path5.join(dir, entry.name), depth + 1);
+        const childDir = path5.join(dir, entry.name);
+        if (normalizedExclusions.some(
+          (excludedPath) => childDir === excludedPath || childDir.startsWith(excludedPath + path5.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"))
@@ -857,7 +938,7 @@ function findTestFile(rootDir) {
         if (!name.endsWith(".ts") && !name.endsWith(".tsx")) continue;
         try {
           const stat = fs4.statSync(path5.join(dir, name));
-          if (stat.size > 200 && stat.size < 5e4) {
+          if (stat.size > 0 && stat.size < 5e4) {
             candidates.push({ file: path5.join(dir, name), size: stat.size });
           }
         } catch {
@@ -881,7 +962,8 @@ function findImporter(graph, file) {
   return (preferred ?? revEdges[0]).target;
 }
 async function main(configOverride) {
-  const { projectRoot, tsconfigPath } = configOverride ?? resolveConfig(import.meta.dirname);
+  const { projectRoot, tsconfigPath, toolDir, toolIsEmbedded } = configOverride ?? resolveConfig(import.meta.dirname);
+  const excludedPaths = toolIsEmbedded ? [toolDir] : [];
   let passed = 0;
   let failed = 0;
   let skipped = 0;
@@ -904,7 +986,7 @@ async function main(configOverride) {
   console.log("=====================");
   console.log(`Project root: ${projectRoot}`);
   console.log("");
-  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 };
@@ -917,7 +999,7 @@ async function main(configOverride) {
   let t0;
   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);
@@ -1034,8 +1116,17 @@ async function main(configOverride) {
   } else {
     fail("navbar", `No symbols found in ${testFileRel}`, navbarMs);
   }
-  const concreteKinds = /* @__PURE__ */ new Set(["const", "function", "class", "var", "let", "enum"]);
-  const sym = allSymbols.find((s) => concreteKinds.has(s.kind)) ?? allSymbols[0];
+  const source = fs4.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",
@@ -1050,6 +1141,7 @@ async function main(configOverride) {
     for (const name of toolNames) skip(name, "No symbol discovered");
   } else {
     const span = sym.spans[0];
+    const point = selectedPosition ?? span.start;
     t0 = performance.now();
     const found = findInNavBar(bar, (item) => item.text === sym.text && item.kind === sym.kind);
     if (found && found.spans.length > 0) {
@@ -1062,7 +1154,7 @@ async function main(configOverride) {
       fail("find_symbol", `Could not re-find ${sym.text}`, performance.now() - t0);
     }
     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);
@@ -1070,7 +1162,7 @@ async function main(configOverride) {
       pass("definition", `${sym.text} is its own definition`, performance.now() - t0);
     }
     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",
@@ -1078,7 +1170,10 @@ async function main(configOverride) {
       performance.now() - t0
     );
     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);
+    }
     if (!info && defs.length > 0) {
       const def = defs[0];
       info = await client.quickinfo(testFileRel, def.start.line, def.start.offset);
@@ -1087,7 +1182,7 @@ async function main(configOverride) {
       const typeStr = info.displayString.length > 80 ? info.displayString.slice(0, 80) + "..." : 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`);
     }
     t0 = performance.now();
     const navItems = await client.navto(sym.text, 5);
@@ -1119,7 +1214,6 @@ async function main(configOverride) {
     const exportSymbols = topItems.filter((item) => symbolKinds.has(item.kind));
     pass("module_exports", `${exportSymbols.length} top-level symbol(s)`, performance.now() - t0);
     t0 = performance.now();
-    const source = fs4.readFileSync(testFile, "utf-8");
     const importMatch = source.match(/^import\s+\{([^}]+)\}\s+from\s+["']([^"']+)["']/m);
     if (importMatch) {
       const firstName = importMatch[1].split(",")[0].replace(/^type\s+/, "").trim();
@@ -1180,5 +1274,6 @@ async function main(configOverride) {
   return { passed, failed, skipped };
 }
 export {
-  main
+  main,
+  selectQuickInfoSymbol
 };

package/dist/tsserver-client.js

@@ -5,6 +5,30 @@ import * as fs from "fs";
 import { createRequire } from "module";
 var log = (...args) => console.error("[typegraph/tsserver]", ...args);
 var REQUEST_TIMEOUT_MS = 1e4;
+function readPackageVersion(packagePath) {
+  const pkg = JSON.parse(fs.readFileSync(packagePath, "utf-8"));
+  return pkg.version ?? "unknown";
+}
+function resolveTsServer(projectRoot) {
+  const projectRequire = createRequire(path.resolve(projectRoot, "package.json"));
+  let projectVersion;
+  try {
+    const packagePath2 = projectRequire.resolve("typescript/package.json");
+    projectVersion = readPackageVersion(packagePath2);
+    const serverPath2 = projectRequire.resolve("typescript/lib/tsserver.js");
+    return { path: serverPath2, version: projectVersion, source: "project" };
+  } catch {
+  }
+  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
+  };
+}
 var TsServerClient = class {
   constructor(projectRoot, tsconfigPath = "./tsconfig.json") {
     this.projectRoot = projectRoot;
@@ -41,9 +65,12 @@ var TsServerClient = class {
   // ─── Lifecycle ──────────────────────────────────────────────────────────
   async start() {
     if (this.child) return;
-    const require2 = createRequire(path.resolve(this.projectRoot, "package.json"));
-    const tsserverPath = require2.resolve("typescript/lib/tsserver.js");
-    log(`Spawning tsserver: ${tsserverPath}`);
+    const resolution = resolveTsServer(this.projectRoot);
+    const tsserverPath = resolution.path;
+    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}`);
     this.child = spawn("node", [tsserverPath, "--disableAutomaticTypingAcquisition"], {
@@ -72,12 +99,9 @@ var TsServerClient = class {
       }
     });
     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]`);
   }
@@ -301,5 +325,6 @@ var TsServerClient = class {
   }
 };
 export {
-  TsServerClient
+  TsServerClient,
+  resolveTsServer
 };