typegraph-mcp 0.9.47 → 0.9.48

package/dist/check.js

@@ -21,14 +21,25 @@ __export(module_graph_exports, {
 });
 import { parseSync } from "oxc-parser";
 import { ResolverFactory } from "oxc-resolver";
-import * as fs from "fs";
-import * as path2 from "path";
-function discoverFiles(rootDir) {
+import * as fs2 from "fs";
+import * as path3 from "path";
+function normalizeExcludedPaths(rootDir, excludedPaths) {
+  return excludedPaths.map(
+    (excludedPath) => path3.resolve(rootDir, excludedPath)
+  );
+}
+function isExcluded(filePath, excludedPaths) {
+  return excludedPaths.some(
+    (excludedPath) => filePath === excludedPath || filePath.startsWith(excludedPath + path3.sep)
+  );
+}
+function discoverFiles(rootDir, excludedPaths = []) {
   const files = [];
+  const normalizedExclusions = normalizeExcludedPaths(rootDir, excludedPaths);
   function walk(dir) {
     let entries;
     try {
-      entries = fs.readdirSync(dir, { withFileTypes: true });
+      entries = fs2.readdirSync(dir, { withFileTypes: true });
     } catch {
       return;
     }
@@ -36,14 +47,16 @@ 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 = path3.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;
         if (name.endsWith(".d.ts") || name.endsWith(".d.mts") || name.endsWith(".d.cts")) continue;
-        const ext = path2.extname(name);
+        const ext = path3.extname(name);
         if (TS_EXTENSIONS.has(ext)) {
-          files.push(path2.join(dir, name));
+          files.push(path3.join(dir, name));
         }
       }
     }
@@ -98,25 +111,25 @@ function parseFileImports(filePath, source) {
 }
 function distToSource(resolvedPath, projectRoot) {
   if (!resolvedPath.startsWith(projectRoot)) return resolvedPath;
-  const rel = path2.relative(projectRoot, resolvedPath);
-  const distIdx = rel.indexOf("dist" + path2.sep);
+  const rel = path3.relative(projectRoot, resolvedPath);
+  const distIdx = rel.indexOf("dist" + path3.sep);
   if (distIdx === -1) return resolvedPath;
   const prefix = rel.slice(0, distIdx);
   const afterDist = rel.slice(distIdx + 5);
   const withoutExt = afterDist.replace(/\.(m?j|c)s$/, "");
   for (const ext of SOURCE_EXTS) {
-    const candidate = path2.resolve(projectRoot, prefix, "src", withoutExt + ext);
-    if (fs.existsSync(candidate)) return candidate;
+    const candidate = path3.resolve(projectRoot, prefix, "src", withoutExt + ext);
+    if (fs2.existsSync(candidate)) return candidate;
   }
   for (const ext of SOURCE_EXTS) {
-    const candidate = path2.resolve(projectRoot, prefix, withoutExt + ext);
-    if (fs.existsSync(candidate)) return candidate;
+    const candidate = path3.resolve(projectRoot, prefix, withoutExt + ext);
+    if (fs2.existsSync(candidate)) return candidate;
   }
   if (withoutExt.endsWith("/index")) {
     const dirPath = withoutExt.slice(0, -6);
     for (const ext of SOURCE_EXTS) {
-      const candidate = path2.resolve(projectRoot, prefix, "src", dirPath + ext);
-      if (fs.existsSync(candidate)) return candidate;
+      const candidate = path3.resolve(projectRoot, prefix, "src", dirPath + ext);
+      if (fs2.existsSync(candidate)) return candidate;
     }
   }
   return resolvedPath;
@@ -126,9 +139,9 @@ function resolveProjectImport(resolver, fromDir, specifier, projectRoot) {
     const result = resolver.sync(fromDir, specifier);
     if (result.path && !result.path.includes("node_modules")) {
       const mapped = distToSource(result.path, projectRoot);
-      const ext = path2.extname(mapped);
+      const ext = path3.extname(mapped);
       if (!TS_EXTENSIONS.has(ext)) return null;
-      if (SKIP_FILES.has(path2.basename(mapped))) return null;
+      if (SKIP_FILES.has(path3.basename(mapped))) return null;
       return mapped;
     }
   } catch {
@@ -136,11 +149,9 @@ function resolveProjectImport(resolver, fromDir, specifier, projectRoot) {
   return null;
 }
 function createResolver(projectRoot, tsconfigPath) {
+  const configFile = path3.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"],
@@ -158,7 +169,7 @@ function buildForwardEdges(files, resolver, projectRoot) {
   for (const filePath of files) {
     let source;
     try {
-      source = fs.readFileSync(filePath, "utf-8");
+      source = fs2.readFileSync(filePath, "utf-8");
     } catch {
       continue;
     }
@@ -170,7 +181,7 @@ function buildForwardEdges(files, resolver, projectRoot) {
       continue;
     }
     const edges = [];
-    const fromDir = path2.dirname(filePath);
+    const fromDir = path3.dirname(filePath);
     for (const raw of rawImports) {
       const target = resolveProjectImport(resolver, fromDir, raw.specifier, projectRoot);
       if (target) {
@@ -206,10 +217,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);
@@ -237,7 +248,7 @@ function updateFile(graph, filePath, resolver, projectRoot) {
   }
   let source;
   try {
-    source = fs.readFileSync(filePath, "utf-8");
+    source = fs2.readFileSync(filePath, "utf-8");
   } catch {
     removeFile(graph, filePath);
     return;
@@ -250,7 +261,7 @@ function updateFile(graph, filePath, resolver, projectRoot) {
     graph.forward.set(filePath, []);
     return;
   }
-  const fromDir = path2.dirname(filePath);
+  const fromDir = path3.dirname(filePath);
   const newEdges = [];
   for (const raw of rawImports) {
     const target = resolveProjectImport(resolver, fromDir, raw.specifier, projectRoot);
@@ -301,22 +312,24 @@ 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 watcher = fs.watch(
+    const normalizedExclusions = normalizeExcludedPaths(projectRoot, excludedPaths);
+    const watcher = fs2.watch(
       projectRoot,
       { recursive: true },
       (_eventType, filename) => {
         if (!filename) return;
-        const ext = path2.extname(filename);
+        const ext = path3.extname(filename);
         if (!TS_EXTENSIONS.has(ext)) return;
-        const parts = filename.split(path2.sep);
+        const parts = filename.split(path3.sep);
         if (parts.some((p) => SKIP_DIRS.has(p))) return;
-        if (SKIP_FILES.has(path2.basename(filename))) return;
+        if (SKIP_FILES.has(path3.basename(filename))) return;
         if (filename.endsWith(".d.ts") || filename.endsWith(".d.mts") || filename.endsWith(".d.cts"))
           return;
-        const absPath = path2.resolve(projectRoot, filename);
-        if (fs.existsSync(absPath)) {
+        const absPath = path3.resolve(projectRoot, filename);
+        if (isExcluded(absPath, normalizedExclusions)) return;
+        if (fs2.existsSync(absPath)) {
           updateFile(graph, absPath, resolver, projectRoot);
           void hooks?.onFileUpdated?.(absPath);
         } else {
@@ -355,10 +368,10 @@ var init_module_graph = __esm({
 });
 
 // check.ts
-import * as fs2 from "fs";
-import * as path3 from "path";
-import { createRequire } from "module";
-import { spawn, spawnSync } from "child_process";
+import * as fs3 from "fs";
+import * as path4 from "path";
+import { createRequire as createRequire2 } from "module";
+import { spawn as spawn2, spawnSync } from "child_process";
 
 // config.ts
 import * as path from "path";
@@ -371,18 +384,84 @@ function resolveConfig(toolDir) {
   return { projectRoot, tsconfigPath, toolDir, toolIsEmbedded, toolRelPath };
 }
 
+// tsserver-client.ts
+import { spawn } from "child_process";
+import * as path2 from "path";
+import * as fs from "fs";
+import { createRequire } from "module";
+function readPackageVersion(packagePath) {
+  const pkg = JSON.parse(fs.readFileSync(packagePath, "utf-8"));
+  return pkg.version ?? "unknown";
+}
+function resolveTsServer(projectRoot) {
+  const projectRequire = createRequire(path2.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
+  };
+}
+
+// biome-config.ts
+var BIOME_CONFIG_NAMES = [
+  "biome.json",
+  "biome.jsonc",
+  ".biome.json",
+  ".biome.jsonc"
+];
+function filesObjectMatch(raw) {
+  return raw.match(/(["']files["']\s*:\s*\{)([\s\S]*?)(\n?\s*\})/);
+}
+function filesIncludes(raw) {
+  const filesObject = filesObjectMatch(raw);
+  if (!filesObject) return null;
+  const includes = filesObject[2].match(/["']includes["']\s*:\s*\[([\s\S]*?)\]/);
+  if (!includes) return null;
+  return [...includes[1].matchAll(/["']([^"']+)["']/g)].map((match) => match[1]);
+}
+function biomeScopeExcludes(raw, parentDir) {
+  const escaped = parentDir.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const explicitIgnore = new RegExp(
+    `["']!{1,2}(?:\\*\\*/)?${escaped}(?:/\\*\\*)?["']`
+  );
+  if (explicitIgnore.test(raw)) return true;
+  const includes = filesIncludes(raw);
+  if (!includes) return false;
+  const positivePatterns = includes.filter((pattern) => !pattern.startsWith("!"));
+  return !positivePatterns.some((pattern) => {
+    const normalized = pattern.replace(/^\.\//, "");
+    return normalized === "*" || normalized === "**" || normalized.startsWith("**/") || normalized.startsWith("*/") || normalized === parentDir || normalized.startsWith(`${parentDir}/`);
+  });
+}
+
 // check.ts
-function findFirstTsFile(dir) {
+function findFirstTsFile(dir, excludedPaths = []) {
   const skipDirs = /* @__PURE__ */ new Set(["node_modules", "dist", ".git", ".wrangler", "coverage"]);
   try {
-    for (const entry of fs2.readdirSync(dir, { withFileTypes: true })) {
+    for (const entry of fs3.readdirSync(dir, { withFileTypes: true })) {
       if (entry.isFile() && entry.name.endsWith(".ts") && !entry.name.endsWith(".d.ts")) {
-        return path3.join(dir, entry.name);
+        return path4.join(dir, entry.name);
       }
     }
-    for (const entry of fs2.readdirSync(dir, { withFileTypes: true })) {
+    for (const entry of fs3.readdirSync(dir, { withFileTypes: true })) {
       if (entry.isDirectory() && !skipDirs.has(entry.name) && !entry.name.startsWith(".")) {
-        const found = findFirstTsFile(path3.join(dir, entry.name));
+        const childDir = path4.join(dir, entry.name);
+        if (excludedPaths.some(
+          (excludedPath) => childDir === excludedPath || childDir.startsWith(excludedPath + path4.sep)
+        )) continue;
+        const found = findFirstTsFile(childDir, excludedPaths);
         if (found) return found;
       }
     }
@@ -390,23 +469,15 @@ function findFirstTsFile(dir) {
   }
   return null;
 }
-function testTsserver(projectRoot) {
-  return new Promise((resolve4) => {
-    let tsserverPath;
-    try {
-      const require2 = createRequire(path3.resolve(projectRoot, "package.json"));
-      tsserverPath = require2.resolve("typescript/lib/tsserver.js");
-    } catch {
-      resolve4(false);
-      return;
-    }
-    const child = spawn("node", [tsserverPath, "--disableAutomaticTypingAcquisition"], {
+function testTsserver(projectRoot, resolution) {
+  return new Promise((resolve5) => {
+    const child = spawn2("node", [resolution.path, "--disableAutomaticTypingAcquisition"], {
       cwd: projectRoot,
       stdio: ["pipe", "pipe", "pipe"]
     });
     const timeout = setTimeout(() => {
       child.kill();
-      resolve4(false);
+      resolve5(false);
     }, 1e4);
     let buffer = "";
     child.stdout.on("data", (chunk) => {
@@ -414,12 +485,12 @@ function testTsserver(projectRoot) {
       if (buffer.includes('"success":true')) {
         clearTimeout(timeout);
         child.kill();
-        resolve4(true);
+        resolve5(true);
       }
     });
     child.on("error", () => {
       clearTimeout(timeout);
-      resolve4(false);
+      resolve5(false);
     });
     child.on("exit", () => {
       clearTimeout(timeout);
@@ -436,9 +507,9 @@ function testTsserver(projectRoot) {
   });
 }
 function readProjectCodexConfig(projectRoot) {
-  const configPath = path3.resolve(projectRoot, ".codex/config.toml");
-  if (!fs2.existsSync(configPath)) return null;
-  return fs2.readFileSync(configPath, "utf-8");
+  const configPath = path4.resolve(projectRoot, ".codex/config.toml");
+  if (!fs3.existsSync(configPath)) return null;
+  return fs3.readFileSync(configPath, "utf-8");
 }
 function hasCodexTypegraphRegistration(content) {
   return /\[mcp_servers\.typegraph\]/.test(content);
@@ -452,17 +523,17 @@ function hasCompleteCodexTypegraphRegistration(content) {
 function hasTrustedCodexProject(projectRoot) {
   const home = process.env.HOME;
   if (!home) return null;
-  const globalConfigPath = path3.join(home, ".codex/config.toml");
-  if (!fs2.existsSync(globalConfigPath)) return null;
-  const lines = fs2.readFileSync(globalConfigPath, "utf-8").split(/\r?\n/);
+  const globalConfigPath = path4.join(home, ".codex/config.toml");
+  if (!fs3.existsSync(globalConfigPath)) return null;
+  const lines = fs3.readFileSync(globalConfigPath, "utf-8").split(/\r?\n/);
   let currentProject = null;
   let currentTrusted = false;
-  const matchesTrustedProject = () => currentProject !== null && currentTrusted && (projectRoot === currentProject || projectRoot.startsWith(currentProject + path3.sep));
+  const matchesTrustedProject = () => currentProject !== null && currentTrusted && (projectRoot === currentProject || projectRoot.startsWith(currentProject + path4.sep));
   for (const line of lines) {
     const sectionMatch = line.match(/^\[projects\."([^"]+)"\]\s*$/);
     if (sectionMatch) {
       if (matchesTrustedProject()) return true;
-      currentProject = path3.resolve(sectionMatch[1]);
+      currentProject = path4.resolve(sectionMatch[1]);
       currentTrusted = false;
       continue;
     }
@@ -492,9 +563,9 @@ function hasCompleteJsonTypegraphRegistration(config, serverName, projectRoot) {
   return typeof command === "string" && command.length > 0 && Array.isArray(args) && serializedArgs.includes("server.ts") && serializedArgs.includes("tsx") && typeof env === "object" && env !== null && env["TYPEGRAPH_PROJECT_ROOT"] === projectRoot && typeof env["TYPEGRAPH_TSCONFIG"] === "string";
 }
 function readJsonConfig(configPath) {
-  if (!fs2.existsSync(configPath)) return null;
+  if (!fs3.existsSync(configPath)) return null;
   try {
-    return JSON.parse(fs2.readFileSync(configPath, "utf-8"));
+    return JSON.parse(fs3.readFileSync(configPath, "utf-8"));
   } catch {
     return null;
   }
@@ -502,8 +573,8 @@ function readJsonConfig(configPath) {
 function getAntigravityMcpConfigPaths() {
   const home = process.env.HOME || "";
   return [
-    path3.join(home, ".gemini/antigravity/mcp_config.json"),
-    path3.join(home, ".gemini/antigravity-cli/plugins/typegraph-mcp/mcp_config.json")
+    path4.join(home, ".gemini/antigravity/mcp_config.json"),
+    path4.join(home, ".gemini/antigravity-cli/plugins/typegraph-mcp/mcp_config.json")
   ];
 }
 function findAntigravityRegistration(projectRoot) {
@@ -516,37 +587,6 @@ function findAntigravityRegistration(projectRoot) {
   }
   return null;
 }
-function readProjectPackageJson(projectRoot) {
-  const packageJsonPath = path3.resolve(projectRoot, "package.json");
-  if (!fs2.existsSync(packageJsonPath)) return null;
-  try {
-    return JSON.parse(fs2.readFileSync(packageJsonPath, "utf-8"));
-  } catch {
-    return null;
-  }
-}
-function getProjectInstallCommand(projectRoot, packageJson) {
-  const packageManager = typeof packageJson?.["packageManager"] === "string" ? packageJson["packageManager"] : "";
-  if (packageManager.startsWith("pnpm@") || fs2.existsSync(path3.join(projectRoot, "pnpm-lock.yaml"))) {
-    return "pnpm install";
-  }
-  if (packageManager.startsWith("yarn@") || fs2.existsSync(path3.join(projectRoot, "yarn.lock"))) {
-    return "yarn install";
-  }
-  return "npm install";
-}
-function hasDeclaredDependency(packageJson, packageName) {
-  const depKeys = [
-    "dependencies",
-    "devDependencies",
-    "peerDependencies",
-    "optionalDependencies"
-  ];
-  return depKeys.some((key) => {
-    const deps = packageJson?.[key];
-    return typeof deps === "object" && deps !== null && packageName in deps;
-  });
-}
 var ESLINT_CONFIG_NAMES = [
   "eslint.config.mjs",
   "eslint.config.js",
@@ -563,26 +603,32 @@ var OXLINT_CONFIG_NAMES = [
 function findLintConfigs(projectRoot) {
   const configs = [];
   for (const fileName of ESLINT_CONFIG_NAMES) {
-    const fullPath = path3.resolve(projectRoot, fileName);
-    if (fs2.existsSync(fullPath)) {
+    const fullPath = path4.resolve(projectRoot, fileName);
+    if (fs3.existsSync(fullPath)) {
       configs.push({ tool: "ESLint", fileName, fullPath, propertyName: "ignores" });
     }
   }
   for (const fileName of OXLINT_CONFIG_NAMES) {
-    const fullPath = path3.resolve(projectRoot, fileName);
-    if (fs2.existsSync(fullPath)) {
+    const fullPath = path4.resolve(projectRoot, fileName);
+    if (fs3.existsSync(fullPath)) {
       configs.push({ tool: "Oxlint", fileName, fullPath, propertyName: "ignorePatterns" });
     }
   }
+  for (const fileName of BIOME_CONFIG_NAMES) {
+    const fullPath = path4.resolve(projectRoot, fileName);
+    if (fs3.existsSync(fullPath)) {
+      configs.push({ tool: "Biome", fileName, fullPath, propertyName: "files.includes" });
+      break;
+    }
+  }
   return configs;
 }
 async function main(configOverride) {
   const { projectRoot, tsconfigPath, toolDir, toolIsEmbedded, toolRelPath } = configOverride ?? resolveConfig(import.meta.dirname);
+  const excludedPaths = toolIsEmbedded ? [toolDir] : [];
   let passed = 0;
   let failed = 0;
   let warned = 0;
-  const projectPackageJson = readProjectPackageJson(projectRoot);
-  const installCommand = getProjectInstallCommand(projectRoot, projectPackageJson);
   function pass(msg) {
     console.log(`  \u2713 ${msg}`);
     passed++;
@@ -612,36 +658,39 @@ async function main(configOverride) {
   } else {
     fail(`Node.js ${nodeVersion} is too old`, "Upgrade Node.js to >= 22");
   }
-  const tsxInRoot = fs2.existsSync(path3.join(projectRoot, "node_modules/.bin/tsx"));
-  const tsxInTool = fs2.existsSync(path3.join(toolDir, "node_modules/.bin/tsx"));
+  const tsxInRoot = fs3.existsSync(path4.join(projectRoot, "node_modules/.bin/tsx"));
+  const tsxInTool = fs3.existsSync(path4.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;
+  let tsResolution = null;
   try {
-    const require2 = createRequire(path3.resolve(projectRoot, "package.json"));
-    const tsserverPath = require2.resolve("typescript/lib/tsserver.js");
-    const tsPkgPath = path3.resolve(path3.dirname(tsserverPath), "..", "package.json");
-    const tsPkg = JSON.parse(fs2.readFileSync(tsPkgPath, "utf-8"));
-    tsVersion = tsPkg.version;
-    pass(`TypeScript found (v${tsVersion})`);
+    tsResolution = resolveTsServer(projectRoot);
+    if (tsResolution.source === "project") {
+      pass(`TypeScript found (v${tsResolution.version})`);
+    } else if (tsResolution.projectVersion) {
+      pass(
+        `Compatible tsserver found (TypeScript v${tsResolution.version} tool runtime; project uses v${tsResolution.projectVersion})`
+      );
+    } else {
+      pass(`TypeScript found in typegraph-mcp (v${tsResolution.version})`);
+    }
   } catch {
-    const hasDeclaredTs = hasDeclaredDependency(projectPackageJson, "typescript");
     fail(
-      hasDeclaredTs ? "TypeScript is declared but not installed in project" : "TypeScript not found in project",
-      hasDeclaredTs ? `Run \`${installCommand}\` to install project dependencies` : `Add \`typescript\` to devDependencies and run \`${installCommand}\``
+      "Compatible tsserver runtime not found",
+      `Run \`cd ${toolRelPath} && npm install --include=optional\``
     );
   }
-  const tsconfigAbs = path3.resolve(projectRoot, tsconfigPath);
-  if (fs2.existsSync(tsconfigAbs)) {
+  const tsconfigAbs = path4.resolve(projectRoot, tsconfigPath);
+  if (fs3.existsSync(tsconfigAbs)) {
     pass(`tsconfig.json exists at ${tsconfigPath}`);
   } else {
-    fail(`tsconfig.json not found at ${tsconfigPath}`, `Create a tsconfig.json at ${tsconfigPath}`);
+    pass("No tsconfig.json; semantic tools will use an inferred TypeScript project");
   }
-  const pluginMcpPath = path3.join(toolDir, ".mcp.json");
-  const hasPluginMcp = fs2.existsSync(pluginMcpPath) && fs2.existsSync(path3.join(toolDir, ".claude-plugin/plugin.json"));
+  const pluginMcpPath = path4.join(toolDir, ".mcp.json");
+  const hasPluginMcp = fs3.existsSync(pluginMcpPath) && fs3.existsSync(path4.join(toolDir, ".claude-plugin/plugin.json"));
   const projectCodexConfig = readProjectCodexConfig(projectRoot);
   const hasProjectCodexRegistration = projectCodexConfig !== null && hasCompleteCodexTypegraphRegistration(projectCodexConfig);
   const codexGet = spawnSync("codex", ["mcp", "get", "typegraph"], {
@@ -655,7 +704,7 @@ async function main(configOverride) {
   } else if (hasPluginMcp) {
     pass("MCP registered via plugin (.mcp.json + .claude-plugin/ present)");
   } else if (projectCodexConfig !== null) {
-    const codexConfigPath = path3.resolve(projectRoot, ".codex/config.toml");
+    const codexConfigPath = path4.resolve(projectRoot, ".codex/config.toml");
     const hasSection = hasCodexTypegraphRegistration(projectCodexConfig);
     const hasCommand = /command\s*=\s*"[^"]+"/.test(projectCodexConfig);
     const hasArgs = /args\s*=\s*\[[\s\S]*\]/.test(projectCodexConfig);
@@ -689,11 +738,11 @@ async function main(configOverride) {
   } else if (antigravityRegistrationPath !== null) {
     pass(`MCP registered in Antigravity config (${antigravityRegistrationPath})`);
   } else {
-    const codexConfigPath = path3.resolve(projectRoot, ".codex/config.toml");
-    const mcpJsonPath = path3.resolve(projectRoot, ".claude/mcp.json");
-    if (fs2.existsSync(mcpJsonPath)) {
+    const codexConfigPath = path4.resolve(projectRoot, ".codex/config.toml");
+    const mcpJsonPath = path4.resolve(projectRoot, ".claude/mcp.json");
+    if (fs3.existsSync(mcpJsonPath)) {
       try {
-        const mcpJson = JSON.parse(fs2.readFileSync(mcpJsonPath, "utf-8"));
+        const mcpJson = JSON.parse(fs3.readFileSync(mcpJsonPath, "utf-8"));
         const tsNav = mcpJson?.mcpServers?.["typegraph"];
         if (tsNav) {
           const hasCommand = tsNav.command === "npx";
@@ -712,7 +761,7 @@ async function main(configOverride) {
             );
           }
         } else {
-          const serverPath = toolIsEmbedded ? `./${toolRelPath}/server.ts` : path3.resolve(toolDir, "server.ts");
+          const serverPath = toolIsEmbedded ? `./${toolRelPath}/server.ts` : path4.resolve(toolDir, "server.ts");
           fail(
             "MCP entry 'typegraph' not found in .claude/mcp.json",
             `Add to .claude/mcp.json:
@@ -740,11 +789,17 @@ async function main(configOverride) {
       );
     }
   }
-  const toolNodeModules = path3.join(toolDir, "node_modules");
-  if (fs2.existsSync(toolNodeModules)) {
-    const requiredPkgs = ["@modelcontextprotocol/sdk", "oxc-parser", "oxc-resolver", "zod"];
+  const toolNodeModules = path4.join(toolDir, "node_modules");
+  if (fs3.existsSync(toolNodeModules)) {
+    const requiredPkgs = [
+      "@modelcontextprotocol/sdk",
+      "oxc-parser",
+      "oxc-resolver",
+      "typescript",
+      "zod"
+    ];
     const missing = requiredPkgs.filter(
-      (pkg) => !fs2.existsSync(path3.join(toolNodeModules, ...pkg.split("/")))
+      (pkg) => !fs3.existsSync(path4.join(toolNodeModules, ...pkg.split("/")))
     );
     if (missing.length === 0) {
       pass(`Dependencies installed (${requiredPkgs.length} packages)`);
@@ -755,7 +810,7 @@ async function main(configOverride) {
     fail("typegraph-mcp dependencies not installed", `Run \`cd ${toolRelPath} && npm install\``);
   }
   try {
-    const oxcParserReq = createRequire(path3.join(toolDir, "package.json"));
+    const oxcParserReq = createRequire2(path4.join(toolDir, "package.json"));
     const { parseSync: parseSync2 } = await import(oxcParserReq.resolve("oxc-parser"));
     const result = parseSync2("test.ts", 'import { x } from "./y";');
     if (result.module?.staticImports?.length === 1) {
@@ -773,18 +828,18 @@ async function main(configOverride) {
     );
   }
   try {
-    const oxcResolverReq = createRequire(path3.join(toolDir, "package.json"));
+    const oxcResolverReq = createRequire2(path4.join(toolDir, "package.json"));
     const { ResolverFactory: ResolverFactory2 } = await import(oxcResolverReq.resolve("oxc-resolver"));
     const resolver = new ResolverFactory2({
-      tsconfig: { configFile: tsconfigAbs, references: "auto" },
+      ...fs3.existsSync(tsconfigAbs) ? { tsconfig: { configFile: tsconfigAbs, references: "auto" } } : {},
       extensions: [".ts", ".tsx", ".js"],
       extensionAlias: { ".js": [".ts", ".tsx", ".js"] }
     });
     let resolveOk = false;
-    const testFile = findFirstTsFile(projectRoot);
+    const testFile = findFirstTsFile(projectRoot, excludedPaths);
     if (testFile) {
-      const dir = path3.dirname(testFile);
-      const base = "./" + path3.basename(testFile);
+      const dir = path4.dirname(testFile);
+      const base = "./" + path4.basename(testFile);
       const result = resolver.sync(dir, base);
       resolveOk = !!result.path;
     }
@@ -802,9 +857,9 @@ async function main(configOverride) {
       `Reinstall: \`cd ${toolRelPath} && rm -rf node_modules && npm install\``
     );
   }
-  if (tsVersion) {
+  if (tsResolution) {
     try {
-      const ok = await testTsserver(projectRoot);
+      const ok = await testTsserver(projectRoot, tsResolution);
       if (ok) {
         pass("tsserver responds to configure");
       } else {
@@ -825,12 +880,16 @@ async function main(configOverride) {
   try {
     let buildGraph2;
     try {
-      ({ buildGraph: buildGraph2 } = await import(path3.resolve(toolDir, "module-graph.js")));
+      ({ buildGraph: buildGraph2 } = await import(path4.resolve(toolDir, "module-graph.js")));
     } catch {
       ({ buildGraph: buildGraph2 } = await Promise.resolve().then(() => (init_module_graph(), module_graph_exports)));
     }
     const start = performance.now();
-    const { graph } = await buildGraph2(projectRoot, tsconfigPath);
+    const { graph } = await buildGraph2(
+      projectRoot,
+      tsconfigPath,
+      excludedPaths
+    );
     const elapsed = (performance.now() - start).toFixed(0);
     const edgeCount = [...graph.forward.values()].reduce(
       (s, e) => s + e.length,
@@ -858,35 +917,36 @@ async function main(configOverride) {
   if (toolIsEmbedded) {
     const lintConfigs = findLintConfigs(projectRoot);
     if (lintConfigs.length > 0) {
-      const parentDir = path3.basename(path3.dirname(toolDir));
+      const parentDir = path4.basename(path4.dirname(toolDir));
       const parentIgnorePattern = new RegExp(`["']${parentDir}\\/\\*\\*["']`);
       for (const config of lintConfigs) {
-        const content = fs2.readFileSync(config.fullPath, "utf-8");
-        const hasParentIgnore = parentIgnorePattern.test(content);
+        const content = fs3.readFileSync(config.fullPath, "utf-8");
+        const hasParentIgnore = config.tool === "Biome" ? biomeScopeExcludes(content, parentDir) : parentIgnorePattern.test(content);
         if (hasParentIgnore) {
           pass(`${config.tool} ignores ${parentDir}/ (${config.fileName})`);
         } else {
+          const expectedPattern = config.tool === "Biome" ? `!!${parentDir}` : `${parentDir}/**`;
           fail(
-            `${config.tool} missing ignore: "${parentDir}/**" (${config.fileName})`,
+            `${config.tool} missing ignore: "${expectedPattern}" (${config.fileName})`,
             `Add to ${config.propertyName} in ${config.fileName}:
-    "${parentDir}/**",`
+    "${expectedPattern}",`
           );
         }
       }
     } else {
-      skip("Lint config check (no ESLint or Oxlint config found)");
+      skip("Lint config check (no ESLint, Oxlint, or Biome config found)");
     }
   } else {
     skip("Lint config check (typegraph-mcp is external to project)");
   }
-  const gitignorePath = path3.resolve(projectRoot, ".gitignore");
-  if (fs2.existsSync(gitignorePath)) {
-    const gitignoreContent = fs2.readFileSync(gitignorePath, "utf-8");
+  const gitignorePath = path4.resolve(projectRoot, ".gitignore");
+  if (fs3.existsSync(gitignorePath)) {
+    const gitignoreContent = fs3.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 ? path3.basename(path3.dirname(toolDir)) : null;
+    const parentDir = toolIsEmbedded ? path4.basename(path4.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}/` : ""));