typegraph-mcp 0.9.46 → 0.9.48

package/README.md

@@ -87,7 +87,7 @@ First query takes ~2s (tsserver warmup). Subsequent queries: 1-60ms.
 ## Requirements
 
 - **Node.js** >= 22
-- **TypeScript** >= 5.0 in the target project
+- A project containing TypeScript source files. `tsconfig.json` is supported but optional; without one, semantic tools use an inferred TypeScript project.
 - **npm** for dependency installation
 
 ## Tools
@@ -146,9 +146,9 @@ npx typegraph-mcp check
 | Symptom | Fix |
 |---|---|
 | Server won't start | `cd plugins/typegraph-mcp && npm install --include=optional` |
-| "TypeScript not found" | Run `pnpm install` or `npm install`; if TypeScript is not declared, add it to devDependencies first |
+| "Compatible tsserver not found" | Reinstall the plugin dependencies; TypeGraph uses the project's legacy tsserver when available and its bundled TypeScript 5 runtime for TypeScript 7 projects |
 | Tools return empty results | Check `TYPEGRAPH_TSCONFIG` points to the right tsconfig |
-| Build errors from plugins/ | Add `"plugins/**"` to tsconfig.json `exclude` array |
+| Broad project checks include plugins/ | Narrow the check command's input or ignore `plugins/`; setup does not edit `tsconfig.json` |
 | `@esbuild/*` or `@rollup/*` package missing | Reinstall with Node 22: `npm install --include=optional` |
 | "npm warn Unknown project config" | Safe to ignore — caused by pnpm settings in your `.npmrc` that npm doesn't recognize |
 
@@ -224,6 +224,15 @@ nvm use
 npm install --include=optional
 ```
 
+To install the current checkout into itself for Claude Code and Codex CLI:
+
+```bash
+npm run setup:self
+```
+
+The wrapper invokes the local `cli.ts`. In a Git worktree it first adds every generated
+plugin, skill, MCP configuration, and agent-instruction path to `.gitignore`.
+
 ### Run locally against a project
 
 ```bash

package/benchmark.ts

