@code-pushup/eslint-plugin 0.35.0 → 0.42.0

package/index.js

@@ -1,35 +1,298 @@
 // packages/plugin-eslint/src/lib/eslint-plugin.ts
-import { mkdir as mkdir2, writeFile as writeFile2 } from "node:fs/promises";
 import { dirname as dirname2, join as join3 } from "node:path";
 import { fileURLToPath } from "node:url";
 
 // packages/plugin-eslint/package.json
 var name = "@code-pushup/eslint-plugin";
-var version = "0.35.0";
+var version = "0.42.0";
 
 // packages/plugin-eslint/src/lib/config.ts
-import { z } from "zod";
-var eslintPluginConfigSchema = z.object({
-  eslintrc: z.union(
-    [
-      z.string({ description: "Path to ESLint config file" }),
-      z.record(z.string(), z.unknown(), {
-        description: "ESLint config object"
-      })
-    ],
-    { description: "ESLint config as file path or inline object" }
-  ),
-  patterns: z.union([z.string(), z.array(z.string()).min(1)], {
-    description: "Lint target files. May contain file paths, directory paths or glob patterns"
-  })
-});
+import { z as z16 } from "zod";
 
-// packages/models/src/lib/audit.ts
-import { z as z3 } from "zod";
+// packages/utils/src/lib/text-formats/constants.ts
+var NEW_LINE = "\n";
+var TAB = "  ";
+
+// packages/utils/src/lib/text-formats/html/details.ts
+function details(title, content, cfg = { open: false }) {
+  return `<details${cfg.open ? " open" : ""}>${NEW_LINE}<summary>${title}</summary>${NEW_LINE}${// ⚠️ The blank line is needed to ensure Markdown in content is rendered correctly.
+  NEW_LINE}${content}${NEW_LINE}${// @TODO in the future we could consider adding it only if the content ends with a code block
+  // ⚠️ The blank line ensure Markdown in content is rendered correctly.
+  NEW_LINE}</details>${// ⚠️ The blank line is needed to ensure Markdown after details is rendered correctly.
+  NEW_LINE}`;
+}
+
+// packages/utils/src/lib/text-formats/html/font-style.ts
+var boldElement = "b";
+function bold(text) {
+  return `<${boldElement}>${text}</${boldElement}>`;
+}
+var italicElement = "i";
+function italic(text) {
+  return `<${italicElement}>${text}</${italicElement}>`;
+}
+var codeElement = "code";
+function code(text) {
+  return `<${codeElement}>${text}</${codeElement}>`;
+}
+
+// packages/utils/src/lib/text-formats/html/link.ts
+function link(href, text) {
+  return `<a href="${href}">${text || href}"</a>`;
+}
+
+// packages/utils/src/lib/transform.ts
+function toArray(val) {
+  return Array.isArray(val) ? val : [val];
+}
+function objectToKeys(obj) {
+  return Object.keys(obj);
+}
+function distinct(array) {
+  return [...new Set(array)];
+}
+function capitalize(text) {
+  return `${text.charAt(0).toLocaleUpperCase()}${text.slice(
+    1
+  )}`;
+}
+
+// packages/utils/src/lib/table.ts
+function rowToStringArray({ rows, columns = [] }) {
+  if (Array.isArray(rows.at(0)) && typeof columns.at(0) === "object") {
+    throw new TypeError(
+      "Column can`t be object when rows are primitive values"
+    );
+  }
+  return rows.map((row) => {
+    if (Array.isArray(row)) {
+      return row.map(String);
+    }
+    const objectRow = row;
+    if (columns.length === 0 || typeof columns.at(0) === "string") {
+      return Object.values(objectRow).map(String);
+    }
+    return columns.map(
+      ({ key }) => String(objectRow[key])
+    );
+  });
+}
+function columnsToStringArray({ rows, columns = [] }) {
+  const firstRow = rows.at(0);
+  const primitiveRows = Array.isArray(firstRow);
+  if (typeof columns.at(0) === "string" && !primitiveRows) {
+    throw new Error("invalid union type. Caught by model parsing.");
+  }
+  if (columns.length === 0) {
+    if (Array.isArray(firstRow)) {
+      return firstRow.map((_, idx) => String(idx));
+    }
+    return Object.keys(firstRow);
+  }
+  if (typeof columns.at(0) === "string") {
+    return columns.map(String);
+  }
+  const cols = columns;
+  return cols.map(({ label, key }) => label ?? capitalize(key));
+}
+function getColumnAlignmentForKeyAndIndex(targetKey, targetIdx, columns = []) {
+  const column = columns.at(targetIdx) ?? columns.find((col) => col.key === targetKey);
+  if (typeof column === "string") {
+    return column;
+  } else if (typeof column === "object") {
+    return column.align ?? "center";
+  } else {
+    return "center";
+  }
+}
+function getColumnAlignmentForIndex(targetIdx, columns = []) {
+  const column = columns.at(targetIdx);
+  if (column == null) {
+    return "center";
+  } else if (typeof column === "string") {
+    return column;
+  } else if (typeof column === "object") {
+    return column.align ?? "center";
+  } else {
+    return "center";
+  }
+}
+function getColumnAlignments({
+  rows,
+  columns = []
+}) {
+  if (rows.at(0) == null) {
+    throw new Error("first row can`t be undefined.");
+  }
+  if (Array.isArray(rows.at(0))) {
+    const firstPrimitiveRow = rows.at(0);
+    return Array.from({ length: firstPrimitiveRow.length }).map(
+      (_, idx) => getColumnAlignmentForIndex(idx, columns)
+    );
+  }
+  const firstObject = rows.at(0);
+  return Object.keys(firstObject).map(
+    (key, idx) => getColumnAlignmentForKeyAndIndex(key, idx, columns)
+  );
+}
+
+// packages/utils/src/lib/text-formats/html/table.ts
+function wrap(elem, content) {
+  return `<${elem}>${content}</${elem}>${NEW_LINE}`;
+}
+function wrapRow(content) {
+  const elem = "tr";
+  return `<${elem}>${NEW_LINE}${content}</${elem}>${NEW_LINE}`;
+}
+function table(tableData) {
+  if (tableData.rows.length === 0) {
+    throw new Error("Data can't be empty");
+  }
+  const tableHeaderCols = columnsToStringArray(tableData).map((s) => wrap("th", s)).join("");
+  const tableHeaderRow = wrapRow(tableHeaderCols);
+  const tableBody = rowToStringArray(tableData).map((arr) => {
+    const columns = arr.map((s) => wrap("td", s)).join("");
+    return wrapRow(columns);
+  }).join("");
+  return wrap("table", `${NEW_LINE}${tableHeaderRow}${tableBody}`);
+}
+
+// packages/utils/src/lib/text-formats/md/font-style.ts
+var boldWrap = "**";
+function bold2(text) {
+  return `${boldWrap}${text}${boldWrap}`;
+}
+var italicWrap = "_";
+function italic2(text) {
+  return `${italicWrap}${text}${italicWrap}`;
+}
+var strikeThroughWrap = "~";
+function strikeThrough(text) {
+  return `${strikeThroughWrap}${text}${strikeThroughWrap}`;
+}
+var codeWrap = "`";
+function code2(text) {
+  return `${codeWrap}${text}${codeWrap}`;
+}
+
+// packages/utils/src/lib/text-formats/md/headline.ts
+function headline(text, hierarchy = 1) {
+  return `${"#".repeat(hierarchy)} ${text}${NEW_LINE}`;
+}
+function h(text, hierarchy = 1) {
+  return headline(text, hierarchy);
+}
+function h1(text) {
+  return headline(text, 1);
+}
+function h2(text) {
+  return headline(text, 2);
+}
+function h3(text) {
+  return headline(text, 3);
+}
+function h4(text) {
+  return headline(text, 4);
+}
+function h5(text) {
+  return headline(text, 5);
+}
+function h6(text) {
+  return headline(text, 6);
+}
+
+// packages/utils/src/lib/text-formats/md/image.ts
+function image(src, alt) {
+  return `![${alt}](${src})`;
+}
+
+// packages/utils/src/lib/text-formats/md/link.ts
+function link2(href, text) {
+  return `[${text || href}](${href})`;
+}
+
+// packages/utils/src/lib/text-formats/md/list.ts
+function li(text, order = "unordered") {
+  const style = order === "unordered" ? "-" : "- [ ]";
+  return `${style} ${text}`;
+}
+function indentation(text, level = 1) {
+  return `${TAB.repeat(level)}${text}`;
+}
+
+// packages/utils/src/lib/text-formats/md/paragraphs.ts
+function paragraphs(...sections) {
+  return sections.filter(Boolean).join(`${NEW_LINE}${NEW_LINE}`);
+}
+
+// packages/utils/src/lib/text-formats/md/section.ts
+function section(...contents) {
+  return `${lines(...contents)}${NEW_LINE}`;
+}
+function lines(...contents) {
+  return `${contents.filter(Boolean).join(NEW_LINE)}`;
+}
+
+// packages/utils/src/lib/text-formats/md/table.ts
+var alignString = /* @__PURE__ */ new Map([
+  ["left", ":--"],
+  ["center", ":--:"],
+  ["right", "--:"]
+]);
+function tableRow(rows) {
+  return `|${rows.join("|")}|`;
+}
+function table2(data) {
+  if (data.rows.length === 0) {
+    throw new Error("Data can't be empty");
+  }
+  const alignmentRow = getColumnAlignments(data).map(
+    (s) => alignString.get(s) ?? String(alignString.get("center"))
+  );
+  return section(
+    `${lines(
+      tableRow(columnsToStringArray(data)),
+      tableRow(alignmentRow),
+      ...rowToStringArray(data).map(tableRow)
+    )}`
+  );
+}
+
+// packages/utils/src/lib/text-formats/index.ts
+var md = {
+  bold: bold2,
+  italic: italic2,
+  strikeThrough,
+  code: code2,
+  link: link2,
+  image,
+  headline,
+  h,
+  h1,
+  h2,
+  h3,
+  h4,
+  h5,
+  h6,
+  indentation,
+  lines,
+  li,
+  section,
+  paragraphs,
+  table: table2
+};
+var html = {
+  bold,
+  italic,
+  code,
+  link,
+  details,
+  table
+};
 
 // packages/models/src/lib/implementation/schemas.ts
 import { MATERIAL_ICONS } from "vscode-material-icons";
