@code-pushup/eslint-plugin 0.1.0

package/index.js

@@ -0,0 +1,874 @@
+// packages/plugin-eslint/src/lib/eslint-plugin.ts
+import { mkdir, writeFile } from "fs/promises";
+import { dirname as dirname2, join as join3 } from "path";
+import { fileURLToPath } from "url";
+
+// packages/plugin-eslint/package.json
+var name = "@code-pushup/eslint-plugin";
+var version = "0.1.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"
+  })
+});
+
+// packages/models/src/lib/category-config.ts
+import { z as z3 } from "zod";
+
+// packages/models/src/lib/implementation/schemas.ts
+import { z as z2 } from "zod";
+import { MATERIAL_ICONS } from "@code-pushup/portal-client";
+
+// packages/models/src/lib/implementation/utils.ts
+var slugRegex = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+var filenameRegex = /^(?!.*[ \\/:*?"<>|]).+$/;
+function hasDuplicateStrings(strings) {
+  const uniqueStrings = Array.from(new Set(strings));
+  const duplicatedStrings = strings.filter(
+    /* @__PURE__ */ ((i) => (v) => uniqueStrings[i] !== v || !++i)(0)
+  );
+  return duplicatedStrings.length === 0 ? false : duplicatedStrings;
+}
+function hasMissingStrings(toCheck, existing) {
+  const nonExisting = toCheck.filter((s) => !existing.includes(s));
+  return nonExisting.length === 0 ? false : nonExisting;
+}
+function errorItems(items, transform = (items2) => items2.join(", ")) {
+  const paredItems = items ? items : [];
+  return transform(paredItems);
+}
+function exists(value) {
+  return value != null;
+}
+
+// packages/models/src/lib/implementation/schemas.ts
+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 })
+  });
+}
+function slugSchema(description = "Unique ID (human-readable, URL-safe)") {
+  return z2.string({ description }).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(128, {
+    message: "slug can be max 128 characters long"
+  });
+}
+function descriptionSchema(description = "Description (markdown)") {
+  return z2.string({ description }).max(65536).optional();
+}
+function docsUrlSchema(description = "Documentation site") {
+  return urlSchema(description).optional().or(z2.string().max(0));
+}
+function urlSchema(description) {
+  return z2.string({ description }).url();
+}
+function titleSchema(description = "Descriptive name") {
+  return z2.string({ description }).max(256);
+}
+function metaSchema(options) {
+  const {
+    descriptionDescription,
+    titleDescription,
+    docsUrlDescription,
+    description
+  } = options || {};
+  return z2.object(
+    {
+      title: titleSchema(titleDescription),
+      description: descriptionSchema(descriptionDescription),
+      docsUrl: docsUrlSchema(docsUrlDescription)
+    },
+    { description }
+  );
+}
+function filePathSchema(description) {
+  return z2.string({ description }).trim().min(1, { message: "path is invalid" });
+}
+function fileNameSchema(description) {
+  return z2.string({ description }).trim().regex(filenameRegex, {
+    message: `The filename has to be valid`
+  }).min(1, { message: "file name is invalid" });
+}
+function positiveIntSchema(description) {
+  return z2.number({ description }).int().nonnegative();
+}
+function packageVersionSchema(options) {
+  let { versionDescription, optional } = options || {};
+  versionDescription = versionDescription || "NPM version of the package";
+  optional = !!optional;
+  const packageSchema = z2.string({ description: "NPM package name" });
+  const versionSchema = z2.string({ description: versionDescription });
+  return z2.object(
+    {
+      packageName: optional ? packageSchema.optional() : packageSchema,
+      version: optional ? versionSchema.optional() : versionSchema
+    },
+    { description: "NPM package name and version of a published package" }
+  );
+}
+function weightSchema(description = "Coefficient for the given score (use weight 0 if only for display)") {
+  return positiveIntSchema(description);
+}
+function weightedRefSchema(description, slugDescription) {
+  return z2.object(
+    {
+      slug: slugSchema(slugDescription),
+      weight: weightSchema("Weight used to calculate score")
+    },
+    { description }
+  );
+}
+function scorableSchema(description, refSchema, duplicateCheckFn, duplicateMessageFn) {
+  return z2.object(
+    {
+      slug: slugSchema('Human-readable unique ID, e.g. "performance"'),
+      refs: z2.array(refSchema).refine(
+        (refs) => !duplicateCheckFn(refs),
+        (refs) => ({
+          message: duplicateMessageFn(refs)
+        })
+      )
+    },
+    { description }
+  );
+}
+var materialIconSchema = z2.enum(
+  MATERIAL_ICONS,
+  { description: "Icon from VSCode Material Icons extension" }
+);
+
+// packages/models/src/lib/category-config.ts
+var categoryRefSchema = weightedRefSchema(
+  "Weighted references to audits and/or groups for the category",
+  "Slug of an audit or group (depending on `type`)"
+).merge(
+  z3.object({
+    type: z3.enum(["audit", "group"], {
+      description: "Discriminant for reference kind, affects where `slug` is looked up"
+    }),
+    plugin: slugSchema(
+      "Plugin slug (plugin should contain referenced audit or group)"
+    )
+  })
+);
+var categoryConfigSchema = scorableSchema(
+  "Category with a score calculated from audits and groups from various plugins",
+  categoryRefSchema,
+  getDuplicateRefsInCategoryMetrics,
+  duplicateRefsInCategoryMetricsErrorMsg
+).merge(
+  metaSchema({
+    titleDescription: "Category Title",
+    docsUrlDescription: "Category docs URL",
+    descriptionDescription: "Category description",
+    description: "Meta info for category"
+  })
+).merge(
+  z3.object({
+    isBinary: z3.boolean({
+      description: 'Is this a binary category (i.e. only a perfect score considered a "pass")?'
+    }).optional()
+  })
+);
+function duplicateRefsInCategoryMetricsErrorMsg(metrics) {
+  const duplicateRefs = getDuplicateRefsInCategoryMetrics(metrics);
+  return `In the categories, the following audit or group refs are duplicates: ${errorItems(
+    duplicateRefs
+  )}`;
+}
+function getDuplicateRefsInCategoryMetrics(metrics) {
+  return hasDuplicateStrings(
+    metrics.map(({ slug, type, plugin }) => `${type} :: ${plugin} / ${slug}`)
+  );
+}
+
+// packages/models/src/lib/core-config.ts
+import { z as z12 } from "zod";
+
+// packages/models/src/lib/persist-config.ts
+import { z as z4 } from "zod";
+var formatSchema = z4.enum(["json", "md"]);
+var persistConfigSchema = z4.object({
+  outputDir: filePathSchema("Artifacts folder"),
+  filename: fileNameSchema("Artifacts file name (without extension)").default(
+    "report"
+  ),
+  format: z4.array(formatSchema).default(["json"]).optional()
+  // @TODO remove default or optional value and otherwise it will not set defaults.
+});
+
+// packages/models/src/lib/plugin-config.ts
+import { z as z10 } from "zod";
+
+// packages/models/src/lib/plugin-config-audits.ts
+import { z as z5 } from "zod";
+var auditSchema = z5.object({
+  slug: slugSchema("ID (unique within plugin)")
+}).merge(
+  metaSchema({
+    titleDescription: "Descriptive name",
+    descriptionDescription: "Description (markdown)",
+    docsUrlDescription: "Link to documentation (rationale)",
+    description: "List of scorable metrics for the given plugin"
+  })
+);
+var pluginAuditsSchema = z5.array(auditSchema, {
+  description: "List of audits maintained in a plugin"
+}).refine(
+  (auditMetadata) => !getDuplicateSlugsInAudits(auditMetadata),
+  (auditMetadata) => ({
+    message: duplicateSlugsInAuditsErrorMsg(auditMetadata)
+  })
+);
+function duplicateSlugsInAuditsErrorMsg(audits) {
+  const duplicateRefs = getDuplicateSlugsInAudits(audits);
+  return `In plugin audits the slugs are not unique: ${errorItems(
+    duplicateRefs
+  )}`;
+}
+function getDuplicateSlugsInAudits(audits) {
+  return hasDuplicateStrings(audits.map(({ slug }) => slug));
+}
+
+// packages/models/src/lib/plugin-config-groups.ts
+import { z as z6 } from "zod";
+var auditGroupRefSchema = weightedRefSchema(
+  "Weighted references to audits",
+  "Reference slug to an audit within this plugin (e.g. 'max-lines')"
+);
+var auditGroupSchema = scorableSchema(
+  'An audit group aggregates a set of audits into a single score which can be referenced from a category. E.g. the group slug "performance" groups audits and can be referenced in a category',
+  auditGroupRefSchema,
+  getDuplicateRefsInGroups,
+  duplicateRefsInGroupsErrorMsg
+).merge(
+  metaSchema({
+    titleDescription: "Descriptive name for the group",
+    descriptionDescription: "Description of the group (markdown)",
+    docsUrlDescription: "Group documentation site",
+    description: "Group metadata"
+  })
+);
+var auditGroupsSchema = z6.array(auditGroupSchema, {
+  description: "List of groups"
+}).optional().refine(
+  (groups) => !getDuplicateSlugsInGroups(groups),
+  (groups) => ({
+    message: duplicateSlugsInGroupsErrorMsg(groups)
+  })
+);
+function duplicateRefsInGroupsErrorMsg(groupAudits) {
+  const duplicateRefs = getDuplicateRefsInGroups(groupAudits);
+  return `In plugin groups the audit refs are not unique: ${errorItems(
+    duplicateRefs
+  )}`;
+}
+function getDuplicateRefsInGroups(groupAudits) {
+  return hasDuplicateStrings(
+    groupAudits.map(({ slug: ref }) => ref).filter(exists)
+  );
+}
+function duplicateSlugsInGroupsErrorMsg(groups) {
+  const duplicateRefs = getDuplicateSlugsInGroups(groups);
+  return `In groups the slugs are not unique: ${errorItems(duplicateRefs)}`;
+}
+function getDuplicateSlugsInGroups(groups) {
+  return Array.isArray(groups) ? hasDuplicateStrings(groups.map(({ slug }) => slug)) : false;
+}
+
+// packages/models/src/lib/plugin-config-runner.ts
+import { z as z9 } from "zod";
+
+// packages/models/src/lib/plugin-process-output.ts
+import { z as z8 } from "zod";
+
+// packages/models/src/lib/plugin-process-output-audit-issue.ts
+import { z as z7 } from "zod";
+var sourceFileLocationSchema = z7.object(
+  {
+    file: filePathSchema("Relative path to source file in Git repo"),
+    position: z7.object(
+      {
+        startLine: positiveIntSchema("Start line"),
+        startColumn: positiveIntSchema("Start column").optional(),
+        endLine: positiveIntSchema("End line").optional(),
+        endColumn: positiveIntSchema("End column").optional()
+      },
+      { description: "Location in file" }
+    ).optional()
+  },
+  { description: "Source file location" }
+);
+var issueSeveritySchema = z7.enum(["info", "warning", "error"], {
+  description: "Severity level"
+});
+var issueSchema = z7.object(
+  {
+    message: z7.string({ description: "Descriptive error message" }).max(512),
+    severity: issueSeveritySchema,
+    source: sourceFileLocationSchema.optional()
+  },
+  { description: "Issue information" }
+);
+
+// packages/models/src/lib/plugin-process-output.ts
+var auditOutputSchema = z8.object(
+  {
+    slug: slugSchema("Reference to audit"),
+    displayValue: z8.string({ description: "Formatted value (e.g. '0.9 s', '2.1 MB')" }).optional(),
+    value: positiveIntSchema("Raw numeric value"),
+    score: z8.number({
+      description: "Value between 0 and 1"
+    }).min(0).max(1),
+    details: z8.object(
+      {
+        issues: z8.array(issueSchema, { description: "List of findings" })
+      },
+      { description: "Detailed information" }
+    ).optional()
+  },
+  { description: "Audit information" }
+);
+var auditOutputsSchema = z8.array(auditOutputSchema, {
+  description: "List of JSON formatted audit output emitted by the runner process of a plugin"
+}).refine(
+  (audits) => !getDuplicateSlugsInAudits2(audits),
+  (audits) => ({ message: duplicateSlugsInAuditsErrorMsg2(audits) })
+);
+function duplicateSlugsInAuditsErrorMsg2(audits) {
+  const duplicateRefs = getDuplicateSlugsInAudits2(audits);
+  return `In plugin audits the slugs are not unique: ${errorItems(
+    duplicateRefs
+  )}`;
+}
+function getDuplicateSlugsInAudits2(audits) {
+  return hasDuplicateStrings(audits.map(({ slug }) => slug));
+}
+
+// packages/models/src/lib/plugin-config-runner.ts
+var outputTransformSchema = z9.function().args(z9.unknown()).returns(z9.union([auditOutputsSchema, z9.promise(auditOutputsSchema)]));
+var runnerConfigSchema = z9.object(
+  {
+    command: z9.string({
+      description: "Shell command to execute"
+    }),
+    args: z9.array(z9.string({ description: "Command arguments" })).optional(),
+    outputFile: filePathSchema("Output path"),
+    outputTransform: outputTransformSchema.optional()
+  },
+  {
+    description: "How to execute runner"
+  }
+);
+var onProgressSchema = z9.function().args(z9.unknown()).returns(z9.void());
+var runnerFunctionSchema = z9.function().args(onProgressSchema.optional()).returns(z9.union([auditOutputsSchema, z9.promise(auditOutputsSchema)]));
+
+// packages/models/src/lib/plugin-config.ts
+var pluginMetaSchema = packageVersionSchema({
+  optional: true
+}).merge(
+  metaSchema({
+    titleDescription: "Descriptive name",
+    descriptionDescription: "Description (markdown)",
+    docsUrlDescription: "Plugin documentation site",
+    description: "Plugin metadata"
+  })
+).merge(
+  z10.object({
+    slug: slugSchema("References plugin. ID (unique within core config)"),
+    icon: materialIconSchema
+  })
+);
+var pluginDataSchema = z10.object({
+  runner: z10.union([runnerConfigSchema, runnerFunctionSchema]),
+  audits: pluginAuditsSchema,
+  groups: auditGroupsSchema
+});
+var pluginConfigSchema = pluginMetaSchema.merge(pluginDataSchema).refine(
+  (pluginCfg) => !getMissingRefsFromGroups(pluginCfg),
+  (pluginCfg) => ({
+    message: missingRefsFromGroupsErrorMsg(pluginCfg)
+  })
+);
+function missingRefsFromGroupsErrorMsg(pluginCfg) {
+  const missingRefs = getMissingRefsFromGroups(pluginCfg);
+  return `In the groups, the following audit ref's needs to point to a audit in this plugin config: ${errorItems(
+    missingRefs
+  )}`;
+}
+function getMissingRefsFromGroups(pluginCfg) {
+  if (pluginCfg?.groups?.length && pluginCfg?.audits?.length) {
+    const groups = pluginCfg?.groups || [];
+    const audits = pluginCfg?.audits || [];
+    return hasMissingStrings(
+      groups.flatMap(({ refs: audits2 }) => audits2.map(({ slug: ref }) => ref)),
+      audits.map(({ slug }) => slug)
+    );
+  }
+  return false;
+}
+
+// packages/models/src/lib/upload-config.ts
+import { z as z11 } from "zod";
+var uploadConfigSchema = z11.object({
+  server: urlSchema("URL of deployed portal API"),
+  apiKey: z11.string({
+    description: "API key with write access to portal (use `process.env` for security)"
+  }),
+  organization: z11.string({
+    description: "Organization in code versioning system"
+  }),
+  project: z11.string({
+    description: "Project in code versioning system"
+  })
+});
+
+// packages/models/src/lib/core-config.ts
+var unrefinedCoreConfigSchema = z12.object({
+  plugins: z12.array(pluginConfigSchema, {
+    description: "List of plugins to be used (official, community-provided, or custom)"
+  }),
+  /** portal configuration for persisting results */
+  persist: persistConfigSchema,
+  /** portal configuration for uploading results */
+  upload: uploadConfigSchema.optional(),
+  categories: z12.array(categoryConfigSchema, {
+    description: "Categorization of individual audits"
+  }).refine(
+    (categoryCfg) => !getDuplicateSlugCategories(categoryCfg),
+    (categoryCfg) => ({
+      message: duplicateSlugCategoriesErrorMsg(categoryCfg)
+    })
+  )
+});
+var coreConfigSchema = refineCoreConfig(unrefinedCoreConfigSchema);
+function refineCoreConfig(schema) {
+  return schema.refine(
+    (coreCfg) => !getMissingRefsForCategories(coreCfg),
+    (coreCfg) => ({
+      message: missingRefsForCategoriesErrorMsg(coreCfg)
+    })
+  );
+}
+function missingRefsForCategoriesErrorMsg(coreCfg) {
+  const missingRefs = getMissingRefsForCategories(coreCfg);
+  return `In the categories, the following plugin refs do not exist in the provided plugins: ${errorItems(
+    missingRefs
+  )}`;
+}
+function getMissingRefsForCategories(coreCfg) {
+  const missingRefs = [];
+  const auditRefsFromCategory = coreCfg.categories.flatMap(
+    ({ refs }) => refs.filter(({ type }) => type === "audit").map(({ plugin, slug }) => `${plugin}/${slug}`)
+  );
+  const auditRefsFromPlugins = coreCfg.plugins.flatMap(
+    ({ audits, slug: pluginSlug }) => {
+      return audits.map(({ slug }) => `${pluginSlug}/${slug}`);
+    }
+  );
+  const missingAuditRefs = hasMissingStrings(
+    auditRefsFromCategory,
+    auditRefsFromPlugins
+  );
+  if (Array.isArray(missingAuditRefs) && missingAuditRefs.length > 0) {
+    missingRefs.push(...missingAuditRefs);
+  }
+  const groupRefsFromCategory = coreCfg.categories.flatMap(
+    ({ refs }) => refs.filter(({ type }) => type === "group").map(({ plugin, slug }) => `${plugin}#${slug} (group)`)
+  );
+  const groupRefsFromPlugins = coreCfg.plugins.flatMap(
+    ({ groups, slug: pluginSlug }) => {
+      return Array.isArray(groups) ? groups.map(({ slug }) => `${pluginSlug}#${slug} (group)`) : [];
+    }
+  );
+  const missingGroupRefs = hasMissingStrings(
+    groupRefsFromCategory,
+    groupRefsFromPlugins
+  );
+  if (Array.isArray(missingGroupRefs) && missingGroupRefs.length > 0) {
+    missingRefs.push(...missingGroupRefs);
+  }
+  return missingRefs.length ? missingRefs : false;
+}
+function duplicateSlugCategoriesErrorMsg(categories) {
+  const duplicateStringSlugs = getDuplicateSlugCategories(categories);
+  return `In the categories, the following slugs are duplicated: ${errorItems(
+    duplicateStringSlugs
+  )}`;
+}
+function getDuplicateSlugCategories(categories) {
+  return hasDuplicateStrings(categories.map(({ slug }) => slug));
+}
+
+// packages/models/src/lib/report.ts
+import { z as z13 } from "zod";
+var auditReportSchema = auditSchema.merge(auditOutputSchema);
+var pluginReportSchema = pluginMetaSchema.merge(
+  executionMetaSchema({
+    descriptionDate: "Start date and time of plugin run",
+    descriptionDuration: "Duration of the plugin run in ms"
+  })
+).merge(
+  z13.object({
+    audits: z13.array(auditReportSchema),
+    groups: z13.array(auditGroupSchema).optional()
+  })
+);
+var reportSchema = packageVersionSchema({
+  versionDescription: "NPM version of the CLI"
+}).merge(
+  executionMetaSchema({
+    descriptionDate: "Start date and time of the collect run",
+    descriptionDuration: "Duration of the collect run in ms"
+  })
+).merge(
+  z13.object(
+    {
+      categories: z13.array(categoryConfigSchema),
+      plugins: z13.array(pluginReportSchema)
+    },
+    { description: "Collect output data" }
+  )
+);
+
+// packages/utils/src/lib/file-system.ts
+import { bundleRequire } from "bundle-require";
+import chalk from "chalk";
+import { join } from "path";
+
+// packages/utils/src/lib/formatting.ts
+function slugify(text) {
+  return text.trim().toLowerCase().replace(/\s+|\//g, "-").replace(/[^a-z0-9-]/g, "");
+}
+
+// packages/utils/src/lib/file-system.ts
+function pluginWorkDir(slug) {
+  return join("node_modules", ".code-pushup", slug);
+}
+
+// packages/utils/src/lib/execute-process.ts
+function objectToCliArgs(params) {
+  if (!params) {
+    return [];
+  }
+  return Object.entries(params).flatMap(([key, value]) => {
+    if (key === "_") {
+      if (Array.isArray(value)) {
+        return value;
+      } else {
+        return [value + ""];
+      }
+    }
+    const prefix = key.length === 1 ? "-" : "--";
+    if (Array.isArray(value)) {
+      return value.map((v) => `${prefix}${key}="${v}"`);
+    }
+    if (Array.isArray(value)) {
+      return value.map((v) => `${prefix}${key}="${v}"`);
+    }
+    if (typeof value === "string") {
+      return [`${prefix}${key}="${value}"`];
+    }
+    if (typeof value === "number") {
+      return [`${prefix}${key}=${value}`];
+    }
+    if (typeof value === "boolean") {
+      return [`${prefix}${value ? "" : "no-"}${key}`];
+    }
+    throw new Error(`Unsupported type ${typeof value} for key ${key}`);
+  });
+}
+objectToCliArgs({ z: 5 });
+
+// packages/utils/src/lib/git.ts
+import simpleGit from "simple-git";
+var git = simpleGit();
+
+// packages/utils/src/lib/progress.ts
+import chalk2 from "chalk";
+import { MultiProgressBars } from "multi-progress-bars";
+
+// packages/utils/src/lib/report-to-stdout.ts
+import cliui from "@isaacs/cliui";
+import chalk3 from "chalk";
+import Table from "cli-table3";
+
+// packages/utils/src/lib/transformation.ts
+function toArray(val) {
+  return Array.isArray(val) ? val : [val];
+}
+function objectToKeys(obj) {
+  return Object.keys(obj);
+}
+function distinct(array) {
+  return Array.from(new Set(array));
+}
+
+// packages/plugin-eslint/src/lib/meta/hash.ts
+import { createHash } from "crypto";
+function ruleIdToSlug(ruleId, options) {
+  const slug = slugify(ruleId);
+  if (!options?.length) {
+    return slug;
+  }
+  return `${slug}-${jsonHash(options)}`;
+}
+function jsonHash(data, bytes = 8) {
+  return createHash("shake256", { outputLength: bytes }).update(JSON.stringify(data) ?? "null").digest("hex");
+}
+
+// packages/plugin-eslint/src/lib/meta/rules.ts
+async function listRules(eslint, patterns) {
+  const configs = await toArray(patterns).reduce(
+    async (acc, pattern) => [
+      ...await acc,
+      await eslint.calculateConfigForFile(pattern)
+    ],
+    Promise.resolve([])
+  );
+  const rulesIds = distinct(
+    configs.flatMap((config) => Object.keys(config.rules ?? {}))
+  );
+  const rulesMeta = eslint.getRulesMetaForResults([
+    {
+      messages: rulesIds.map((ruleId) => ({ ruleId })),
+      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) {
+        console.warn(`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
+        }
+      };
+    },
+    {}
+  );
+  return Object.values(rulesMap).flatMap(Object.values);
+}
+function isRuleOff(entry) {
+  const level = Array.isArray(entry) ? entry[0] : entry;
+  switch (level) {
+    case 0:
+    case "off":
+      return true;
+    case 1:
+    case 2:
+    case "warn":
+    case "error":
+      return false;
+  }
+}
+function parseRuleId(ruleId) {
+  const i = ruleId.lastIndexOf("/");
+  if (i < 0) {
+    return { name: ruleId };
+  }
+  return {
+    plugin: ruleId.slice(0, i),
+    name: ruleId.slice(i + 1)
+  };
+}
+
+// packages/plugin-eslint/src/lib/meta/groups.ts
+var typeGroups = {
+  problem: {
+    slug: "problems",
+    title: "Problems",
+    description: "Code that either will cause an error or may cause confusing behavior. Developers should consider this a high priority to resolve."
+  },
+  suggestion: {
+    slug: "suggestions",
+    title: "Suggestions",
+    description: "Something that could be done in a better way but no errors will occur if the code isn't changed."
+  },
+  layout: {
+    slug: "formatting",
+    title: "Formatting",
+    description: "Primarily about whitespace, semicolons, commas, and parentheses, all the parts of the program that determine how the code looks rather than how it executes."
+  }
+};
+function groupsFromRuleTypes(rules) {
+  const allTypes = objectToKeys(typeGroups);
+  const auditSlugsMap = rules.reduce(
+    (acc, { meta: { type }, ruleId, options }) => type == null ? acc : {
+      ...acc,
+      [type]: [...acc[type] ?? [], ruleIdToSlug(ruleId, options)]
+    },
+    {}
+  );
+  return allTypes.map((type) => ({
+    ...typeGroups[type],
+    refs: auditSlugsMap[type]?.map(
+      (slug) => ({ slug, weight: 1 })
+    ) ?? []
+  }));
+}
+function groupsFromRuleCategories(rules) {
+  const categoriesMap = rules.reduce(
+    (acc, { meta: { docs }, ruleId, options }) => {
+      const category = docs?.category;
+      if (!category) {
+        return acc;
+      }
+      const { plugin = "" } = parseRuleId(ruleId);
+      return {
+        ...acc,
+        [plugin]: {
+          ...acc[plugin],
+          [category]: [
+            ...acc[plugin]?.[category] ?? [],
+            ruleIdToSlug(ruleId, options)
+          ]
+        }
+      };
+    },
+    {}
+  );
+  return Object.entries(categoriesMap).flatMap(
+    ([plugin, categories]) => Object.entries(categories).map(
+      ([category, slugs]) => ({
+        slug: `${slugify(plugin)}-${slugify(category)}`,
+        title: `${category} (${plugin})`,
+        refs: slugs.map((slug) => ({ slug, weight: 1 }))
+      })
+    )
+  ).sort((a, b) => a.slug.localeCompare(b.slug));
+}
+
+// packages/plugin-eslint/src/lib/meta/transform.ts
+function ruleToAudit({ ruleId, meta, options }) {
+  const name2 = ruleId.split("/").at(-1) ?? ruleId;
+  const plugin = name2 === ruleId ? null : ruleId.slice(0, ruleId.lastIndexOf("/"));
+  const lines = [
+    `ESLint rule **${name2}**${plugin ? `, from _${plugin}_ plugin` : ""}.`,
+    ...options?.length ? ["Custom options:"] : [],
+    ...options?.map(
+      (option) => ["```json", JSON.stringify(option, null, 2), "```"].join("\n")
+    ) ?? []
+  ];
+  return {
+    slug: ruleIdToSlug(ruleId, options),
+    title: meta.docs?.description ?? name2,
+    description: lines.join("\n\n"),
+    ...meta.docs?.url && {
+      docsUrl: meta.docs.url
+    }
+  };
+}
+
+// packages/plugin-eslint/src/lib/meta/index.ts
+async function listAuditsAndGroups(eslint, patterns) {
+  const rules = await listRules(eslint, patterns);
+  const audits = rules.map(ruleToAudit);
+  const groups = [
+    ...groupsFromRuleTypes(rules),
+    ...groupsFromRuleCategories(rules)
+  ];
+  return { audits, groups };
+}
+
+// packages/plugin-eslint/src/lib/runner/index.ts
+import { platform } from "os";
+import { dirname, join as join2 } from "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 AUDIT_SLUGS_SEP = ",";
+function createRunnerConfig(scriptPath, audits, eslintrc, patterns) {
+  return {
+    command: "node",
+    args: [
+      scriptPath,
+      audits.map((audit) => audit.slug).join(AUDIT_SLUGS_SEP),
+      eslintrc,
+      ...toArray(patterns).map(
+        (pattern) => platform() === "win32" ? pattern : `'${pattern}'`
+      )
+    ],
+    outputFile: RUNNER_OUTPUT_PATH
+  };
+}
+
+// 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 mkdir(dirname2(ESLINTRC_PATH), { recursive: true });
+    await writeFile(ESLINTRC_PATH, JSON.stringify(eslintrc));
+  }
+  const eslintrcPath = typeof eslintrc === "string" ? eslintrc : ESLINTRC_PATH;
+  const runnerScriptPath = join3(
+    fileURLToPath(dirname2(import.meta.url)),
+    "bin.js"
+  );
+  return {
+    slug: "eslint",
+    title: "ESLint",
+    icon: "eslint",
+    description: "Official Code PushUp ESLint plugin",
+    // TODO: docsUrl (package README, once published)
+    packageName: name,
+    version,
+    audits,
+    groups,
+    runner: createRunnerConfig(
+      runnerScriptPath,
+      audits,
+      eslintrcPath,
+      patterns
+    )
+  };
+}
+
+// packages/plugin-eslint/src/index.ts
+var src_default = eslintPlugin;
+export {
+  src_default as default
+};