@@ -666,8 +666,17 @@ async function benchmarkAccuracy(
 
 // ─── Main ────────────────────────────────────────────────────────────────────
 
-export async function main(config?: { projectRoot: string; tsconfigPath: string }) {
-  ({ projectRoot, tsconfigPath } = config ?? resolveConfig(import.meta.dirname));
+export async function main(config?: {
+  projectRoot: string;
+  tsconfigPath: string;
+  toolDir?: string;
+  toolIsEmbedded?: boolean;
+}) {
+  const resolvedConfig = config ?? resolveConfig(import.meta.dirname);
+  ({ projectRoot, tsconfigPath } = resolvedConfig);
+  const excludedPaths = resolvedConfig.toolIsEmbedded && resolvedConfig.toolDir
+    ? [resolvedConfig.toolDir]
+    : [];
   console.log("");
   console.log("typegraph-mcp Benchmark");
   console.log("=======================");
@@ -676,7 +685,7 @@ export async function main(config?: { projectRoot: string; tsconfigPath: string
 
   // Build graph
   const graphStart = performance.now();
-  const { graph } = await buildGraph(projectRoot, tsconfigPath);
+  const { graph } = await buildGraph(projectRoot, tsconfigPath, excludedPaths);
   const graphMs = performance.now() - graphStart;
   const edgeCount = [...graph.forward.values()].reduce((s, e) => s + e.length, 0);
   console.log(`Module graph: ${graph.files.size} files, ${edgeCount} edges [${graphMs.toFixed(0)}ms]`);

package/biome-config.ts

@@ -0,0 +1,76 @@
+export const BIOME_CONFIG_NAMES = [
+  "biome.json",
+  "biome.jsonc",
+  ".biome.json",
+  ".biome.jsonc",
+];
+
+function filesObjectMatch(raw: string): RegExpMatchArray | null {
+  return raw.match(/(["']files["']\s*:\s*\{)([\s\S]*?)(\n?\s*\})/);
+}
+
+function filesIncludes(raw: string): string[] | null {
+  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]);
+}
+
+export function biomeScopeExcludes(raw: string, parentDir: string): boolean {
+  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}/`)
+    );
+  });
+}
+
+function appendToIncludes(body: string, forceIgnore: string): string | null {
+  const pattern = /(["']includes["']\s*:\s*\[)([\s\S]*?)(\])/;
+  if (!pattern.test(body)) return null;
+  return body.replace(pattern, (_match, open, items, close) => {
+    const trimmed = items.trimEnd();
+    const needsComma = trimmed.length > 0 && !trimmed.endsWith(",");
+    return `${open}${trimmed}${needsComma ? "," : ""} ${forceIgnore}${close}`;
+  });
+}
+
+export function patchBiomeConfig(raw: string, parentDir: string): string | null {
+  const forceIgnore = `"!!${parentDir}"`;
+  const filesObjectRe = /(["']files["']\s*:\s*\{)([\s\S]*?)(\n?\s*\})/;
+  const filesObject = filesObjectMatch(raw);
+
+  if (filesObject) {
+    const updatedBody = appendToIncludes(filesObject[2], forceIgnore);
+    if (updatedBody) {
+      return raw.replace(filesObjectRe, `${filesObject[1]}${updatedBody}${filesObject[3]}`);
+    }
+
+    const body = filesObject[2].trimEnd();
+    const needsComma = body.trim().length > 0 && !body.trimEnd().endsWith(",");
+    const updatedFiles = `${filesObject[1]}${body}${needsComma ? "," : ""}\n    "includes": ["**", ${forceIgnore}]${filesObject[3]}`;
+    return raw.replace(filesObjectRe, updatedFiles);
+  }
+
+  const lastBrace = raw.lastIndexOf("}");
+  if (lastBrace === -1) return null;
+  const before = raw.slice(0, lastBrace).trimEnd();
+  const needsComma = !before.endsWith(",") && !before.endsWith("{");
+  return `${before}${needsComma ? "," : ""}\n  "files": { "includes": ["**", ${forceIgnore}] }\n}\n`;
+}

package/check.ts

@@ -14,6 +14,8 @@ import * as path from "node:path";
 import { createRequire } from "node:module";
 import { spawn, spawnSync } from "node:child_process";
 import { resolveConfig, type TypegraphConfig } from "./config.js";
+import { resolveTsServer, type TsServerResolution } from "./tsserver-client.js";
+import { BIOME_CONFIG_NAMES, biomeScopeExcludes } from "./biome-config.js";
 
 // ─── Result Type ─────────────────────────────────────────────────────────────
 
@@ -26,7 +28,7 @@ export interface CheckResult {
 // ─── Helpers ─────────────────────────────────────────────────────────────────
 
 /** Find first .ts file in the project (for resolver smoke test) */
-function findFirstTsFile(dir: string): string | null {
+function findFirstTsFile(dir: string, excludedPaths: string[] = []): string | null {
   const skipDirs = new Set(["node_modules", "dist", ".git", ".wrangler", "coverage"]);
   try {
     for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
@@ -36,7 +38,14 @@ function findFirstTsFile(dir: string): string | null {
     }
     for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
       if (entry.isDirectory() && !skipDirs.has(entry.name) && !entry.name.startsWith(".")) {
-        const found = findFirstTsFile(path.join(dir, entry.name));
+        const childDir = path.join(dir, entry.name);
+        if (
+          excludedPaths.some(
+            (excludedPath) =>
+              childDir === excludedPath || childDir.startsWith(excludedPath + path.sep)
+          )
+        ) continue;
+        const found = findFirstTsFile(childDir, excludedPaths);
         if (found) return found;
       }
     }
@@ -47,18 +56,9 @@ function findFirstTsFile(dir: string): string | null {
 }
 
 /** Spawn tsserver, send configure, verify response, shut down */
-function testTsserver(projectRoot: string): Promise<boolean> {
+function testTsserver(projectRoot: string, resolution: TsServerResolution): Promise<boolean> {
   return new Promise((resolve) => {
-    let tsserverPath: string;
-    try {
-      const require = createRequire(path.resolve(projectRoot, "package.json"));
-      tsserverPath = require.resolve("typescript/lib/tsserver.js");
-    } catch {
-      resolve(false);
-      return;
-    }
-
-    const child = spawn("node", [tsserverPath, "--disableAutomaticTypingAcquisition"], {
+    const child = spawn("node", [resolution.path, "--disableAutomaticTypingAcquisition"], {
       cwd: projectRoot,
       stdio: ["pipe", "pipe", "pipe"],
     });
@@ -228,45 +228,6 @@ function findAntigravityRegistration(projectRoot: string): string | null {
   return null;
 }
 
-function readProjectPackageJson(projectRoot: string): Record<string, unknown> | null {
-  const packageJsonPath = path.resolve(projectRoot, "package.json");
-  if (!fs.existsSync(packageJsonPath)) return null;
-
-  try {
-    return JSON.parse(fs.readFileSync(packageJsonPath, "utf-8")) as Record<string, unknown>;
-  } catch {
-    return null;
-  }
-}
-
-function getProjectInstallCommand(projectRoot: string, packageJson: Record<string, unknown> | null): string {
-  const packageManager = typeof packageJson?.["packageManager"] === "string"
-    ? packageJson["packageManager"]
-    : "";
-
-  if (packageManager.startsWith("pnpm@") || fs.existsSync(path.join(projectRoot, "pnpm-lock.yaml"))) {
-    return "pnpm install";
-  }
-  if (packageManager.startsWith("yarn@") || fs.existsSync(path.join(projectRoot, "yarn.lock"))) {
-    return "yarn install";
-  }
-  return "npm install";
-}
-
-function hasDeclaredDependency(packageJson: Record<string, unknown> | null, packageName: string): boolean {
-  const depKeys = [
-    "dependencies",
-    "devDependencies",
-    "peerDependencies",
-    "optionalDependencies",
-  ] as const;
-
-  return depKeys.some((key) => {
-    const deps = packageJson?.[key];
-    return typeof deps === "object" && deps !== null && packageName in deps;
-  });
-}
-
 const ESLINT_CONFIG_NAMES = [
   "eslint.config.mjs",
   "eslint.config.js",
@@ -283,7 +244,8 @@ const OXLINT_CONFIG_NAMES = [
 
 type LintConfigCheck =
   | { tool: "ESLint"; fileName: string; fullPath: string; propertyName: "ignores" }
-  | { tool: "Oxlint"; fileName: string; fullPath: string; propertyName: "ignorePatterns" };
+  | { tool: "Oxlint"; fileName: string; fullPath: string; propertyName: "ignorePatterns" }
+  | { tool: "Biome"; fileName: string; fullPath: string; propertyName: "files.includes" };
 
 function findLintConfigs(projectRoot: string): LintConfigCheck[] {
   const configs: LintConfigCheck[] = [];
@@ -302,6 +264,14 @@ function findLintConfigs(projectRoot: string): LintConfigCheck[] {
     }
   }
 
+  for (const fileName of BIOME_CONFIG_NAMES) {
+    const fullPath = path.resolve(projectRoot, fileName);
+    if (fs.existsSync(fullPath)) {
+      configs.push({ tool: "Biome", fileName, fullPath, propertyName: "files.includes" });
+      break;
+    }
+  }
+
   return configs;
 }
 
@@ -310,12 +280,11 @@ function findLintConfigs(projectRoot: string): LintConfigCheck[] {
 export async function main(configOverride?: TypegraphConfig): Promise<CheckResult> {
   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: string): void {
     console.log(`  \u2713 ${msg}`);
@@ -363,33 +332,32 @@ export async function main(configOverride?: TypegraphConfig): Promise<CheckResul
     pass("tsx available (via npx/global)");
   }
 
-  // 3. TypeScript in project
-  let tsVersion: string | null = null;
+  // 3. Compatible tsserver runtime
+  let tsResolution: TsServerResolution | null = null;
   try {
-    const require = createRequire(path.resolve(projectRoot, "package.json"));
-    const tsserverPath = require.resolve("typescript/lib/tsserver.js");
-    const tsPkgPath = path.resolve(path.dirname(tsserverPath), "..", "package.json");
-    const tsPkg = JSON.parse(fs.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\``
     );
   }
 
-  // 4. tsconfig.json exists
+  // 4. TypeScript project mode
   const tsconfigAbs = path.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}`);
+    pass("No tsconfig.json; semantic tools will use an inferred TypeScript project");
   }
 
   // 5. MCP registration
@@ -501,7 +469,13 @@ export async function main(configOverride?: TypegraphConfig): Promise<CheckResul
   // 6. typegraph-mcp dependencies installed
   const toolNodeModules = path.join(toolDir, "node_modules");
   if (fs.existsSync(toolNodeModules)) {
-    const requiredPkgs = ["@modelcontextprotocol/sdk", "oxc-parser", "oxc-resolver", "zod"];
+    const requiredPkgs = [
+      "@modelcontextprotocol/sdk",
+      "oxc-parser",
+      "oxc-resolver",
+      "typescript",
+      "zod",
+    ];
     const missing = requiredPkgs.filter(
       (pkg) => !fs.existsSync(path.join(toolNodeModules, ...pkg.split("/")))
     );
@@ -539,13 +513,15 @@ export async function main(configOverride?: TypegraphConfig): Promise<CheckResul
     const oxcResolverReq = createRequire(path.join(toolDir, "package.json"));
     const { ResolverFactory } = await import(oxcResolverReq.resolve("oxc-resolver"));
     const resolver = new ResolverFactory({
-      tsconfig: { configFile: tsconfigAbs, references: "auto" },
+      ...(fs.existsSync(tsconfigAbs)
+        ? { tsconfig: { configFile: tsconfigAbs, references: "auto" as const } }
+        : {}),
       extensions: [".ts", ".tsx", ".js"],
       extensionAlias: { ".js": [".ts", ".tsx", ".js"] },
     });
     // Find any .ts file in the project to test resolution
     let resolveOk = false;
-    const testFile = findFirstTsFile(projectRoot);
+    const testFile = findFirstTsFile(projectRoot, excludedPaths);
     if (testFile) {
       const dir = path.dirname(testFile);
       const base = "./" + path.basename(testFile);
@@ -569,9 +545,9 @@ export async function main(configOverride?: TypegraphConfig): Promise<CheckResul
   }
 
   // 9. tsserver startup test
-  if (tsVersion) {
+  if (tsResolution) {
     try {
-      const ok = await testTsserver(projectRoot);
+      const ok = await testTsserver(projectRoot, tsResolution);
       if (ok) {
         pass("tsserver responds to configure");
       } else {
@@ -592,7 +568,7 @@ export async function main(configOverride?: TypegraphConfig): Promise<CheckResul
 
   // 10. Module graph build test
   try {
-    let buildGraph: (root: string, tsconfig: string) => Promise<{ graph: { files: Set<string>; forward: Map<string, unknown[]> } }>;
+    let buildGraph: (root: string, tsconfig: string, excluded?: string[]) => Promise<{ graph: { files: Set<string>; forward: Map<string, unknown[]> } }>;
     try {
       ({ buildGraph } = await import(path.resolve(toolDir, "module-graph.js")));
     } catch {
@@ -600,7 +576,11 @@ export async function main(configOverride?: TypegraphConfig): Promise<CheckResul
       ({ buildGraph } = await import("./module-graph.js"));
     }
     const start = performance.now();
-    const { graph } = await buildGraph(projectRoot, tsconfigPath);
+    const { graph } = await buildGraph(
+      projectRoot,
+      tsconfigPath,
+      excludedPaths
+    );
     const elapsed = (performance.now() - start).toFixed(0);
     const edgeCount = [...graph.forward.values()].reduce(
       (s: number, e: unknown[]) => s + e.length,
@@ -636,19 +616,23 @@ export async function main(configOverride?: TypegraphConfig): Promise<CheckResul
 
       for (const config of lintConfigs) {
         const content = fs.readFileSync(config.fullPath, "utf-8");
-        const hasParentIgnore = parentIgnorePattern.test(content);
+        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})`,
-            `Add to ${config.propertyName} in ${config.fileName}:\n    "${parentDir}/**",`
+            `${config.tool} missing ignore: "${expectedPattern}" (${config.fileName})`,
+            `Add to ${config.propertyName} in ${config.fileName}:\n    "${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)");

package/cli.ts

@@ -18,6 +18,7 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import { execSync } from "node:child_process";
 import * as p from "@clack/prompts";
+import { BIOME_CONFIG_NAMES, biomeScopeExcludes, patchBiomeConfig } from "./biome-config.js";
 import { resolveConfig } from "./config.js";
 
 // ─── Types ───────────────────────────────────────────────────────────────────
@@ -141,6 +142,7 @@ const AGENTS: Record<AgentId, AgentDef> = {
 /** Core files always installed (server, modules, config, package manifest) */
 const CORE_FILES = [
   "server.ts",
+  "biome-config.ts",
   "module-graph.ts",
   "tsserver-client.ts",
   "graph-queries.ts",
@@ -700,49 +702,6 @@ function deregisterAntigravityMcp(projectRoot: string): void {
   }
 }
 
-// ─── TSConfig Exclude ─────────────────────────────────────────────────────────
-
-function ensureTsconfigExclude(projectRoot: string): void {
-  const tsconfigPath = path.resolve(projectRoot, "tsconfig.json");
-  if (!fs.existsSync(tsconfigPath)) return;
-
-  try {
-    const raw = fs.readFileSync(tsconfigPath, "utf-8");
-    const excludeArrayMatch = raw.match(/("exclude"\s*:\s*\[)([\s\S]*?)(\])/);
-    if (excludeArrayMatch && /["']plugins(?:\/\*\*|\/\*|)["']/.test(excludeArrayMatch[2])) {
-      return;
-    }
-
-    // Insert "plugins/**" into the exclude array in the original file
-    if (excludeArrayMatch) {
-      // Existing exclude array — append to it
-      const updated = raw.replace(
-        /("exclude"\s*:\s*\[)([\s\S]*?)(\])/,
-        (_match, open, items, close) => {
-          const trimmed = items.trimEnd();
-          const needsComma = trimmed.length > 0 && !trimmed.endsWith(",");
-          return `${open}${items.trimEnd()}${needsComma ? "," : ""}\n    "plugins/**"${close}`;
-        }
-      );
-      fs.writeFileSync(tsconfigPath, updated);
-    } else {
-      // No exclude field — add one before the closing brace
-      const lastBrace = raw.lastIndexOf("}");
-      if (lastBrace !== -1) {
-        const before = raw.slice(0, lastBrace).trimEnd();
-        const needsComma = !before.endsWith(",") && !before.endsWith("{");
-        const patched = `${before}${needsComma ? "," : ""}\n  "exclude": ["plugins/**"]\n}\n`;
-        fs.writeFileSync(tsconfigPath, patched);
-      }
-    }
-
-    p.log.success('Added "plugins/**" to tsconfig.json exclude (prevents build errors)');
-  } catch {
-    // Don't fail setup over tsconfig parsing issues
-    p.log.warn('Could not update tsconfig.json — manually add "plugins/**" to the exclude array to prevent build errors');
-  }
-}
-
 // ─── Lint Ignore ─────────────────────────────────────────────────────────────
 
 const ESLINT_CONFIG_NAMES = [
@@ -761,7 +720,8 @@ const OXLINT_CONFIG_NAMES = [
 
 type LintConfig =
   | { tool: "ESLint"; fileName: string; fullPath: string; format: "flat" }
-  | { tool: "Oxlint"; fileName: string; fullPath: string; format: "json" | "module" };
+  | { tool: "Oxlint"; fileName: string; fullPath: string; format: "json" | "module" }
+  | { tool: "Biome"; fileName: string; fullPath: string; format: "json" };
 
 function findLintConfigs(projectRoot: string): LintConfig[] {
   const configs: LintConfig[] = [];
@@ -785,6 +745,14 @@ function findLintConfigs(projectRoot: string): LintConfig[] {
     }
   }
 
+  for (const fileName of BIOME_CONFIG_NAMES) {
+    const fullPath = path.resolve(projectRoot, fileName);
+    if (fs.existsSync(fullPath)) {
+      configs.push({ tool: "Biome", fileName, fullPath, format: "json" });
+      break;
+    }
+  }
+
   return configs;
 }
 
@@ -862,34 +830,51 @@ function patchOxlintModuleConfig(raw: string): string | null {
   return null;
 }
 
+function lintPropertyName(config: LintConfig): string {
+  if (config.tool === "ESLint") return "ignores";
+  if (config.tool === "Oxlint") return "ignorePatterns";
+  return "files.includes";
+}
+
 function ensureLintIgnores(projectRoot: string): void {
   const configs = findLintConfigs(projectRoot);
   for (const config of configs) {
     try {
       const raw = fs.readFileSync(config.fullPath, "utf-8");
-      if (/["']plugins\/\*\*["']/.test(raw)) continue;
+      if (
+        config.tool === "Biome"
+          ? biomeScopeExcludes(raw, "plugins")
+          : /["']plugins\/\*\*["']/.test(raw)
+      ) {
+        continue;
+      }
 
       const updated =
         config.tool === "ESLint"
           ? patchEslintConfig(raw)
+          : config.tool === "Biome"
+            ? patchBiomeConfig(raw, "plugins")
           : config.format === "json"
             ? patchOxlintJsonConfig(raw)
             : patchOxlintModuleConfig(raw);
 
       if (updated) {
         fs.writeFileSync(config.fullPath, updated);
-        const propertyName = config.tool === "ESLint" ? "ignores" : "ignorePatterns";
-        p.log.success(`Added "plugins/**" to ${config.fileName} ${propertyName}`);
+        const propertyName = lintPropertyName(config);
+        const ignorePattern = config.tool === "Biome" ? "!!plugins" : "plugins/**";
+        p.log.success(`Added "${ignorePattern}" to ${config.fileName} ${propertyName}`);
       } else {
-        const propertyName = config.tool === "ESLint" ? "ignores" : "ignorePatterns";
+        const propertyName = lintPropertyName(config);
+        const ignorePattern = config.tool === "Biome" ? "!!plugins" : "plugins/**";
         p.log.warn(
-          `Could not patch ${config.fileName} — manually add "plugins/**" to ${propertyName}`
+          `Could not patch ${config.fileName} — manually add "${ignorePattern}" to ${propertyName}`
         );
       }
     } catch {
-      const propertyName = config.tool === "ESLint" ? "ignores" : "ignorePatterns";
+      const propertyName = lintPropertyName(config);
+      const ignorePattern = config.tool === "Biome" ? "!!plugins" : "plugins/**";
       p.log.warn(
-        `Could not update ${config.fileName} — manually add "plugins/**" to ${propertyName}`
+        `Could not update ${config.fileName} — manually add "${ignorePattern}" to ${propertyName}`
       );
     }
   }
@@ -957,13 +942,13 @@ async function setup(yes: boolean): Promise<void> {
     process.exit(1);
   }
 
-  if (!fs.existsSync(tsconfigPath)) {
-    p.cancel("No tsconfig.json found. typegraph-mcp requires a TypeScript project.");
-    process.exit(1);
+  if (fs.existsSync(tsconfigPath)) {
+    p.log.success("Found package.json and tsconfig.json");
+  } else {
+    p.log.success("Found package.json");
+    p.log.info("No tsconfig.json found; semantic tools will use an inferred TypeScript project");
   }
 
-  p.log.success("Found package.json and tsconfig.json");
-
   // 2. Check for existing installation
   const targetDir = path.resolve(projectRoot, PLUGIN_DIR_NAME);
   const isUpdate = fs.existsSync(targetDir);
@@ -1125,13 +1110,10 @@ async function setup(yes: boolean): Promise<void> {
   // 7. Register MCP server in agent-specific configs
   registerMcpServers(projectRoot, selectedAgents);
 
-  // 8. Ensure plugins/ is excluded from tsconfig
-  ensureTsconfigExclude(projectRoot);
-
-  // 9. Ensure plugins/ is ignored by supported lint configs
+  // 8. Ensure plugins/ is ignored by supported lint configs
   ensureLintIgnores(projectRoot);
 
-  // 10. Verification
+  // 9. Verification
   await runVerification(targetDir, selectedAgents);
 }
 
@@ -1383,7 +1365,6 @@ const args = process.argv.slice(2);
 const command = args.find((a) => !a.startsWith("-"));
 const yes = args.includes("--yes") || args.includes("-y");
 const help = args.includes("--help") || args.includes("-h");
-
 // Clear npx download noise (warnings, "Ok to proceed?" prompt)
 process.stdout.write("\x1Bc");
 

package/commands/check.md

@@ -20,4 +20,4 @@ Run health checks to verify typegraph-mcp is correctly set up for this project.
    - For any failures, highlight the issue and the suggested fix
    - If all checks pass, confirm typegraph-mcp is ready
 
-3. The check verifies: Node.js version, tsx availability, TypeScript installation, tsconfig.json, MCP registration, dependencies, oxc-parser, oxc-resolver, tsserver, module graph, ESLint ignores, and .gitignore configuration.
+3. The check verifies: Node.js version, tsx availability, compatible TypeScript runtime, tsconfig.json, MCP registration, dependencies, oxc-parser, oxc-resolver, tsserver, module graph, ESLint/Oxlint/Biome ignores, and .gitignore configuration.