-import { z as z2 } from "zod";
+import { z } from "zod";
 
 // packages/models/src/lib/implementation/limits.ts
 var MAX_SLUG_LENGTH = 128;
@@ -92,25 +355,26 @@ function missingRefsForCategoriesErrorMsg(categories, plugins) {
 }
 
 // packages/models/src/lib/implementation/schemas.ts
+var primitiveValueSchema = z.union([z.string(), z.number()]);
 function executionMetaSchema(options = {
   descriptionDate: "Execution start date and time",
   descriptionDuration: "Execution duration in ms"
 }) {
-  return z2.object({
-    date: z2.string({ description: options.descriptionDate }),
-    duration: z2.number({ description: options.descriptionDuration })
+  return z.object({
+    date: z.string({ description: options.descriptionDate }),
+    duration: z.number({ description: options.descriptionDuration })
   });
 }
-var slugSchema = z2.string({ description: "Unique ID (human-readable, URL-safe)" }).regex(slugRegex, {
+var slugSchema = z.string({ description: "Unique ID (human-readable, URL-safe)" }).regex(slugRegex, {
   message: "The slug has to follow the pattern [0-9a-z] followed by multiple optional groups of -[0-9a-z]. e.g. my-slug"
 }).max(MAX_SLUG_LENGTH, {
   message: `slug can be max ${MAX_SLUG_LENGTH} characters long`
 });
-var descriptionSchema = z2.string({ description: "Description (markdown)" }).max(MAX_DESCRIPTION_LENGTH).optional();
-var urlSchema = z2.string().url();
-var docsUrlSchema = urlSchema.optional().or(z2.literal("")).describe("Documentation site");
-var titleSchema = z2.string({ description: "Descriptive name" }).max(MAX_TITLE_LENGTH);
-var scoreSchema = z2.number({
+var descriptionSchema = z.string({ description: "Description (markdown)" }).max(MAX_DESCRIPTION_LENGTH).optional();
+var urlSchema = z.string().url();
+var docsUrlSchema = urlSchema.optional().or(z.literal("")).describe("Documentation site");
+var titleSchema = z.string({ description: "Descriptive name" }).max(MAX_TITLE_LENGTH);
+var scoreSchema = z.number({
   description: "Value between 0 and 1"
 }).min(0).max(1);
 function metaSchema(options) {
@@ -120,7 +384,7 @@ function metaSchema(options) {
     docsUrlDescription,
     description
   } = options ?? {};
-  return z2.object(
+  return z.object(
     {
       title: titleDescription ? titleSchema.describe(titleDescription) : titleSchema,
       description: descriptionDescription ? descriptionSchema.describe(descriptionDescription) : descriptionSchema,
@@ -129,17 +393,17 @@ function metaSchema(options) {
     { description }
   );
 }
-var filePathSchema = z2.string().trim().min(1, { message: "path is invalid" });
-var fileNameSchema = z2.string().trim().regex(filenameRegex, {
+var filePathSchema = z.string().trim().min(1, { message: "path is invalid" });
+var fileNameSchema = z.string().trim().regex(filenameRegex, {
   message: `The filename has to be valid`
 }).min(1, { message: "file name is invalid" });
-var positiveIntSchema = z2.number().int().positive();
-var nonnegativeIntSchema = z2.number().int().nonnegative();
+var positiveIntSchema = z.number().int().positive();
+var nonnegativeIntSchema = z.number().int().nonnegative();
 function packageVersionSchema(options) {
   const { versionDescription = "NPM version of the package", required } = options ?? {};
-  const packageSchema = z2.string({ description: "NPM package name" });
-  const versionSchema = z2.string({ description: versionDescription });
-  return z2.object(
+  const packageSchema = z.string({ description: "NPM package name" });
+  const versionSchema = z.string({ description: versionDescription });
+  return z.object(
     {
       packageName: required ? packageSchema : packageSchema.optional(),
       version: required ? versionSchema : versionSchema.optional()
@@ -151,7 +415,7 @@ var weightSchema = nonnegativeIntSchema.describe(
   "Coefficient for the given score (use weight 0 if only for display)"
 );
 function weightedRefSchema(description, slugDescription) {
-  return z2.object(
+  return z.object(
     {
       slug: slugSchema.describe(slugDescription),
       weight: weightSchema.describe("Weight used to calculate score")
@@ -160,10 +424,10 @@ function weightedRefSchema(description, slugDescription) {
   );
 }
 function scorableSchema(description, refSchema, duplicateCheckFn, duplicateMessageFn) {
-  return z2.object(
+  return z.object(
     {
       slug: slugSchema.describe('Human-readable unique ID, e.g. "performance"'),
-      refs: z2.array(refSchema).min(1).refine(
+      refs: z.array(refSchema).min(1).refine(
         (refs) => !duplicateCheckFn(refs),
         (refs) => ({
           message: duplicateMessageFn(refs)
@@ -175,7 +439,7 @@ function scorableSchema(description, refSchema, duplicateCheckFn, duplicateMessa
     { description }
   );
 }
-var materialIconSchema = z2.enum(MATERIAL_ICONS, {
+var materialIconSchema = z.enum(MATERIAL_ICONS, {
   description: "Icon from VSCode Material Icons extension"
 });
 function hasNonZeroWeightedRef(refs) {
@@ -183,7 +447,8 @@ function hasNonZeroWeightedRef(refs) {
 }
 
 // packages/models/src/lib/audit.ts
-var auditSchema = z3.object({
+import { z as z2 } from "zod";
+var auditSchema = z2.object({
   slug: slugSchema.describe("ID (unique within plugin)")
 }).merge(
   metaSchema({
@@ -193,7 +458,7 @@ var auditSchema = z3.object({
     description: "List of scorable metrics for the given plugin"
   })
 );
-var pluginAuditsSchema = z3.array(auditSchema, {
+var pluginAuditsSchema = z2.array(auditSchema, {
   description: "List of audits maintained in a plugin"
 }).min(1).refine(
   (auditMetadata) => !getDuplicateSlugsInAudits(auditMetadata),
@@ -215,11 +480,11 @@ function getDuplicateSlugsInAudits(audits) {
 import { z as z5 } from "zod";
 
 // packages/models/src/lib/issue.ts
-import { z as z4 } from "zod";
-var sourceFileLocationSchema = z4.object(
+import { z as z3 } from "zod";
+var sourceFileLocationSchema = z3.object(
   {
     file: filePathSchema.describe("Relative path to source file in Git repo"),
-    position: z4.object(
+    position: z3.object(
       {
         startLine: positiveIntSchema.describe("Start line"),
         startColumn: positiveIntSchema.describe("Start column").optional(),
@@ -231,24 +496,69 @@ var sourceFileLocationSchema = z4.object(
   },
   { description: "Source file location" }
 );
-var issueSeveritySchema = z4.enum(["info", "warning", "error"], {
+var issueSeveritySchema = z3.enum(["info", "warning", "error"], {
   description: "Severity level"
 });
-var issueSchema = z4.object(
+var issueSchema = z3.object(
   {
-    message: z4.string({ description: "Descriptive error message" }).max(MAX_ISSUE_MESSAGE_LENGTH),
+    message: z3.string({ description: "Descriptive error message" }).max(MAX_ISSUE_MESSAGE_LENGTH),
     severity: issueSeveritySchema,
     source: sourceFileLocationSchema.optional()
   },
   { description: "Issue information" }
 );
 
+// packages/models/src/lib/table.ts
+import { z as z4 } from "zod";
+var tableAlignmentSchema = z4.enum(["left", "center", "right"], {
+  description: "Cell alignment"
+});
+var tableColumnObjectSchema = z4.object({
+  key: z4.string(),
+  label: z4.string().optional(),
+  align: tableAlignmentSchema.optional()
+});
+var tableRowObjectSchema = z4.record(primitiveValueSchema, {
+  description: "Object row"
+});
+var tableRowPrimitiveSchema = z4.array(primitiveValueSchema, {
+  description: "Primitive row"
+});
+var tableSharedSchema = z4.object({
+  title: z4.string().optional().describe("Display title for table")
+});
+var tablePrimitiveSchema = tableSharedSchema.merge(
+  z4.object(
+    {
+      columns: z4.array(tableAlignmentSchema).optional(),
+      rows: z4.array(tableRowPrimitiveSchema)
+    },
+    { description: "Table with primitive rows and optional alignment columns" }
+  )
+);
+var tableObjectSchema = tableSharedSchema.merge(
+  z4.object(
+    {
+      columns: z4.union([
+        z4.array(tableAlignmentSchema),
+        z4.array(tableColumnObjectSchema)
+      ]).optional(),
+      rows: z4.array(tableRowObjectSchema)
+    },
+    {
+      description: "Table with object rows and optional alignment or object columns"
+    }
+  )
+);
+var tableSchema = (description = "Table information") => z4.union([tablePrimitiveSchema, tableObjectSchema], { description });
+
 // packages/models/src/lib/audit-output.ts
 var auditValueSchema = nonnegativeIntSchema.describe("Raw numeric value");
 var auditDisplayValueSchema = z5.string({ description: "Formatted value (e.g. '0.9 s', '2.1 MB')" }).optional();
 var auditDetailsSchema = z5.object(
   {
-    issues: z5.array(issueSchema, { description: "List of findings" })
+    issues: z5.array(issueSchema, { description: "List of findings" }).optional(),
+    table: tableSchema("Table of related findings").optional()
   },
   { description: "Detailed information" }
 );
@@ -600,10 +910,14 @@ function makeArraysComparisonSchema(diffSchema, resultSchema, description) {
     { description }
   );
 }
-var scorableMetaSchema = z15.object({ slug: slugSchema, title: titleSchema });
+var scorableMetaSchema = z15.object({
+  slug: slugSchema,
+  title: titleSchema,
+  docsUrl: docsUrlSchema
+});
 var scorableWithPluginMetaSchema = scorableMetaSchema.merge(
   z15.object({
-    plugin: pluginMetaSchema.pick({ slug: true, title: true }).describe("Plugin which defines it")
+    plugin: pluginMetaSchema.pick({ slug: true, title: true, docsUrl: true }).describe("Plugin which defines it")
   })
 );
 var scorableDiffSchema = scorableMetaSchema.merge(
@@ -740,7 +1054,7 @@ async function ensureDirectoryExists(baseDir) {
     await mkdir(baseDir, { recursive: true });
     return;
   } catch (error) {
-    ui().logger.error(error.message);
+    ui().logger.info(error.message);
     if (error.code !== "EEXIST") {
       throw error;
     }
@@ -750,27 +1064,65 @@ function pluginWorkDir(slug) {
   return join("node_modules", ".code-pushup", slug);
 }
 
-// packages/utils/src/lib/git.ts
+// packages/utils/src/lib/reports/utils.ts
+var { image: image2, bold: boldMd } = md;
+
+// packages/utils/src/lib/git/git.ts
 import { simpleGit } from "simple-git";
 
-// packages/utils/src/lib/transform.ts
-function toArray(val) {
-  return Array.isArray(val) ? val : [val];
-}
-function objectToKeys(obj) {
-  return Object.keys(obj);
-}
-function distinct(array) {
-  return [...new Set(array)];
-}
+// packages/utils/src/lib/git/git.commits-and-tags.ts
+import { simpleGit as simpleGit2 } from "simple-git";
+
+// packages/utils/src/lib/semver.ts
+import { rcompare, valid } from "semver";
 
 // packages/utils/src/lib/progress.ts
 import chalk3 from "chalk";
 import { MultiProgressBars } from "multi-progress-bars";
 
+// packages/utils/src/lib/reports/formatting.ts
+var { headline: headline2, lines: lines2, link: link3, section: section2, table: table3 } = md;
+
+// packages/utils/src/lib/reports/generate-md-report-categoy-section.ts
+var { link: link4, section: section3, h2: h22, lines: lines3, li: li2, bold: boldMd2, h3: h32, indentation: indentation2 } = md;
+
+// packages/utils/src/lib/reports/generate-md-report.ts
+var { h1: h12, h2: h23, h3: h33, lines: lines4, link: link5, section: section4, code: codeMd } = md;
+var { bold: boldHtml, details: details2 } = html;
+
+// packages/utils/src/lib/reports/generate-md-reports-diff.ts
+var {
+  h1: h13,
+  h2: h24,
+  lines: lines5,
+  link: link6,
+  bold: boldMd3,
+  italic: italicMd,
+  table: table4,
+  section: section5
+} = md;
+var { details: details3 } = html;
+
 // packages/utils/src/lib/reports/log-stdout-summary.ts
 import chalk4 from "chalk";
 
+// packages/plugin-eslint/src/lib/config.ts
+var eslintTargetSchema = z16.object({
+  eslintrc: z16.union(
+    [
+      z16.string({ description: "Path to ESLint config file" }),
+      z16.record(z16.string(), z16.unknown(), {
+        description: "ESLint config object"
+      })
+    ],
+    { description: "ESLint config as file path or inline object" }
+  ),
+  patterns: z16.union([z16.string(), z16.array(z16.string()).min(1)], {
+    description: "Lint target files. May contain file paths, directory paths or glob patterns"
+  })
+});
+var eslintPluginConfigSchema = z16.union([eslintTargetSchema, z16.array(eslintTargetSchema).min(1)]).transform(toArray);
+
 // packages/plugin-eslint/src/lib/meta/hash.ts
 import { createHash } from "node:crypto";
 function ruleIdToSlug(ruleId, options) {
@@ -784,8 +1136,27 @@ function jsonHash(data, bytes = 8) {
   return createHash("shake256", { outputLength: bytes }).update(JSON.stringify(data) || "null").digest("hex");
 }
 
+// packages/plugin-eslint/src/lib/setup.ts
+import { ESLint } from "eslint";
+function setupESLint(eslintrc) {
+  return new ESLint({
+    ...typeof eslintrc === "string" ? { overrideConfigFile: eslintrc } : { baseConfig: eslintrc },
+    useEslintrc: false,
+    errorOnUnmatchedPattern: false
+  });
+}
+
 // packages/plugin-eslint/src/lib/meta/rules.ts
-async function listRules(eslint, patterns) {
+async function listRules(targets) {
+  const rulesMap = await targets.reduce(async (acc, { eslintrc, patterns }) => {
+    const eslint = setupESLint(eslintrc);
+    const prev = await acc;
+    const curr = await loadRulesMap(eslint, patterns);
+    return mergeRulesMaps(prev, curr);
+  }, Promise.resolve({}));
+  return Object.values(rulesMap).flatMap(Object.values);
+}
+async function loadRulesMap(eslint, patterns) {
   const configs = await toArray(patterns).reduce(
     async (acc, pattern) => [
       ...await acc,
@@ -803,31 +1174,39 @@ async function listRules(eslint, patterns) {
       suppressedMessages: []
     }
   ]);
-  const rulesMap = configs.flatMap((config) => Object.entries(config.rules ?? {})).filter(([, ruleEntry]) => ruleEntry != null && !isRuleOff(ruleEntry)).reduce(
-    (acc, [ruleId, ruleEntry]) => {
-      const meta = rulesMeta[ruleId];
-      if (!meta) {
-        ui().logger.warning(`Metadata not found for ESLint rule ${ruleId}`);
-        return acc;
+  return configs.flatMap((config) => Object.entries(config.rules ?? {})).filter(([, ruleEntry]) => ruleEntry != null && !isRuleOff(ruleEntry)).reduce((acc, [ruleId, ruleEntry]) => {
+    const meta = rulesMeta[ruleId];
+    if (!meta) {
+      ui().logger.warning(`Metadata not found for ESLint rule ${ruleId}`);
+      return acc;
+    }
+    const options = toArray(ruleEntry).slice(1);
+    const optionsHash = jsonHash(options);
+    const ruleData = {
+      ruleId,
+      meta,
+      options
+    };
+    return {
+      ...acc,
+      [ruleId]: {
+        ...acc[ruleId],
+        [optionsHash]: ruleData
       }
-      const options = toArray(ruleEntry).slice(1);
-      const optionsHash = jsonHash(options);
-      const ruleData = {
-        ruleId,
-        meta,
-        options
-      };
-      return {
-        ...acc,
-        [ruleId]: {
-          ...acc[ruleId],
-          [optionsHash]: ruleData
-        }
-      };
-    },
-    {}
+    };
+  }, {});
+}
+function mergeRulesMaps(prev, curr) {
+  return Object.entries(curr).reduce(
+    (acc, [ruleId, ruleVariants]) => ({
+      ...acc,
+      [ruleId]: {
+        ...acc[ruleId],
+        ...ruleVariants
+      }
+    }),
+    prev
   );
-  return Object.values(rulesMap).flatMap(Object.values);
 }
 function isRuleOff(entry) {
   const level = Array.isArray(entry) ? entry[0] : entry;
@@ -923,7 +1302,7 @@ function ruleToAudit({ ruleId, meta, options }) {
   const name2 = ruleId.split("/").at(-1) ?? ruleId;
   const plugin = name2 === ruleId ? null : ruleId.slice(0, ruleId.lastIndexOf("/"));
   const pluginContext = plugin ? `, from _${plugin}_ plugin` : "";
-  const lines = [
+  const lines6 = [
     `ESLint rule **${name2}**${pluginContext}.`,
     ...options?.length ? ["Custom options:"] : [],
     ...options?.map(
@@ -933,7 +1312,7 @@ function ruleToAudit({ ruleId, meta, options }) {
   return {
     slug: ruleIdToSlug(ruleId, options),
     title: truncateTitle(meta.docs?.description ?? name2),
-    description: truncateDescription(lines.join("\n\n")),
+    description: truncateDescription(lines6.join("\n\n")),
     ...meta.docs?.url && {
       docsUrl: meta.docs.url
     }
@@ -941,8 +1320,8 @@ function ruleToAudit({ ruleId, meta, options }) {
 }
 
 // packages/plugin-eslint/src/lib/meta/index.ts
-async function listAuditsAndGroups(eslint, patterns) {
-  const rules = await listRules(eslint, patterns);
+async function listAuditsAndGroups(targets) {
+  const rules = await listRules(targets);
   const audits = rules.map(ruleToAudit);
   const groups = [
     ...groupsFromRuleTypes(rules),
@@ -954,31 +1333,17 @@ async function listAuditsAndGroups(eslint, patterns) {
 // packages/plugin-eslint/src/lib/runner/index.ts
 import { writeFile } from "node:fs/promises";
 import { dirname, join as join2 } from "node:path";
-
-// packages/plugin-eslint/src/lib/setup.ts
-import { ESLint } from "eslint";
-function setupESLint(eslintrc) {
-  return new ESLint({
-    ...typeof eslintrc === "string" ? { overrideConfigFile: eslintrc } : { baseConfig: eslintrc },
-    useEslintrc: false,
-    errorOnUnmatchedPattern: false
-  });
-}
-
-// packages/plugin-eslint/src/lib/runner/index.ts
 var WORKDIR = pluginWorkDir("eslint");
 var RUNNER_OUTPUT_PATH = join2(WORKDIR, "runner-output.json");
-var ESLINTRC_PATH = join2(process.cwd(), WORKDIR, ".eslintrc.json");
 var PLUGIN_CONFIG_PATH = join2(
   process.cwd(),
   WORKDIR,
   "plugin-config.json"
 );
-async function createRunnerConfig(scriptPath, audits, eslintrc, patterns) {
+async function createRunnerConfig(scriptPath, audits, targets) {
   const config = {
-    eslintrc,
-    slugs: audits.map((audit) => audit.slug),
-    patterns: toArray(patterns)
+    targets,
+    slugs: audits.map((audit) => audit.slug)
   };
   await ensureDirectoryExists(dirname(PLUGIN_CONFIG_PATH));
   await writeFile(PLUGIN_CONFIG_PATH, JSON.stringify(config));
@@ -991,14 +1356,8 @@ async function createRunnerConfig(scriptPath, audits, eslintrc, patterns) {
 
 // packages/plugin-eslint/src/lib/eslint-plugin.ts
 async function eslintPlugin(config) {
-  const { eslintrc, patterns } = eslintPluginConfigSchema.parse(config);
-  const eslint = setupESLint(eslintrc);
-  const { audits, groups } = await listAuditsAndGroups(eslint, patterns);
-  if (typeof eslintrc !== "string") {
-    await mkdir2(dirname2(ESLINTRC_PATH), { recursive: true });
-    await writeFile2(ESLINTRC_PATH, JSON.stringify(eslintrc));
-  }
-  const eslintrcPath = typeof eslintrc === "string" ? eslintrc : ESLINTRC_PATH;
+  const targets = eslintPluginConfigSchema.parse(config);
+  const { audits, groups } = await listAuditsAndGroups(targets);
   const runnerScriptPath = join3(
     fileURLToPath(dirname2(import.meta.url)),
     "bin.js"
@@ -1013,12 +1372,7 @@ async function eslintPlugin(config) {
     version,
     audits,
     groups,
-    runner: await createRunnerConfig(
-      runnerScriptPath,
-      audits,
-      eslintrcPath,
-      patterns
-    )
+    runner: await createRunnerConfig(runnerScriptPath, audits, targets)
   };
 }
 
@@ -1049,33 +1403,27 @@ async function nxProjectsToConfig(projectGraph, predicate = () => true) {
   const { readProjectsConfigurationFromProjectGraph } = await import("@nx/devkit");
   const projectsConfiguration = readProjectsConfigurationFromProjectGraph(projectGraph);
   const projects = Object.values(projectsConfiguration.projects).filter((project) => "lint" in (project.targets ?? {})).filter(predicate).sort((a, b) => a.root.localeCompare(b.root));
-  const eslintConfig = {
-    root: true,
-    overrides: await Promise.all(
-      projects.map(async (project) => ({
-        files: getLintFilePatterns(project),
-        extends: await findCodePushupEslintrc(project) ?? getEslintConfig(project)
-      }))
+  return Promise.all(
+    projects.map(
+      async (project) => ({
+        eslintrc: await findCodePushupEslintrc(project) ?? getEslintConfig(project),
+        patterns: [
+          ...getLintFilePatterns(project),
+          // HACK: ESLint.calculateConfigForFile won't find rules included only for subsets of *.ts when globs used
+          // so we explicitly provide additional patterns used by @code-pushup/eslint-config to ensure those rules are included
+          // this workaround won't be necessary once flat configs are stable (much easier to find all rules)
+          `${project.sourceRoot}/*.spec.ts`,
+          // jest/* and vitest/* rules
+          `${project.sourceRoot}/*.cy.ts`,
+          // cypress/* rules
+          `${project.sourceRoot}/*.stories.ts`,
+          // storybook/* rules
+          `${project.sourceRoot}/.storybook/main.ts`
+          // storybook/no-uninstalled-addons rule
+        ]
+      })
     )
-  };
-  const patterns = projects.flatMap((project) => [
-    ...getLintFilePatterns(project),
-    // HACK: ESLint.calculateConfigForFile won't find rules included only for subsets of *.ts when globs used
-    // so we explicitly provide additional patterns used by @code-pushup/eslint-config to ensure those rules are included
-    // this workaround won't be necessary once flat configs are stable (much easier to find all rules)
-    `${project.sourceRoot}/*.spec.ts`,
-    // jest/* and vitest/* rules
-    `${project.sourceRoot}/*.cy.ts`,
-    // cypress/* rules
-    `${project.sourceRoot}/*.stories.ts`,
-    // storybook/* rules
-    `${project.sourceRoot}/.storybook/main.ts`
-    // storybook/no-uninstalled-addons rule
-  ]);
-  return {
-    eslintrc: eslintConfig,
-    patterns
-  };
+  );
 }
 
 // packages/plugin-eslint/src/lib/nx/find-all-projects.ts