typegraph-mcp 0.9.38 → 0.9.39

package/check.ts

@@ -209,6 +209,44 @@ function hasDeclaredDependency(packageJson: Record<string, unknown> | null, pack
   });
 }
 
+const ESLINT_CONFIG_NAMES = [
+  "eslint.config.mjs",
+  "eslint.config.js",
+  "eslint.config.ts",
+  "eslint.config.cjs",
+];
+const OXLINT_CONFIG_NAMES = [
+  ".oxlintrc.json",
+  "oxlint.config.ts",
+  "oxlint.config.js",
+  "oxlint.config.mjs",
+  "oxlint.config.cjs",
+];
+
+type LintConfigCheck =
+  | { tool: "ESLint"; fileName: string; fullPath: string; propertyName: "ignores" }
+  | { tool: "Oxlint"; fileName: string; fullPath: string; propertyName: "ignorePatterns" };
+
+function findLintConfigs(projectRoot: string): LintConfigCheck[] {
+  const configs: LintConfigCheck[] = [];
+
+  for (const fileName of ESLINT_CONFIG_NAMES) {
+    const fullPath = path.resolve(projectRoot, fileName);
+    if (fs.existsSync(fullPath)) {
+      configs.push({ tool: "ESLint", fileName, fullPath, propertyName: "ignores" });
+    }
+  }
+
+  for (const fileName of OXLINT_CONFIG_NAMES) {
+    const fullPath = path.resolve(projectRoot, fileName);
+    if (fs.existsSync(fullPath)) {
+      configs.push({ tool: "Oxlint", fileName, fullPath, propertyName: "ignorePatterns" });
+    }
+  }
+
+  return configs;
+}
+
 // ─── Main ────────────────────────────────────────────────────────────────────
 
 export async function main(configOverride?: TypegraphConfig): Promise<CheckResult> {
@@ -527,31 +565,32 @@ export async function main(configOverride?: TypegraphConfig): Promise<CheckResul
     );
   }
 
