@codacy/tools-eslint-9 0.6.0 → 0.6.1

package/dist/index.js

@@ -37,8 +37,8 @@ var import_tooling2 = require("@codacy/tooling");
 
 // src/adapter.ts
 var import_tooling = require("@codacy/tooling");
-var import_path = __toESM(require("path"));
-var import_fs = __toESM(require("fs"));
+var import_path3 = __toESM(require("path"));
+var import_fs3 = __toESM(require("fs"));
 
 // src/patterns.json
 var patterns_default = [
@@ -28427,15 +28427,55 @@ var patterns_default = [
   }
 ];
 
+// src/config-builder.ts
+var import_fs2 = __toESM(require("fs"));
+var import_path2 = __toESM(require("path"));
+
 // src/blacklist.ts
+var import_fs = __toESM(require("fs"));
+var import_path = __toESM(require("path"));
+var BLACKLISTED_RULE_PATTERNS = [
+  // `eslint-plugin-unused-imports` ships duplicate `-ts` variants (e.g.
+  // `no-unused-imports-ts`) that are meant for codebases NOT using the
+  // `@typescript-eslint` plugin. In our config `@typescript-eslint/
+  // no-unused-vars` is always available for TS files, so the `-ts`
+  // variants are redundant and conflict with it.
+  /^unused-imports\/.*-ts$/,
+  // `eslint-plugin-angular` targets AngularJS 1.x (not Angular 2+) and
+  // also calls removed ESLint 9 APIs in several rules
+  // (`angular/component-limit`, `angular/di*`, `angular/dumb-inject`,
+  // `angular/no-directive-replace`, `angular/no-run-logic`,
+  // `angular/prefer-component`, `angular/service-name`, …). The modern
+  // `@angular-eslint/*` plugin (Angular 2+) is unaffected and stays
+  // enabled.
+  /^angular\//,
+  // `eslint-plugin-eslint-plugin` targets ESLint plugin authors. Several
+  // of its rules (`no-property-in-node`, …) also call removed AST
+  // utilities and fail on ESLint 9. Not useful for end-user code
+  // analysis either.
+  /^eslint-plugin\//
+];
 var BLACKLISTED_RULES = /* @__PURE__ */ new Set([
-  // --- Plugin rules that crash or misbehave ---
-  "@lwc/lwc/no-unexpected-wire-adapter-usages",
-  "@lwc/lwc/no-unknown-wire-adapters",
+  // --- Plugin rules that crash on ESLint 9 (but aren't covered by a
+  //     blanket namespace above) ---------------------------------------
+  // `@typescript-eslint/consistent-type-imports` is incompatible with
+  // the `verbatimModuleSyntax` tsconfig flag (now the recommended TS
+  // setting) and emits conflicting auto-fixes when both are enabled.
   "@typescript-eslint/consistent-type-imports",
-  "angular/service-name",
-  "ember/no-restricted-property-modifications",
+  // `ember/template-indent` reformats Handlebars templates in a way that
+  // fights both the ember-template-lint formatter and Prettier. Source
+  // of persistent whitespace false positives; preserved from the
+  // codacy-eslint blacklist history.
   "ember/template-indent",
+  // --- eslint-plugin-functional family ------------------------------
+  //
+  // The `functional` plugin enforces an extremely strict pure-FP style
+  // (no mutation, no `let`, no throw, no void return, …). On general
+  // JavaScript/TypeScript codebases every one of these rules produces
+  // a flood of false positives that drowns out every other finding.
+  // They are only appropriate for codebases that have opted into the
+  // plugin explicitly — which users can do via their own local
+  // `eslint.config.js` + `useLocalConfigurationFile`.
   "functional/functional-parameters",
   "functional/immutable-data",
   "functional/no-conditional-statements",
@@ -28447,8 +28487,19 @@ var BLACKLISTED_RULES = /* @__PURE__ */ new Set([
   "functional/no-try-statements",
   "functional/prefer-immutable-types",
   "functional/type-declaration-immutability",
+  // `yml/sort-sequence-values` is the YAML counterpart of `jsonc/sort-
+  // array-values` — it requires a non-empty options array (pathPattern
+  // + order) and crashes without one. Listed as unconditional because
+  // patterns.json does not surface a parameter schema that lets us
+  // tell "user supplied" from "default" for this rule; revisit if a
+  // user complains.
   "yml/sort-sequence-values",
-  // --- Core rules that crash or conflict with @stylistic equivalents ---
+  // --- Core formatting rules conflicting with @stylistic ------------
+  //
+  // When both a core layout rule and its `@stylistic/*` equivalent are
+  // enabled, they fight each other (same AST, different fixers). We
+  // prefer the `@stylistic` versions because they track ESLint's
+  // modern layout semantics and handle TS syntax natively.
   "arrow-parens",
   "indent",
   "computed-property-spacing",
@@ -28458,15 +28509,125 @@ var BLACKLISTED_RULES = /* @__PURE__ */ new Set([
   "semi",
   "comma-dangle",
   "no-mixed-spaces-and-tabs",
-  // --- @typescript-eslint formatting rules that conflict with @stylistic ---
+  // `@typescript-eslint/brace-style` and `@typescript-eslint/indent` are
+  // also deprecated in favour of the `@stylistic` equivalents for the
+  // same reason.
   "@typescript-eslint/brace-style",
   "@typescript-eslint/indent"
 ]);
-var BLACKLISTED_RULE_PATTERNS = [/^unused-imports\/.*-ts$/];
+var requireAnyUserParam = (pattern) => !pattern.parameters || Object.keys(pattern.parameters).length === 0;
+var CONDITIONAL_BLACKLIST = /* @__PURE__ */ new Map([
+  // `ember/no-restricted-service-injections` requires at least one of
+  // `paths` or `services` to have a non-empty entry — without a real
+  // value the plugin's own JSON schema rejects the options and aborts
+  // the whole run. Codacy's declared default is `[""]` (an array with
+  // a single empty string) which is nonsensical as a match list. Only
+  // keep the rule when the user has actually configured something.
+  [
+    "ember/no-restricted-service-injections",
+    (pattern) => !hasUserSuppliedAny(pattern, "services", "paths")
+  ],
+  // `ember/no-restricted-property-modifications` has the same pattern:
+  // it takes a list of property names to watch, and is unusable without
+  // one.
+  [
+    "ember/no-restricted-property-modifications",
+    (pattern) => !hasUserSuppliedAny(pattern, "properties")
+  ],
+  // `jsonc/sort-array-values` / `jsonc/sort-keys` need a non-empty
+  // `pathPattern` or `order` — the default placeholder (`^$` / `{}`)
+  // matches nothing meaningful and makes the rule schema-invalid.
+  ["jsonc/sort-array-values", (pattern) => !hasUserSuppliedAny(pattern, "pathPattern", "order")],
+  ["jsonc/sort-keys", (pattern) => !hasUserSuppliedAny(pattern, "pathPattern", "order")],
+  // `jest/no-deprecated-functions` inspects the analysed project's
+  // installed jest version at rule-load time. In a repo without jest
+  // in `package.json` the rule throws `Unable to detect Jest version`
+  // after ESLint has already walked every file, aborting the whole
+  // run. Skip the rule when the target repo has no jest dependency.
+  ["jest/no-deprecated-functions", (_p, ctx) => !hasTargetDependency(ctx.repositoryRoot, "jest")],
+  // `eslint-plugin-check-file` rules require the user to supply a
+  // non-empty naming-pattern object. Without it, each rule fires on
+  // *every* JS/TS file with
+  //   `The naming pattern object "undefined" does not appear to be an
+  //    Object type, please double-check it and try again`
+  // Codacy's `patterns.json` exposes no parameters for these rules, so
+  // they are never useful without a user-provided override. If a user
+  // supplies a `rules` / `patterns` parameter, trust them and run.
+  ["check-file/filename-blocklist", requireAnyUserParam],
+  ["check-file/filename-naming-convention", requireAnyUserParam],
+  ["check-file/folder-match-with-fex", requireAnyUserParam],
+  ["check-file/folder-naming-convention", requireAnyUserParam],
+  // `jsdoc/no-missing-syntax` requires a non-empty `contexts` option.
+  // The Codacy-declared default is `[]`, which the rule itself rejects
+  // at runtime with
+  //   `Rule no-missing-syntax is missing a 'contexts' option`
+  // Skip unless the user has supplied a real value.
+  ["jsdoc/no-missing-syntax", (pattern) => !hasUserSuppliedAny(pattern, "contexts")],
+  // `jsdoc/imports-as-dependencies` synchronously reads the analysed
+  // repo's `package.json` to verify every `@import` tag references a
+  // listed dependency. If the file is missing the rule crashes with
+  //   `ENOENT: no such file or directory, open '<root>/package.json'`
+  // and that sync throw propagates through the rule visitor, aborting
+  // the run mid-way. Skip the rule unless the target repo actually
+  // has a `package.json`.
+  ["jsdoc/imports-as-dependencies", (_p, ctx) => !hasTargetPackageJson(ctx.repositoryRoot)]
+]);
+function hasUserSuppliedAny(pattern, ...paramNames) {
+  const params = pattern.parameters;
+  if (!params) return false;
+  for (const name of paramNames) {
+    const raw = params[name];
+    if (raw === void 0 || raw === "") continue;
+    const parsed = tryParseCollection(raw);
+    if (Array.isArray(parsed)) {
+      if (parsed.length > 0 && parsed.some((v) => v !== "" && v != null)) return true;
+    } else if (parsed && typeof parsed === "object") {
+      if (Object.keys(parsed).length > 0) return true;
+    } else if (typeof parsed === "string") {
+      if (parsed.length > 0 && parsed !== "^$") return true;
+    } else if (parsed !== void 0 && parsed !== null) {
+      return true;
+    }
+  }
+  return false;
+}
+function tryParseCollection(raw) {
+  const trimmed = raw.trim();
+  if (trimmed.startsWith("[") && trimmed.endsWith("]") || trimmed.startsWith("{") && trimmed.endsWith("}")) {
+    try {
+      return JSON.parse(trimmed);
+    } catch {
+    }
+  }
+  return trimmed;
+}
+function hasTargetPackageJson(repositoryRoot) {
+  try {
+    import_fs.default.accessSync(import_path.default.join(repositoryRoot, "package.json"), import_fs.default.constants.R_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function hasTargetDependency(repositoryRoot, dependencyName) {
+  try {
+    const pkgPath = import_path.default.join(repositoryRoot, "package.json");
+    const raw = import_fs.default.readFileSync(pkgPath, "utf-8");
+    const pkg = JSON.parse(raw);
+    return !!pkg.dependencies?.[dependencyName] || !!pkg.devDependencies?.[dependencyName] || !!pkg.peerDependencies?.[dependencyName] || !!pkg.optionalDependencies?.[dependencyName];
+  } catch {
+    return false;
+  }
+}
 function isBlacklisted(ruleId) {
   if (BLACKLISTED_RULES.has(ruleId)) return true;
   return BLACKLISTED_RULE_PATTERNS.some((re) => re.test(ruleId));
 }
+function shouldSkipRule(ruleId, pattern, ctx) {
+  if (isBlacklisted(ruleId)) return true;
+  const predicate = CONDITIONAL_BLACKLIST.get(ruleId);
+  return predicate ? predicate(pattern, ctx) : false;
+}
 
 // src/plugin-registry.ts
 async function loadPlugin(packageName) {
@@ -28609,6 +28770,30 @@ function extractPluginPrefix(ruleId) {
 }
 
 // src/config-builder.ts
+var TSCONFIG_CANDIDATES = [
+  "tsconfig.json",
+  "tsconfig.base.json",
+  "tsconfig.eslint.json",
+  "jsconfig.json"
+];
+function hasTypeScriptProjectConfig(repositoryRoot) {
+  for (const name of TSCONFIG_CANDIDATES) {
+    try {
+      import_fs2.default.accessSync(import_path2.default.join(repositoryRoot, name));
+      return true;
+    } catch {
+    }
+  }
+  return false;
+}
+var PATTERN_DEFAULTS = new Map(
+  patterns_default.filter((p) => Array.isArray(p.parameters) && p.parameters.length > 0).map((p) => [
+    p.id,
+    Object.fromEntries(
+      (p.parameters ?? []).filter((param) => param.default !== void 0).map((param) => [param.name, param.default ?? ""])
+    )
+  ])
+);
 var TOOL_ID = "ESLint9";
 var PREFIX = `${TOOL_ID}_`;
 var CORE_TO_TS_EXTENSION = /* @__PURE__ */ new Map([
@@ -28645,11 +28830,11 @@ function decodePatternId(patternId) {
 function encodePatternId(ruleId) {
   return `${PREFIX}${ruleId.replace(/_/g, "__").replace(/\//g, "_")}`;
 }
-async function buildESLintConfig(patterns) {
+async function buildESLintConfig(patterns, ctx = { repositoryRoot: process.cwd() }) {
   const ruleEntries = [];
   for (const p of patterns) {
     const ruleId = decodePatternId(p.patternId);
-    if (isBlacklisted(ruleId)) continue;
+    if (shouldSkipRule(ruleId, p, ctx)) continue;
     ruleEntries.push({ ruleId, pattern: p });
   }
   const allRuleIds = ruleEntries.map((e) => e.ruleId);
@@ -28662,6 +28847,7 @@ async function buildESLintConfig(patterns) {
     if (!prefix) {
       coreRules[ruleId] = ruleValue;
     } else if (plugins.has(prefix)) {
+      if (!pluginExposesRule(plugins.get(prefix), prefix, ruleId)) continue;
       if (!pluginRuleGroups.has(prefix)) {
         pluginRuleGroups.set(prefix, {});
       }
@@ -28669,6 +28855,14 @@ async function buildESLintConfig(patterns) {
     }
   }
   const configs = [];
+  configs.push({
+    files: ["**/*.jsx", "**/*.tsx"],
+    languageOptions: {
+      parserOptions: {
+        ecmaFeatures: { jsx: true }
+      }
+    }
+  });
   if (Object.keys(coreRules).length > 0) {
     configs.push({
       files: ["**/*.js", "**/*.jsx", "**/*.mjs", "**/*.cjs", "**/*.ts", "**/*.tsx"],
@@ -28678,17 +28872,16 @@ async function buildESLintConfig(patterns) {
   const tsPlugin = plugins.get("@typescript-eslint");
   const tsRules = pluginRuleGroups.get("@typescript-eslint");
   if (tsRules && tsPlugin) {
+    const tsLanguageOptions = {
+      parser: await loadTsParser()
+    };
+    if (hasTypeScriptProjectConfig(ctx.repositoryRoot)) {
+      tsLanguageOptions.parserOptions = { projectService: true };
+    }
     configs.push({
       files: ["**/*.ts", "**/*.tsx"],
       plugins: { "@typescript-eslint": tsPlugin },
-      languageOptions: {
-        parser: await loadTsParser(),
-        parserOptions: {
-          projectService: {
-            allowDefaultProject: ["*.ts", "*.tsx"]
-          }
-        }
-      },
+      languageOptions: tsLanguageOptions,
       rules: tsRules
     });
     pluginRuleGroups.delete("@typescript-eslint");
@@ -28713,6 +28906,26 @@ async function buildESLintConfig(patterns) {
     if (prefix === "yml") {
       configItem.files = ["**/*.yml", "**/*.yaml"];
     }
+    if (prefix === "storybook") {
+      configItem.files = [
+        "**/*.stories.js",
+        "**/*.stories.jsx",
+        "**/*.stories.mjs",
+        "**/*.stories.cjs",
+        "**/*.stories.ts",
+        "**/*.stories.tsx",
+        "**/*.story.js",
+        "**/*.story.jsx",
+        "**/*.story.mjs",
+        "**/*.story.cjs",
+        "**/*.story.ts",
+        "**/*.story.tsx"
+      ];
+    }
+    if (prefix === "react") {
+      const version = hasTargetDependency(ctx.repositoryRoot, "react") ? "detect" : "999.999.999";
+      configItem.settings = { react: { version } };
+    }
     configs.push(configItem);
   }
   const tsOverrideRules = {};
@@ -28734,16 +28947,18 @@ async function buildESLintConfig(patterns) {
   return configs;
 }
 function buildRuleValue(pattern) {
-  if (!pattern.parameters || Object.keys(pattern.parameters).length === 0) {
+  const defaults = PATTERN_DEFAULTS.get(pattern.patternId) ?? {};
+  const merged = { ...defaults, ...pattern.parameters ?? {} };
+  if (Object.keys(merged).length === 0) {
     return "error";
   }
   const result = ["error"];
   const optionsObj = {};
-  for (const [name, rawValue] of Object.entries(pattern.parameters)) {
+  for (const [name, rawValue] of Object.entries(merged)) {
     const value = parseParamValue(rawValue);
     if (name === "unnamedParam") {
       result.splice(1, 0, value);
-    } else {
+    } else if (!isEmptyCollection(value)) {
       optionsObj[name] = value;
     }
   }
@@ -28752,6 +28967,13 @@ function buildRuleValue(pattern) {
   }
   return result.length === 1 ? "error" : result;
 }
+function isEmptyCollection(value) {
+  if (Array.isArray(value)) return value.length === 0;
+  if (value !== null && typeof value === "object") {
+    return Object.keys(value).length === 0;
+  }
+  return false;
+}
 function parseParamValue(value) {
   const trimmed = value.trim();
   if (trimmed === "true") return true;
@@ -28770,6 +28992,15 @@ async function loadTsParser() {
   const mod = await import("typescript-eslint");
   return mod.default?.parser ?? mod.parser;
 }
+function pluginExposesRule(plugin, prefix, fullRuleId) {
+  if (!plugin || typeof plugin !== "object") return false;
+  const rules = plugin.rules;
+  if (!rules || typeof rules !== "object") {
+    return true;
+  }
+  const shortName = fullRuleId.startsWith(prefix + "/") ? fullRuleId.slice(prefix.length + 1) : fullRuleId;
+  return Object.prototype.hasOwnProperty.call(rules, shortName);
+}
 
 // src/metadata.ts
 var descriptor = {
@@ -28806,14 +29037,75 @@ function ruleMetadata(ruleId) {
   const patternId = encodePatternId(ruleId);
   return PATTERN_META.get(patternId) ?? { category: "BestPractice", severity: "Info" };
 }
-function readLine(filePath, lineNumber) {
-  try {
-    const content = import_fs.default.readFileSync(filePath, "utf-8");
-    const lines = content.split("\n");
-    return lines[lineNumber - 1] ?? "";
-  } catch {
-    return "";
+var PROBE_SNIPPETS = [
+  { filePath: "__codacy_probe__.js", source: "var x=0;\n" },
+  { filePath: "__codacy_probe__.jsx", source: "const x=<div/>;\n" },
+  { filePath: "__codacy_probe__.ts", source: "const x: number = 0;\n" },
+  { filePath: "__codacy_probe__.tsx", source: "const x:unknown=<div/>;\n" },
+  { filePath: "__codacy_probe__.vue", source: "<template><div/></template>\n" },
+  { filePath: "__codacy_probe__.svelte", source: "<div></div>\n" },
+  { filePath: "__codacy_probe__.json", source: "{}\n" },
+  { filePath: "__codacy_probe__.yml", source: "a: 1\n" },
+  { filePath: "__codacy_probe__.md", source: "# probe\n" }
+];
+async function probeConfig(eslint, repositoryRoot) {
+  for (const { filePath, source } of PROBE_SNIPPETS) {
+    try {
+      await eslint.lintText(source, { filePath: import_path3.default.join(repositoryRoot, filePath) });
+    } catch (err) {
+      return err instanceof Error ? err : new Error(String(err));
+    }
   }
+  return void 0;
+}
+function truncateForError(message) {
+  const oneLine = message.replace(/\s+/g, " ").trim();
+  return oneLine.length > 240 ? oneLine.slice(0, 237) + "\u2026" : oneLine;
+}
+function extractInvalidRule(message) {
+  const flatMatch = message.match(/Key "rules":\s*Key "([^"]+)"/);
+  if (flatMatch) return flatMatch[1];
+  const legacyMatch = message.match(/Configuration for rule "([^"]+)" is invalid/);
+  if (legacyMatch) return legacyMatch[1];
+  const loadMatch = message.match(/Error while loading rule ['"]([^'"]+)['"]/);
+  if (loadMatch) return loadMatch[1];
+  const trailingRule = message.match(/Rule: ['"]([^'"]+)['"]/);
+  if (trailingRule) return trailingRule[1];
+  return void 0;
+}
+function removeRuleFromFlatConfig(config, ruleId) {
+  if (!Array.isArray(config)) return false;
+  let removed = false;
+  for (const entry of config) {
+    if (entry?.rules && Object.prototype.hasOwnProperty.call(entry.rules, ruleId)) {
+      delete entry.rules[ruleId];
+      removed = true;
+    }
+  }
+  return removed;
+}
+function isParserServicesError(message) {
+  return /requires parserServices|parserOptions\.project|requires type information/.test(message);
+}
+function rulePluginPrefix(ruleId) {
+  const slashIdx = ruleId.indexOf("/");
+  if (slashIdx <= 0) return void 0;
+  return ruleId.slice(0, slashIdx);
+}
+function removeRulesByPluginFromFlatConfig(config, pluginPrefix) {
+  if (!Array.isArray(config)) return [];
+  const removed = [];
+  const prefix = pluginPrefix + "/";
+  for (const entry of config) {
+    if (!entry?.rules) continue;
+    for (const key of Object.keys(entry.rules)) {
+      if (key.startsWith(prefix)) {
+        delete entry.rules[key];
+        if (!removed.includes(key)) removed.push(key);
+      }
+    }
+  }
+  return removed;
 }
 var adapter = {
   ...descriptor,
@@ -28854,9 +29146,9 @@ var adapter = {
   async checkLocalConfigurationFile(ctx) {
     ctx.logger.debug("Checking for local config", { toolId: TOOL_ID2 });
     for (const name of LOCAL_CONFIG_FILES) {
-      const candidate = import_path.default.join(ctx.repositoryRoot, name);
+      const candidate = import_path3.default.join(ctx.repositoryRoot, name);
       try {
-        import_fs.default.accessSync(candidate);
+        import_fs3.default.accessSync(candidate);
         ctx.logger.debug("Local config found", { toolId: TOOL_ID2, path: candidate });
         return { found: true, path: candidate };
       } catch {
@@ -28878,7 +29170,7 @@ var adapter = {
     const startedAt = /* @__PURE__ */ new Date();
     const issues = [];
     const errors = [];
-    const absoluteFiles = ctx.targetFiles.map((f) => import_path.default.resolve(ctx.repositoryRoot, f));
+    const absoluteFiles = ctx.targetFiles.map((f) => import_path3.default.resolve(ctx.repositoryRoot, f));
     if (absoluteFiles.length === 0) {
       const completedAt2 = /* @__PURE__ */ new Date();
       return (0, import_tooling.buildResult)(TOOL_ID2, startedAt, completedAt2, issues, errors, ctx.targetFiles.length);
@@ -28902,10 +29194,19 @@ var adapter = {
     if (codacyConfig.useLocalConfigurationFile && codacyConfig.localConfigurationFile) {
       eslintOptions.overrideConfigFile = codacyConfig.localConfigurationFile;
     } else if (codacyConfig.patterns.length > 0) {
+      const buildStartMs = Date.now();
       try {
-        const config = await buildESLintConfig(codacyConfig.patterns);
+        const config = await buildESLintConfig(codacyConfig.patterns, {
+          repositoryRoot: ctx.repositoryRoot
+        });
         eslintOptions.overrideConfig = config;
         eslintOptions.overrideConfigFile = true;
+        ctx.logger.debug("Flat config built", {
+          toolId: TOOL_ID2,
+          durationMs: Date.now() - buildStartMs,
+          configEntries: Array.isArray(config) ? config.length : 0,
+          patternCount: codacyConfig.patterns.length
+        });
       } catch (err) {
         errors.push({
           toolId: TOOL_ID2,
@@ -28923,14 +29224,130 @@ var adapter = {
       return (0, import_tooling.buildResult)(TOOL_ID2, startedAt, /* @__PURE__ */ new Date(), issues, errors, ctx.targetFiles.length);
     }
     const enabledPatterns = new Set(codacyConfig.patterns.map((p) => p.patternId));
+    const MAX_CONFIG_RETRIES = 30;
+    let attempt = 0;
+    let results = [];
     try {
-      const eslint = new ESLintClass(eslintOptions);
-      const results = await eslint.lintFiles(absoluteFiles);
+      const probeStartMs = Date.now();
+      let lastProbeFailure;
+      while (attempt <= MAX_CONFIG_RETRIES) {
+        const probeEslint = new ESLintClass(eslintOptions);
+        const failure = await probeConfig(probeEslint, ctx.repositoryRoot);
+        if (!failure) {
+          lastProbeFailure = void 0;
+          break;
+        }
+        lastProbeFailure = failure;
+        const rule = extractInvalidRule(failure.message);
+        if (!rule) throw failure;
+        if (isParserServicesError(failure.message)) {
+          const prefix = rulePluginPrefix(rule);
+          if (prefix) {
+            const removedRules = removeRulesByPluginFromFlatConfig(
+              eslintOptions.overrideConfig,
+              prefix
+            );
+            if (removedRules.length > 0) {
+              ctx.logger.warn("Skipping plugin requiring parserServices", {
+                toolId: TOOL_ID2,
+                plugin: prefix,
+                count: removedRules.length
+              });
+              errors.push({
+                toolId: TOOL_ID2,
+                phase: "toolConfig",
+                kind: "InvalidRuleConfig",
+                message: `Plugin "${prefix}/*" (${removedRules.length} rule${removedRules.length === 1 ? "" : "s"}) skipped: requires typescript-eslint parserServices (no tsconfig.json in the analysed repo).`,
+                level: "warning"
+              });
+              attempt++;
+              continue;
+            }
+          }
+        }
+        const removed = removeRuleFromFlatConfig(eslintOptions.overrideConfig, rule);
+        if (!removed) throw failure;
+        ctx.logger.warn("Skipping rule rejected during probe", { toolId: TOOL_ID2, rule });
+        errors.push({
+          toolId: TOOL_ID2,
+          phase: "toolConfig",
+          kind: "InvalidRuleConfig",
+          message: `Rule "${rule}" was skipped: ${truncateForError(failure.message)}`,
+          level: "warning"
+        });
+        attempt++;
+      }
+      ctx.logger.debug("Config probe complete", {
+        toolId: TOOL_ID2,
+        durationMs: Date.now() - probeStartMs,
+        rulesSkipped: attempt
+      });
+      if (lastProbeFailure) throw lastProbeFailure;
+      while (true) {
+        try {
+          const instantiateStartMs = Date.now();
+          const eslint = new ESLintClass(eslintOptions);
+          ctx.logger.debug("ESLint instance created", {
+            toolId: TOOL_ID2,
+            durationMs: Date.now() - instantiateStartMs
+          });
+          const lintStartMs = Date.now();
+          results = await eslint.lintFiles(absoluteFiles);
+          ctx.logger.debug("lintFiles() complete", {
+            toolId: TOOL_ID2,
+            durationMs: Date.now() - lintStartMs,
+            fileCount: results.length
+          });
+          break;
+        } catch (err) {
+          const rule = err instanceof Error ? extractInvalidRule(err.message) : void 0;
+          if (!rule || attempt >= MAX_CONFIG_RETRIES) throw err;
+          const parserServicesCause = err instanceof Error && isParserServicesError(err.message);
+          const prefix = rulePluginPrefix(rule);
+          if (prefix) {
+            const removedRules = removeRulesByPluginFromFlatConfig(
+              eslintOptions.overrideConfig,
+              prefix
+            );
+            if (removedRules.length > 0) {
+              const message = parserServicesCause ? `Plugin "${prefix}/*" (${removedRules.length} rule${removedRules.length === 1 ? "" : "s"}) skipped: requires typescript-eslint parserServices (no tsconfig.json / tsconfig.base.json / tsconfig.eslint.json / jsconfig.json found at the repository root).` : `Plugin "${prefix}/*" (${removedRules.length} rule${removedRules.length === 1 ? "" : "s"}) skipped after lintFiles failure on "${rule}": ${truncateForError(err instanceof Error ? err.message : String(err))}`;
+              ctx.logger.warn(
+                parserServicesCause ? "Skipping plugin requiring parserServices" : "Skipping plugin that failed during lintFiles",
+                { toolId: TOOL_ID2, plugin: prefix, count: removedRules.length, rule }
+              );
+              errors.push({
+                toolId: TOOL_ID2,
+                phase: "toolConfig",
+                kind: "InvalidRuleConfig",
+                message,
+                level: "warning"
+              });
+              attempt++;
+              continue;
+            }
+          }
+          const removed = removeRuleFromFlatConfig(eslintOptions.overrideConfig, rule);
+          if (!removed) throw err;
+          ctx.logger.warn("Skipping rule that failed during lintFiles", { toolId: TOOL_ID2, rule });
+          errors.push({
+            toolId: TOOL_ID2,
+            phase: "toolConfig",
+            kind: "InvalidRuleConfig",
+            message: `Rule "${rule}" was skipped after lintFiles failure: ${truncateForError(err instanceof Error ? err.message : String(err))}`,
+            level: "warning"
+          });
+          attempt++;
+        }
+      }
       for (const fileResult of results) {
-        const relPath = import_path.default.relative(ctx.repositoryRoot, fileResult.filePath);
+        if (fileResult.messages.length === 0) continue;
+        const relPath = import_path3.default.relative(ctx.repositoryRoot, fileResult.filePath);
+        let lines;
         for (const msg of fileResult.messages) {
           if (!msg.ruleId) continue;
           if (isBlacklisted(msg.ruleId)) continue;
+          if (msg.message.startsWith("Definition for rule ")) continue;
+          if (msg.line === 0) continue;
           const patternId = encodePatternId(msg.ruleId);
           if (enabledPatterns.size > 0 && !enabledPatterns.has(patternId)) continue;
           const meta = ruleMetadata(msg.ruleId);
@@ -28938,6 +29355,9 @@ var adapter = {
           if (msg.suggestions && msg.suggestions.length > 0) {
             suggestion = msg.suggestions[0].desc;
           }
+          if (lines === void 0) {
+            lines = await (0, import_tooling.readFileLines)(fileResult.filePath);
+          }
           issues.push({
             filePath: relPath,
             patternId,
@@ -28947,7 +29367,7 @@ var adapter = {
             endLine: msg.endLine,
             endColumn: msg.endColumn,
             message: msg.message,
-            lineContent: readLine(fileResult.filePath, msg.line),
+            lineContent: (0, import_tooling.getLineContent)(lines, msg.line),
             category: meta.category,
             severity: meta.severity,
             suggestion

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codacy/tools-eslint-9",
-  "version": "0.6.0",
+  "version": "0.6.1",
   "description": "ESLint 9 adapter — Library-mode JavaScript/TypeScript linter",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -8,21 +8,21 @@
     "dist"
   ],
   "dependencies": {
-    "eslint": "^9.0.0",
-    "@eslint/js": "^9.0.0",
+    "eslint": "^9.38.0",
+    "@eslint/js": "^9.38.0",
     "typescript-eslint": "^8.0.0",
     "globals": "^16.5.0",
     "@angular-eslint/eslint-plugin": "^19.0.0",
-    "@lwc/eslint-plugin-lwc": "^1.0.0",
-    "@salesforce/eslint-plugin-lightning": "^1.0.0",
-    "@shopify/eslint-plugin": "^46.0.0",
+    "@lwc/eslint-plugin-lwc": "^3.0.0",
+    "@salesforce/eslint-plugin-lightning": "^2.0.0",
+    "@shopify/eslint-plugin": "^48.0.2",
     "@stylistic/eslint-plugin": "^4.0.0",
     "@tanstack/eslint-plugin-query": "^5.0.0",
     "@vitest/eslint-plugin": "^1.0.0",
     "eslint-plugin-angular": "^4.0.0",
-    "eslint-plugin-ava": "^14.0.0",
+    "eslint-plugin-ava": "^15.0.1",
     "eslint-plugin-backbone": "^2.0.0",
-    "eslint-plugin-check-file": "^2.0.0",
+    "eslint-plugin-check-file": "^3.2.0",
     "eslint-plugin-compat": "^6.0.0",
     "eslint-plugin-cypress": "^4.0.0",
     "eslint-plugin-ember": "^12.0.0",
@@ -30,22 +30,22 @@
     "eslint-plugin-es-x": "^8.0.0",
     "eslint-plugin-eslint-plugin": "^6.0.0",
     "eslint-plugin-fp": "^2.0.0",
-    "eslint-plugin-functional": "^7.0.0",
+    "eslint-plugin-functional": "^9.0.1",
     "eslint-plugin-i18next": "^6.0.0",
     "eslint-plugin-import": "^2.0.0",
     "eslint-plugin-jasmine": "^4.0.0",
     "eslint-plugin-jest": "^28.0.0",
     "eslint-plugin-jest-dom": "^5.0.0",
-    "eslint-plugin-jest-extended": "^2.0.0",
+    "eslint-plugin-jest-extended": "^3.0.0",
     "eslint-plugin-jest-formatting": "^3.0.0",
     "eslint-plugin-jsdoc": "^50.0.0",
     "eslint-plugin-jsonc": "^2.0.0",
     "eslint-plugin-jsx-a11y": "^6.0.0",
-    "eslint-plugin-lit": "^1.0.0",
+    "eslint-plugin-lit": "^2.1.1",
     "eslint-plugin-lodash": "^8.0.0",
     "eslint-plugin-lodash-fp": "^2.0.0",
     "eslint-plugin-meteor": "^7.0.0",
-    "eslint-plugin-mocha": "^10.0.0",
+    "eslint-plugin-mocha": "^11.0.0",
     "eslint-plugin-n": "^17.0.0",
     "eslint-plugin-nuxt": "^4.0.0",
     "eslint-plugin-perfectionist": "^4.0.0",
@@ -53,7 +53,7 @@
     "eslint-plugin-prettier": "^5.0.0",
     "eslint-plugin-promise": "^7.0.0",
     "eslint-plugin-react": "^7.0.0",
-    "eslint-plugin-react-hooks": "^5.0.0",
+    "eslint-plugin-react-hooks": "^7.0.1",
     "eslint-plugin-react-perf": "^3.0.0",
     "eslint-plugin-react-redux": "^4.0.0",
     "eslint-plugin-redux-saga": "^1.0.0",
@@ -61,7 +61,7 @@
     "eslint-plugin-security": "^3.0.0",
     "eslint-plugin-security-node": "^1.0.0",
     "eslint-plugin-sonarjs": "^3.0.0",
-    "eslint-plugin-sort": "^3.0.0",
+    "eslint-plugin-sort": "^4.0.0",
     "eslint-plugin-sort-destructure-keys": "^2.0.0",
     "eslint-plugin-storybook": "^0.11.0",
     "eslint-plugin-suitescript": "^1.0.0",
@@ -70,16 +70,16 @@
     "eslint-plugin-test-selectors": "^2.0.0",
     "eslint-plugin-testing-library": "^7.0.0",
     "eslint-plugin-typescript-sort-keys": "^3.0.0",
-    "eslint-plugin-unicorn": "^57.0.0",
+    "eslint-plugin-unicorn": "^62.0.0",
     "eslint-plugin-unused-imports": "^4.0.0",
-    "eslint-plugin-vue": "^9.0.0",
+    "eslint-plugin-vue": "^10.1.0",
     "eslint-plugin-vue-scoped-css": "^2.0.0",
     "eslint-plugin-vuejs-accessibility": "^2.0.0",
     "eslint-plugin-vuetify": "^2.0.0",
     "eslint-plugin-wdio": "^9.0.0",
     "eslint-plugin-xss": "^0.1.0",
     "eslint-plugin-yml": "^1.0.0",
-    "@codacy/tooling": "0.6.0"
+    "@codacy/tooling": "0.6.1"
   },
   "license": "MIT",
   "author": "Codacy <support@codacy.com> (https://www.codacy.com)",