typegraph-mcp 0.9.37 → 0.9.39

package/dist/cli.js

@@ -31,6 +31,7 @@ __export(module_graph_exports, {
   createResolver: () => createResolver,
   discoverFiles: () => discoverFiles,
   removeFile: () => removeFile,
+  resolveProjectImport: () => resolveProjectImport,
   startWatcher: () => startWatcher,
   updateFile: () => updateFile
 });
@@ -136,7 +137,7 @@ function distToSource(resolvedPath, projectRoot3) {
   }
   return resolvedPath;
 }
-function resolveImport(resolver, fromDir, specifier, projectRoot3) {
+function resolveProjectImport(resolver, fromDir, specifier, projectRoot3) {
   try {
     const result = resolver.sync(fromDir, specifier);
     if (result.path && !result.path.includes("node_modules")) {
@@ -187,7 +188,7 @@ function buildForwardEdges(files, resolver, projectRoot3) {
     const edges = [];
     const fromDir = path2.dirname(filePath);
     for (const raw of rawImports) {
-      const target = resolveImport(resolver, fromDir, raw.specifier, projectRoot3);
+      const target = resolveProjectImport(resolver, fromDir, raw.specifier, projectRoot3);
       if (target) {
         edges.push({
           target,
@@ -268,7 +269,7 @@ function updateFile(graph, filePath, resolver, projectRoot3) {
   const fromDir = path2.dirname(filePath);
   const newEdges = [];
   for (const raw of rawImports) {
-    const target = resolveImport(resolver, fromDir, raw.specifier, projectRoot3);
+    const target = resolveProjectImport(resolver, fromDir, raw.specifier, projectRoot3);
     if (target) {
       newEdges.push({
         target,
@@ -513,6 +514,22 @@ function hasDeclaredDependency(packageJson, packageName) {
     return typeof deps === "object" && deps !== null && packageName in deps;
   });
 }
+function findLintConfigs(projectRoot3) {
+  const configs = [];
+  for (const fileName of ESLINT_CONFIG_NAMES) {
+    const fullPath = path3.resolve(projectRoot3, fileName);
+    if (fs2.existsSync(fullPath)) {
+      configs.push({ tool: "ESLint", fileName, fullPath, propertyName: "ignores" });
+    }
+  }
+  for (const fileName of OXLINT_CONFIG_NAMES) {
+    const fullPath = path3.resolve(projectRoot3, fileName);
+    if (fs2.existsSync(fullPath)) {
+      configs.push({ tool: "Oxlint", fileName, fullPath, propertyName: "ignorePatterns" });
+    }
+  }
+  return configs;
+}
 async function main(configOverride) {
   const { projectRoot: projectRoot3, tsconfigPath: tsconfigPath3, toolDir, toolIsEmbedded, toolRelPath } = configOverride ?? resolveConfig(import.meta.dirname);
   let passed = 0;
@@ -690,8 +707,8 @@ async function main(configOverride) {
   }
   try {
     const oxcParserReq = createRequire(path3.join(toolDir, "package.json"));
-    const { parseSync: parseSync2 } = await import(oxcParserReq.resolve("oxc-parser"));
-    const result = parseSync2("test.ts", 'import { x } from "./y";');
+    const { parseSync: parseSync3 } = await import(oxcParserReq.resolve("oxc-parser"));
+    const result = parseSync3("test.ts", 'import { x } from "./y";');
     if (result.module?.staticImports?.length === 1) {
       pass("oxc-parser working");
     } else {
@@ -790,28 +807,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(projectRoot3, name)));
-    if (eslintConfigFile) {
-      const eslintConfigPath = path3.resolve(projectRoot3, eslintConfigFile);
-      const eslintContent = fs2.readFileSync(eslintConfigPath, "utf-8");
+    const lintConfigs = findLintConfigs(projectRoot3);
+    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(projectRoot3, ".gitignore");
   if (fs2.existsSync(gitignorePath)) {
@@ -850,9 +867,23 @@ async function main(configOverride) {
   console.log("");
   return { passed, failed, warned };
 }
+var ESLINT_CONFIG_NAMES, OXLINT_CONFIG_NAMES;
 var init_check = __esm({
   "check.ts"() {
     init_config();
+    ESLINT_CONFIG_NAMES = [
+      "eslint.config.mjs",
+      "eslint.config.js",
+      "eslint.config.ts",
+      "eslint.config.cjs"
+    ];
+    OXLINT_CONFIG_NAMES = [
+      ".oxlintrc.json",
+      "oxlint.config.ts",
+      "oxlint.config.js",
+      "oxlint.config.mjs",
+      "oxlint.config.cjs"
+    ];
   }
 });
 
@@ -2307,6 +2338,7 @@ var init_benchmark = __esm({
 var server_exports = {};
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { parseSync as parseSync2 } from "oxc-parser";
 import { z } from "zod";
 import * as fs7 from "fs";
 import * as path8 from "path";
@@ -2371,8 +2403,227 @@ async function resolveParams(params) {
   }
   return { error: "Either line+column or symbol must be provided" };
 }
+function exportPriority(source) {
+  switch (source) {
+    case "local":
+      return 3;
+    case "re-export":
+      return 2;
+    case "star-re-export":
+      return 1;
+  }
+}
+function exportKey(item) {
+  return `${item.symbol}:${item.exportKind}`;
+}
+function sameExportOrigin(a, b) {
+  return a.symbol === b.symbol && a.exportKind === b.exportKind && a.from === b.from && a.definedIn === b.definedIn && a.definedLine === b.definedLine;
+}
+function kindImpliesTypeOnly(kind) {
+  return kind === "type" || kind === "interface";
+}
+function normalizeExportKindLabel(kind, exportKind) {
+  if (exportKind === "type" && !kindImpliesTypeOnly(kind)) {
+    return "type";
+  }
+  return kind;
+}
+function upsertExport(map, conflicts, nextExport) {
+  const key = exportKey(nextExport);
+  if (conflicts.has(key)) {
+    if (nextExport.source === "star-re-export") return;
+    conflicts.delete(key);
+    map.set(key, nextExport);
+    return;
+  }
+  const existing = map.get(key);
+  if (existing && existing.source === "star-re-export" && nextExport.source === "star-re-export" && !sameExportOrigin(existing, nextExport)) {
+    map.delete(key);
+    conflicts.add(key);
+    return;
+  }
+  if (!existing || exportPriority(nextExport.source) > exportPriority(existing.source)) {
+    map.set(key, nextExport);
+  }
+}
+function offsetToLineColumn(source, offset) {
+  const safeOffset = Math.max(0, Math.min(offset ?? 0, source.length));
+  const prefix = source.slice(0, safeOffset);
+  const lines = prefix.split("\n");
+  return {
+    line: lines.length,
+    column: (lines.at(-1)?.length ?? 0) + 1
+  };
+}
+function normalizeExistingPath(filePath) {
+  const resolved = path8.resolve(filePath);
+  try {
+    return fs7.realpathSync.native(resolved);
+  } catch {
+    return resolved;
+  }
+}
+function projectPath(file) {
+  return path8.isAbsolute(file) ? relPath2(file) : file;
+}
+function exportSymbol(entry) {
+  if (entry.exportName.kind === "Default") return "default";
+  return entry.exportName.name ?? entry.localName.name ?? entry.importName.name;
+}
+function exportLookupOffset(entry) {
+  if (entry.moduleRequest) {
+    return entry.importName.start ?? entry.exportName.start ?? entry.start;
+  }
+  if (entry.exportName.kind === "Default") {
+    return entry.localName.start ?? entry.exportName.start ?? entry.start;
+  }
+  return entry.exportName.start ?? entry.localName.start ?? entry.start;
+}
+async function resolveExportMetadata(file, line, column, fallbackKind) {
+  const defs = await client.definition(file, line, column);
+  const def = defs[0] ?? null;
+  let info = await client.quickinfo(file, line, column);
+  if ((!info || info.kind === "alias") && def) {
+    info = await client.quickinfo(def.file, def.start.line, def.start.offset) ?? info;
+  }
+  return {
+    kind: info?.kind ?? fallbackKind,
+    type: info?.displayString ?? null,
+    definedIn: projectPath(def?.file ?? file),
+    definedLine: def?.start.line ?? null
+  };
+}
+async function getModuleExports(file, visited = /* @__PURE__ */ new Set()) {
+  const relFile = path8.isAbsolute(file) ? relPath2(file) : file;
+  const absFile = normalizeExistingPath(client.resolvePath(relFile));
+  if (visited.has(absFile)) return [];
+  const nextVisited = new Set(visited);
+  nextVisited.add(absFile);
+  const exportMap = /* @__PURE__ */ new Map();
+  const conflictingStarExports = /* @__PURE__ */ new Set();
+  let source;
+  try {
+    source = fs7.readFileSync(absFile, "utf-8");
+  } catch {
+    return [...exportMap.values()];
+  }
+  let parsed;
+  try {
+    parsed = parseSync2(absFile, source);
+  } catch {
+    return [...exportMap.values()];
+  }
+  for (const exp of parsed.module.staticExports) {
+    for (const entry of exp.entries) {
+      const moduleRequest = entry.moduleRequest;
+      if (!moduleRequest) continue;
+      const targetFile = resolveProjectImport(
+        moduleResolver,
+        path8.dirname(absFile),
+        moduleRequest.value,
+        projectRoot2
+      );
+      const exportLoc = offsetToLineColumn(
+        source,
+        entry.exportName.start ?? entry.localName.start ?? entry.importName.start ?? entry.start
+      );
+      const importKind = entry.importName.kind;
+      const exportKind = entry.exportName.kind;
+      if (importKind === "AllButDefault" && exportKind === "None") {
+        if (!targetFile) continue;
+        const nestedExports = await getModuleExports(targetFile, nextVisited);
+        for (const nested of nestedExports) {
+          if (nested.symbol === "default") continue;
+          const starExportKind = entry.isType ? "type" : nested.exportKind;
+          upsertExport(exportMap, conflictingStarExports, {
+            ...nested,
+            line: exportLoc.line,
+            exportKind: starExportKind,
+            isTypeOnly: starExportKind === "type",
+            source: "star-re-export",
+            from: relPath2(targetFile)
+          });
+        }
+        continue;
+      }
+      const symbol = exportSymbol(entry);
+      if (!symbol) continue;
+      const importedSymbol = importKind === "Default" ? "default" : importKind === "Name" ? entry.importName.name : null;
+      const nestedMatch = targetFile && importedSymbol ? (await getModuleExports(targetFile, nextVisited)).find(
+        (item) => item.symbol === importedSymbol
+      ) ?? null : null;
+      const lookupLoc = offsetToLineColumn(
+        source,
+        exportLookupOffset(entry)
+      );
+      const metadata = await resolveExportMetadata(
+        relFile,
+        lookupLoc.line,
+        lookupLoc.column,
+        importKind === "All" ? "namespace" : "alias"
+      );
+      const resolvedExportKind = entry.isType || nestedMatch?.exportKind === "type" || kindImpliesTypeOnly(nestedMatch?.kind ?? metadata.kind) ? "type" : "value";
+      const resolvedKind = normalizeExportKindLabel(
+        nestedMatch?.kind ?? metadata.kind,
+        resolvedExportKind
+      );
+      upsertExport(exportMap, conflictingStarExports, {
+        symbol,
+        kind: resolvedKind,
+        line: exportLoc.line,
+        type: nestedMatch?.type ?? metadata.type,
+        exportKind: resolvedExportKind,
+        isTypeOnly: resolvedExportKind === "type",
+        isNamespace: importKind === "All",
+        source: "re-export",
+        from: targetFile ? relPath2(targetFile) : moduleRequest.value,
+        definedIn: nestedMatch?.definedIn ?? metadata.definedIn,
+        definedLine: nestedMatch?.definedLine ?? metadata.definedLine
+      });
+      continue;
+    }
+    for (const entry of exp.entries) {
+      const moduleRequest = entry.moduleRequest;
+      if (moduleRequest) continue;
+      const symbol = exportSymbol(entry);
+      if (!symbol) continue;
+      const exportLoc = offsetToLineColumn(
+        source,
+        entry.exportName.start ?? entry.localName.start ?? entry.start
+      );
+      const lookupLoc = offsetToLineColumn(source, exportLookupOffset(entry));
+      const metadata = await resolveExportMetadata(
+        relFile,
+        lookupLoc.line,
+        lookupLoc.column,
+        entry.isType ? "type" : "value"
+      );
+      const resolvedExportKind = entry.isType || kindImpliesTypeOnly(metadata.kind) ? "type" : "value";
+      const resolvedKind = normalizeExportKindLabel(metadata.kind, resolvedExportKind);
+      if (resolvedExportKind === "value" && symbol !== "default" && !exportKinds.has(resolvedKind) && resolvedKind !== "namespace" && resolvedKind !== "class") {
+        continue;
+      }
+      upsertExport(exportMap, conflictingStarExports, {
+        symbol,
+        kind: resolvedKind,
+        line: exportLoc.line,
+        type: metadata.type,
+        exportKind: resolvedExportKind,
+        isTypeOnly: resolvedExportKind === "type",
+        isNamespace: false,
+        source: "local",
+        from: null,
+        definedIn: relFile,
+        definedLine: resolvedExportKind === "type" ? exportLoc.line : metadata.definedLine
+      });
+    }
+  }
+  return [...exportMap.values()].sort(
+    (a, b) => a.line - b.line || a.symbol.localeCompare(b.symbol)
+  );
+}
 function relPath2(absPath2) {
-  return path8.relative(projectRoot2, absPath2);
+  return path8.relative(normalizedProjectRoot, normalizeExistingPath(absPath2));
 }
 function absPath(file) {
   return path8.isAbsolute(file) ? file : path8.resolve(projectRoot2, file);
@@ -2386,12 +2637,13 @@ async function main4() {
     buildGraph(projectRoot2, tsconfigPath2)
   ]);
   moduleGraph = graphResult.graph;
+  moduleResolver = graphResult.resolver;
   startWatcher(projectRoot2, moduleGraph, graphResult.resolver);
   const transport = new StdioServerTransport();
   await mcpServer.connect(transport);
   log3("MCP server connected and ready");
 }
-var projectRoot2, tsconfigPath2, log3, client, moduleGraph, mcpServer, locationOrSymbol;
+var projectRoot2, tsconfigPath2, log3, client, moduleGraph, moduleResolver, mcpServer, locationOrSymbol, exportKinds, normalizedProjectRoot;
 var init_server = __esm({
   "server.ts"() {
     init_tsserver_client();
@@ -2411,6 +2663,18 @@ var init_server = __esm({
       column: z.number().int().positive().optional().describe("Column/offset (1-based). Required if symbol is not provided."),
       symbol: z.string().optional().describe("Symbol name to find. Alternative to line+column.")
     };
+    exportKinds = /* @__PURE__ */ new Set([
+      "function",
+      "const",
+      "class",
+      "interface",
+      "type",
+      "enum",
+      "var",
+      "let",
+      "method"
+    ]);
+    normalizedProjectRoot = normalizeExistingPath(projectRoot2);
     mcpServer.tool(
       "ts_find_symbol",
       "Find a symbol's location in a file by name. Entry point for navigating without exact coordinates.",
@@ -2676,53 +2940,37 @@ var init_server = __esm({
     );
     mcpServer.tool(
       "ts_module_exports",
-      "List all exported symbols from a module with their resolved types. Gives an at-a-glance understanding of what a file provides.",
+      "List all exported symbols from a module with their resolved types, including re-exports when possible. Gives an at-a-glance understanding of what a file provides.",
       {
         file: z.string().describe("File to inspect")
       },
       async ({ file }) => {
-        const bar = await client.navbar(file);
-        if (bar.length === 0) {
-          return {
-            content: [
-              {
-                type: "text",
-                text: JSON.stringify({ error: `No symbols found in ${file}` })
-              }
-            ]
-          };
-        }
-        const moduleItem = bar.find((item) => item.kind === "module");
-        const topItems = moduleItem?.childItems ?? bar;
-        const exportKinds = /* @__PURE__ */ new Set([
-          "function",
-          "const",
-          "class",
-          "interface",
-          "type",
-          "enum",
-          "var",
-          "let",
-          "method"
-        ]);
-        const candidates = topItems.filter((item) => exportKinds.has(item.kind));
-        const exports = [];
-        for (const item of candidates) {
-          if (!item.spans[0]) continue;
-          const span = item.spans[0];
-          const info = await client.quickinfo(file, span.start.line, span.start.offset);
-          exports.push({
-            symbol: item.text,
-            kind: item.kind,
-            line: span.start.line,
-            type: info?.displayString ?? null
-          });
-        }
+        const exports = await getModuleExports(file);
+        const localCount = exports.filter((item) => item.source === "local").length;
+        const reExportCount = exports.length - localCount;
+        const typeOnlyCount = exports.filter((item) => item.isTypeOnly).length;
+        const valueCount = exports.length - typeOnlyCount;
+        const namespaceExportCount = exports.filter((item) => item.isNamespace).length;
+        const hasLocalRuntimeExports = exports.some(
+          (item) => item.source === "local" && !item.isTypeOnly
+        );
+        const isPrimarilyBarrel = exports.length > 0 && localCount < reExportCount;
         return {
           content: [
             {
               type: "text",
-              text: JSON.stringify({ file, exports, count: exports.length })
+              text: JSON.stringify({
+                file,
+                exports,
+                count: exports.length,
+                localCount,
+                reExportCount,
+                typeOnlyCount,
+                valueCount,
+                namespaceExportCount,
+                hasLocalRuntimeExports,
+                isPrimarilyBarrel
+              })
             }
           ]
         };
@@ -2927,6 +3175,8 @@ Where suitable, use the \`ts_*\` MCP tools instead of grep/glob for navigating T
 
 Start with the navigation tools before reading entire files. Use direct file reads only after the MCP tools identify the exact symbols or lines that matter.
 
+For quick architectural insight, prefer composition modules and entrypoints over top-level barrel files. If \`ts_module_exports\` on an \`index.ts\` or other barrel looks empty or uninformative, pivot to the app entrypoint, router, handler, service composition root, or API module that wires real behavior together.
+
 Use \`rg\` or \`grep\` when semantic symbol navigation is not the right tool, especially for:
 
 - docs, config, SQL, migrations, JSON, env vars, route strings, and other non-TypeScript assets
@@ -3340,13 +3590,11 @@ function ensureTsconfigExclude(projectRoot3) {
   if (!fs8.existsSync(tsconfigPath3)) return;
   try {
     const raw = fs8.readFileSync(tsconfigPath3, "utf-8");
-    const stripped = raw.replace(/\/\/.*$/gm, "").replace(/,(\s*[}\]])/g, "$1");
-    const tsconfig = JSON.parse(stripped);
-    const exclude = tsconfig.exclude || [];
-    if (exclude.some((e) => e === "plugins" || e === "plugins/**" || e === "plugins/*")) {
+    const excludeArrayMatch = raw.match(/("exclude"\s*:\s*\[)([\s\S]*?)(\])/);
+    if (excludeArrayMatch && /["']plugins(?:\/\*\*|\/\*|)["']/.test(excludeArrayMatch[2])) {
       return;
     }
-    if (raw.includes('"exclude"')) {
+    if (excludeArrayMatch) {
       const updated = raw.replace(
         /("exclude"\s*:\s*\[)([\s\S]*?)(\])/,
         (_match, open, items, close) => {
@@ -3374,40 +3622,114 @@ function ensureTsconfigExclude(projectRoot3) {
     p.log.warn('Could not update tsconfig.json \u2014 manually add "plugins/**" to the exclude array to prevent build errors');
   }
 }
-function ensureEslintIgnore(projectRoot3) {
-  const eslintConfigNames = ["eslint.config.mjs", "eslint.config.js", "eslint.config.ts", "eslint.config.cjs"];
-  const eslintConfigFile = eslintConfigNames.find((name) => fs8.existsSync(path9.resolve(projectRoot3, name)));
-  if (!eslintConfigFile) return;
-  const eslintConfigPath = path9.resolve(projectRoot3, eslintConfigFile);
-  try {
-    const raw = fs8.readFileSync(eslintConfigPath, "utf-8");
-    const pattern = /["']plugins\/\*\*["']/;
-    if (pattern.test(raw)) return;
-    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}`;
+var ESLINT_CONFIG_NAMES2 = [
+  "eslint.config.mjs",
+  "eslint.config.js",
+  "eslint.config.ts",
+  "eslint.config.cjs"
+];
+var OXLINT_CONFIG_NAMES2 = [
+  ".oxlintrc.json",
+  "oxlint.config.ts",
+  "oxlint.config.js",
+  "oxlint.config.mjs",
+  "oxlint.config.cjs"
+];
+function findLintConfigs2(projectRoot3) {
+  const configs = [];
+  for (const fileName of ESLINT_CONFIG_NAMES2) {
+    const fullPath = path9.resolve(projectRoot3, fileName);
+    if (fs8.existsSync(fullPath)) {
+      configs.push({ tool: "ESLint", fileName, fullPath, format: "flat" });
+    }
+  }
+  for (const fileName of OXLINT_CONFIG_NAMES2) {
+    const fullPath = path9.resolve(projectRoot3, fileName);
+    if (fs8.existsSync(fullPath)) {
+      configs.push({
+        tool: "Oxlint",
+        fileName,
+        fullPath,
+        format: fileName.endsWith(".json") ? "json" : "module"
       });
-      fs8.writeFileSync(eslintConfigPath, updated);
-      p.log.success(`Added "plugins/**" to ${eslintConfigFile} ignores`);
-      return;
     }
-    const exportArrayRe = /(export\s+default\s+(?:\w+\.config\(|\[))\s*\n?/;
-    if (exportArrayRe.test(raw)) {
-      const updated = raw.replace(exportArrayRe, (m) => {
-        return `${m}  { ignores: ["plugins/**"] },
+  }
+  return configs;
+}
+function appendToArrayLiteral(raw, propertyPattern, valueLiteral) {
+  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, propertyName, valueLiteral) {
+  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 ? "," : ""}
+  "${propertyName}": [${valueLiteral}]
+}
 `;
-      });
-      fs8.writeFileSync(eslintConfigPath, updated);
-      p.log.success(`Added "plugins/**" to ${eslintConfigFile} ignores`);
-      return;
+}
+function patchEslintConfig(raw) {
+  const updatedIgnores = appendToArrayLiteral(raw, /(ignores\s*:\s*\[)([\s\S]*?)(\])/, '"plugins/**"');
+  if (updatedIgnores) return updatedIgnores;
+  const exportArrayRe = /(export\s+default\s+(?:\w+\.config\(|\[))\s*\n?/;
+  if (exportArrayRe.test(raw)) {
+    return raw.replace(exportArrayRe, (match) => `${match}  { ignores: ["plugins/**"] },
+`);
+  }
+  return null;
+}
+function patchOxlintJsonConfig(raw) {
+  const updatedIgnores = appendToArrayLiteral(
+    raw,
+    /("ignorePatterns"\s*:\s*\[)([\s\S]*?)(\])/,
+    '"plugins/**"'
+  );
+  if (updatedIgnores) return updatedIgnores;
+  return insertTopLevelJsonArrayProperty(raw, "ignorePatterns", '"plugins/**"');
+}
+function patchOxlintModuleConfig(raw) {
+  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}
+  ignorePatterns: ["plugins/**"],`);
+  }
+  return null;
+}
+function ensureLintIgnores(projectRoot3) {
+  const configs = findLintConfigs2(projectRoot3);
+  for (const config of configs) {
+    try {
+      const raw = fs8.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) {
+        fs8.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} \u2014 manually add "plugins/**" to ${propertyName}`
+        );
+      }
+    } catch {
+      const propertyName = config.tool === "ESLint" ? "ignores" : "ignorePatterns";
+      p.log.warn(
+        `Could not update ${config.fileName} \u2014 manually add "plugins/**" to ${propertyName}`
+      );
     }
-    p.log.warn(`Could not patch ${eslintConfigFile} \u2014 manually add "plugins/**" to the ignores array`);
-  } catch {
-    p.log.warn(`Could not update ${eslintConfigFile} \u2014 manually add "plugins/**" to the ignores array`);
   }
 }
 function detectAgents(projectRoot3) {
@@ -3582,7 +3904,7 @@ async function setup(yes2) {
   await setupAgentInstructions(projectRoot3, selectedAgents);
   registerMcpServers(projectRoot3, selectedAgents);
   ensureTsconfigExclude(projectRoot3);
-  ensureEslintIgnore(projectRoot3);
+  ensureLintIgnores(projectRoot3);
   await runVerification(targetDir, selectedAgents);
 }
 async function removePlugin(projectRoot3, pluginDir, options) {