-  // 11. ESLint ignores (only when typegraph-mcp is embedded inside the project)
+  // 11. Lint ignores (only when typegraph-mcp is embedded inside the project)
   if (toolIsEmbedded) {
-    const eslintConfigNames = ["eslint.config.mjs", "eslint.config.js", "eslint.config.ts", "eslint.config.cjs"];
-    const eslintConfigFile = eslintConfigNames.find((name) => fs.existsSync(path.resolve(projectRoot, name)));
-    if (eslintConfigFile) {
-      const eslintConfigPath = path.resolve(projectRoot, eslintConfigFile);
-      const eslintContent = fs.readFileSync(eslintConfigPath, "utf-8");
+    const lintConfigs = findLintConfigs(projectRoot);
+    if (lintConfigs.length > 0) {
       // Determine the parent directory (e.g. "plugins") for the ignore pattern
       const parentDir = path.basename(path.dirname(toolDir));
       const parentIgnorePattern = new RegExp(`["']${parentDir}\\/\\*\\*["']`);
-      const hasParentIgnore = parentIgnorePattern.test(eslintContent);
 
-      if (hasParentIgnore) {
-        pass(`ESLint ignores ${parentDir}/`);
-      } else {
-        fail(
-          `ESLint missing ignore: "${parentDir}/**"`,
-          `Add to the ignores array in ${eslintConfigFile}:\n    "${parentDir}/**",`
-        );
+      for (const config of lintConfigs) {
+        const content = fs.readFileSync(config.fullPath, "utf-8");
+        const hasParentIgnore = parentIgnorePattern.test(content);
+
+        if (hasParentIgnore) {
+          pass(`${config.tool} ignores ${parentDir}/ (${config.fileName})`);
+        } else {
+          fail(
+            `${config.tool} missing ignore: "${parentDir}/**" (${config.fileName})`,
+            `Add to ${config.propertyName} in ${config.fileName}:\n    "${parentDir}/**",`
+          );
+        }
       }
     } else {
-      skip("ESLint config check (no eslint flat config found)");
+      skip("Lint config check (no ESLint or Oxlint config found)");
     }
   } else {
-    skip("ESLint config check (typegraph-mcp is external to project)");
+    skip("Lint config check (typegraph-mcp is external to project)");
   }
 
   // 12. .gitignore check (optional)

package/cli.ts

@@ -601,19 +601,13 @@ function ensureTsconfigExclude(projectRoot: string): void {
 
   try {
     const raw = fs.readFileSync(tsconfigPath, "utf-8");
-    // Strip single-line comments (// ...) and trailing commas for JSON.parse
-    const stripped = raw
-      .replace(/\/\/.*$/gm, "")
-      .replace(/,(\s*[}\]])/g, "$1");
-    const tsconfig = JSON.parse(stripped);
-
-    const exclude: string[] = tsconfig.exclude || [];
-    if (exclude.some((e: string) => e === "plugins" || e === "plugins/**" || e === "plugins/*")) {
-      return; // Already excluded
+    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 (raw.includes('"exclude"')) {
+    if (excludeArrayMatch) {
       // Existing exclude array — append to it
       const updated = raw.replace(
         /("exclude"\s*:\s*\[)([\s\S]*?)(\])/,
@@ -642,48 +636,137 @@ function ensureTsconfigExclude(projectRoot: string): void {
   }
 }
 
-// ─── ESLint Ignore ───────────────────────────────────────────────────────────
+// ─── Lint Ignore ─────────────────────────────────────────────────────────────
 
-function ensureEslintIgnore(projectRoot: string): void {
-  const eslintConfigNames = ["eslint.config.mjs", "eslint.config.js", "eslint.config.ts", "eslint.config.cjs"];
-  const eslintConfigFile = eslintConfigNames.find((name) => fs.existsSync(path.resolve(projectRoot, name)));
-  if (!eslintConfigFile) return;
-  const eslintConfigPath = path.resolve(projectRoot, eslintConfigFile);
+const ESLINT_CONFIG_NAMES = [
+  "eslint.config.mjs",
+  "eslint.config.js",
+  "eslint.config.ts",
+  "eslint.config.cjs",
+];
+const OXLINT_CONFIG_NAMES = [
+  ".oxlintrc.json",
+  "oxlint.config.ts",
+  "oxlint.config.js",
+  "oxlint.config.mjs",
+  "oxlint.config.cjs",
+];
 
-  try {
-    const raw = fs.readFileSync(eslintConfigPath, "utf-8");
-    const pattern = /["']plugins\/\*\*["']/;
-    if (pattern.test(raw)) return; // Already ignored
+type LintConfig =
+  | { tool: "ESLint"; fileName: string; fullPath: string; format: "flat" }
+  | { tool: "Oxlint"; fileName: string; fullPath: string; format: "json" | "module" };
 
-    // Strategy 1: Append to an existing ignores array
-    const ignoresArrayRe = /(ignores\s*:\s*\[)([\s\S]*?)(\])/;
-    const match = raw.match(ignoresArrayRe);
-    if (match) {
-      const updated = raw.replace(ignoresArrayRe, (_m, open, items, close) => {
-        const trimmed = items.trimEnd();
-        const needsComma = trimmed.length > 0 && !trimmed.endsWith(",");
-        return `${open}${items.trimEnd()}${needsComma ? "," : ""} "plugins/**"${close}`;
-      });
-      fs.writeFileSync(eslintConfigPath, updated);
-      p.log.success(`Added "plugins/**" to ${eslintConfigFile} ignores`);
-      return;
+function findLintConfigs(projectRoot: string): LintConfig[] {
+  const configs: LintConfig[] = [];
+
+  for (const fileName of ESLINT_CONFIG_NAMES) {
+    const fullPath = path.resolve(projectRoot, fileName);
+    if (fs.existsSync(fullPath)) {
+      configs.push({ tool: "ESLint", fileName, fullPath, format: "flat" });
     }
+  }
 
-    // Strategy 2: Insert a new ignores object at the start of the exported array
-    // Matches: export default [ or export default tseslint.config(
-    const exportArrayRe = /(export\s+default\s+(?:\w+\.config\(|\[))\s*\n?/;
-    if (exportArrayRe.test(raw)) {
-      const updated = raw.replace(exportArrayRe, (m) => {
-        return `${m}  { ignores: ["plugins/**"] },\n`;
+  for (const fileName of OXLINT_CONFIG_NAMES) {
+    const fullPath = path.resolve(projectRoot, fileName);
+    if (fs.existsSync(fullPath)) {
+      configs.push({
+        tool: "Oxlint",
+        fileName,
+        fullPath,
+        format: fileName.endsWith(".json") ? "json" : "module",
       });
-      fs.writeFileSync(eslintConfigPath, updated);
-      p.log.success(`Added "plugins/**" to ${eslintConfigFile} ignores`);
-      return;
     }
+  }
 
-    p.log.warn(`Could not patch ${eslintConfigFile} — manually add "plugins/**" to the ignores array`);
-  } catch {
-    p.log.warn(`Could not update ${eslintConfigFile} — manually add "plugins/**" to the ignores array`);
+  return configs;
+}
+
+function appendToArrayLiteral(raw: string, propertyPattern: RegExp, valueLiteral: string): string | null {
+  if (!propertyPattern.test(raw)) return null;
+  return raw.replace(propertyPattern, (_match, open, items, close) => {
+    const trimmed = items.trimEnd();
+    const needsComma = trimmed.length > 0 && !trimmed.endsWith(",");
+    return `${open}${items.trimEnd()}${needsComma ? "," : ""} ${valueLiteral}${close}`;
+  });
+}
+
+function insertTopLevelJsonArrayProperty(raw: string, propertyName: string, valueLiteral: string): string | null {
+  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  "${propertyName}": [${valueLiteral}]\n}\n`;
+}
+
+function patchEslintConfig(raw: string): string | null {
+  const updatedIgnores = appendToArrayLiteral(raw, /(ignores\s*:\s*\[)([\s\S]*?)(\])/, '"plugins/**"');
+  if (updatedIgnores) return updatedIgnores;
+
+  // Matches: export default [ or export default tseslint.config(
+  const exportArrayRe = /(export\s+default\s+(?:\w+\.config\(|\[))\s*\n?/;
+  if (exportArrayRe.test(raw)) {
+    return raw.replace(exportArrayRe, (match) => `${match}  { ignores: ["plugins/**"] },\n`);
+  }
+
+  return null;
+}
+
+function patchOxlintJsonConfig(raw: string): string | null {
+  const updatedIgnores = appendToArrayLiteral(
+    raw,
+    /("ignorePatterns"\s*:\s*\[)([\s\S]*?)(\])/,
+    '"plugins/**"'
+  );
+  if (updatedIgnores) return updatedIgnores;
+  return insertTopLevelJsonArrayProperty(raw, "ignorePatterns", '"plugins/**"');
+}
+
+function patchOxlintModuleConfig(raw: string): string | null {
+  const updatedIgnores = appendToArrayLiteral(
+    raw,
+    /(ignorePatterns\s*:\s*\[)([\s\S]*?)(\])/,
+    '"plugins/**"'
+  );
+  if (updatedIgnores) return updatedIgnores;
+
+  const exportObjectRe = /(export\s+default\s*\{)\s*\n?/;
+  if (exportObjectRe.test(raw)) {
+    return raw.replace(exportObjectRe, (match) => `${match}\n  ignorePatterns: ["plugins/**"],`);
+  }
+
+  return null;
+}
+
+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;
+
+      const updated =
+        config.tool === "ESLint"
+          ? patchEslintConfig(raw)
+          : 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}`);
+      } else {
+        const propertyName = config.tool === "ESLint" ? "ignores" : "ignorePatterns";
+        p.log.warn(
+          `Could not patch ${config.fileName} — manually add "plugins/**" to ${propertyName}`
+        );
+      }
+    } catch {
+      const propertyName = config.tool === "ESLint" ? "ignores" : "ignorePatterns";
+      p.log.warn(
+        `Could not update ${config.fileName} — manually add "plugins/**" to ${propertyName}`
+      );
+    }
   }
 }
 
@@ -920,8 +1003,8 @@ async function setup(yes: boolean): Promise<void> {
   // 8. Ensure plugins/ is excluded from tsconfig
   ensureTsconfigExclude(projectRoot);
 
-  // 9. Ensure plugins/ is ignored by ESLint
-  ensureEslintIgnore(projectRoot);
+  // 9. Ensure plugins/ is ignored by supported lint configs
+  ensureLintIgnores(projectRoot);
 
   // 10. Verification
   await runVerification(targetDir, selectedAgents);

package/dist/benchmark.js

@@ -387,7 +387,7 @@ function distToSource(resolvedPath, projectRoot2) {
   }
   return resolvedPath;
 }
-function resolveImport(resolver, fromDir, specifier, projectRoot2) {
+function resolveProjectImport(resolver, fromDir, specifier, projectRoot2) {
   try {
     const result = resolver.sync(fromDir, specifier);
     if (result.path && !result.path.includes("node_modules")) {
@@ -438,7 +438,7 @@ function buildForwardEdges(files, resolver, projectRoot2) {
     const edges = [];
     const fromDir = path2.dirname(filePath);
     for (const raw of rawImports) {
-      const target = resolveImport(resolver, fromDir, raw.specifier, projectRoot2);
+      const target = resolveProjectImport(resolver, fromDir, raw.specifier, projectRoot2);
       if (target) {
         edges.push({
           target,

package/dist/check.js

@@ -15,6 +15,7 @@ __export(module_graph_exports, {
   createResolver: () => createResolver,
   discoverFiles: () => discoverFiles,
   removeFile: () => removeFile,
+  resolveProjectImport: () => resolveProjectImport,
   startWatcher: () => startWatcher,
   updateFile: () => updateFile
 });
@@ -120,7 +121,7 @@ function distToSource(resolvedPath, projectRoot) {
   }
   return resolvedPath;
 }
-function resolveImport(resolver, fromDir, specifier, projectRoot) {
+function resolveProjectImport(resolver, fromDir, specifier, projectRoot) {
   try {
     const result = resolver.sync(fromDir, specifier);
     if (result.path && !result.path.includes("node_modules")) {
@@ -171,7 +172,7 @@ function buildForwardEdges(files, resolver, projectRoot) {
     const edges = [];
     const fromDir = path2.dirname(filePath);
     for (const raw of rawImports) {
-      const target = resolveImport(resolver, fromDir, raw.specifier, projectRoot);
+      const target = resolveProjectImport(resolver, fromDir, raw.specifier, projectRoot);
       if (target) {
         edges.push({
           target,
@@ -252,7 +253,7 @@ function updateFile(graph, filePath, resolver, projectRoot) {
   const fromDir = path2.dirname(filePath);
   const newEdges = [];
   for (const raw of rawImports) {
-    const target = resolveImport(resolver, fromDir, raw.specifier, projectRoot);
+    const target = resolveProjectImport(resolver, fromDir, raw.specifier, projectRoot);
     if (target) {
       newEdges.push({
         target,
@@ -506,6 +507,35 @@ function hasDeclaredDependency(packageJson, packageName) {
     return typeof deps === "object" && deps !== null && packageName in deps;
   });
 }
+var ESLINT_CONFIG_NAMES = [
+  "eslint.config.mjs",
+  "eslint.config.js",
+  "eslint.config.ts",
+  "eslint.config.cjs"
+];
+var OXLINT_CONFIG_NAMES = [
+  ".oxlintrc.json",
+  "oxlint.config.ts",
+  "oxlint.config.js",
+  "oxlint.config.mjs",
+  "oxlint.config.cjs"
+];
+function findLintConfigs(projectRoot) {
+  const configs = [];
+  for (const fileName of ESLINT_CONFIG_NAMES) {
+    const fullPath = path3.resolve(projectRoot, fileName);
+    if (fs2.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)) {
+      configs.push({ tool: "Oxlint", fileName, fullPath, propertyName: "ignorePatterns" });
+    }
+  }
+  return configs;
+}
 async function main(configOverride) {
   const { projectRoot, tsconfigPath, toolDir, toolIsEmbedded, toolRelPath } = configOverride ?? resolveConfig(import.meta.dirname);
   let passed = 0;
@@ -783,28 +813,28 @@ async function main(configOverride) {
     );
   }
   if (toolIsEmbedded) {
-    const eslintConfigNames = ["eslint.config.mjs", "eslint.config.js", "eslint.config.ts", "eslint.config.cjs"];
-    const eslintConfigFile = eslintConfigNames.find((name) => fs2.existsSync(path3.resolve(projectRoot, name)));
-    if (eslintConfigFile) {
-      const eslintConfigPath = path3.resolve(projectRoot, eslintConfigFile);
-      const eslintContent = fs2.readFileSync(eslintConfigPath, "utf-8");
+    const lintConfigs = findLintConfigs(projectRoot);
+    if (lintConfigs.length > 0) {
       const parentDir = path3.basename(path3.dirname(toolDir));
       const parentIgnorePattern = new RegExp(`["']${parentDir}\\/\\*\\*["']`);
-      const hasParentIgnore = parentIgnorePattern.test(eslintContent);
-      if (hasParentIgnore) {
-        pass(`ESLint ignores ${parentDir}/`);
-      } else {
-        fail(
-          `ESLint missing ignore: "${parentDir}/**"`,
-          `Add to the ignores array in ${eslintConfigFile}:
+      for (const config of lintConfigs) {
+        const content = fs2.readFileSync(config.fullPath, "utf-8");
+        const hasParentIgnore = parentIgnorePattern.test(content);
+        if (hasParentIgnore) {
+          pass(`${config.tool} ignores ${parentDir}/ (${config.fileName})`);
+        } else {
+          fail(
+            `${config.tool} missing ignore: "${parentDir}/**" (${config.fileName})`,
+            `Add to ${config.propertyName} in ${config.fileName}:
     "${parentDir}/**",`
-        );
+          );
+        }
       }
     } else {
-      skip("ESLint config check (no eslint flat config found)");
+      skip("Lint config check (no ESLint or Oxlint config found)");
     }
   } else {
-    skip("ESLint config check (typegraph-mcp is external to project)");
+    skip("Lint config check (typegraph-mcp is external to project)");
   }
   const gitignorePath = path3.resolve(projectRoot, ".gitignore");
   if (fs2.existsSync(gitignorePath)) {