@geonosis/oxlint-plugin-biological-architecture 0.1.1 → 0.1.2

package/README.md

@@ -78,6 +78,13 @@ match. It deletes it when the **findings** match: same tree, same rule ids, two
 geonosis-lint-parity --a <config-a.json> --b <config-b.json> [--oxlint <path>] [--out <dir>] -- <paths…>
 ```
 
+**Write both configs inside the workspace being linted** — `<ws>/.oxlintrc.parity-a.json`, deleted
+afterwards — or name the plugin by absolute path in `jsPlugins`. oxlint resolves a `jsPlugins`
+specifier relative to the **config file's** directory, not the working directory, so a config
+written to a temp dir cannot find a plugin installed in the workspace: it fails with
+`Cannot find module '@…/plugin'`, and the tool correctly refuses with
+`config A: oxlint exited 1 without reporting a single finding`.
+
 ### Step 0 — reach, before parity
 
 Parity between two configs that both do nothing is perfect parity. In one source repo 34 of 51
@@ -86,13 +93,20 @@ nothing could check. So this package ships the **reach corpus** — the fixture
 against, one deliberately broken file per rule — and answers the question directly:
 
 ```bash
-geonosis-lint-parity --corpus --a oxlintrc.fork.json --b oxlintrc.published.json [--out <dir>]
+geonosis-lint-parity --corpus [<dir>] --a oxlintrc.fork.json --b oxlintrc.published.json [--out <dir>]
 ```
 
-Both configs run over the shipped corpus (copied to a temp root first, so neither a `.gitignore` nor
+Both configs run over the corpus (copied to a temp root first, so neither a `.gitignore` nor
 oxlint's `node_modules` skip can quietly turn "every rule fired nowhere" into the answer). It prints
-a fired-under-A / fired-under-B row per configured rule and **exits 1 when a rule fires under
-neither**. `--out` writes `CORPUS.md`.
+a fired-under-A / fired-under-B row per in-scope rule and **exits 1 when one fires under neither**.
+`--out` writes `CORPUS.md`.
+
+**A corpus covers the rules its own `manifest.json` names, and only those.** The one this package
+ships names `biological-architecture/*` — one deliberately broken file per rule, the list generated
+from the plugin's own rules export at build time. A configured `eqeqeq`, `unicorn/*` or
+`typescript/*` is listed under **outside this corpus** and gets no verdict: this tree is no evidence
+either way about somebody else's rule, and judging one would fail every real config for saying
+nothing. `--corpus <dir>` points the same run at another plugin's corpus; the scope moves with it.
 
 Every rule this package exports has at least one corpus file that fires it, and a test fails if that
 stops being true — so a rule cannot be added without evidence it reaches anything.
@@ -103,7 +117,14 @@ It runs oxlint twice with `--format=unix` over the same paths, strips the workin
 sorts, and prints the two counts, `only in A`, `only in B` and a per-rule tally. **It exits 1 when
 `only in A` is non-empty** — a finding the old config caught and the new one does not. New findings
 are what an upgrade is for; lost ones stop the adoption. `--out` writes `a.txt`, `b.txt`,
-`only-in-a.txt`, `only-in-b.txt` and `SUMMARY.md` for the proof file.
+`only-in-a.txt`, `only-in-b.txt`, `changed.txt` and `SUMMARY.md` for the proof file.
+
+**A finding is identified by where it is and which rule found it — `path:line:col` plus
+`plugin(rule)`.** The message is not part of it, and neither is the severity. A release that only
+rewords a rule's message would otherwise show as one finding lost and one gained, and stop an
+adoption over a sentence. Those pair up instead under **changed**, reported in full and never
+reaching the exit code; a severity change lands there too, because that is a fact about the config
+rather than a rule that stopped firing.
 
 **Fork vs published**, before deleting a vendored copy — two configs identical but for `jsPlugins`:
 

package/corpus/manifest.json

@@ -0,0 +1,59 @@
+{
+  "plugin": "biological-architecture",
+  "rules": [
+    "biological-architecture/atom-no-deps",
+    "biological-architecture/cell-must-be-stateful",
+    "biological-architecture/cell-must-not-compose-cell",
+    "biological-architecture/cell-no-tissues",
+    "biological-architecture/cells-folder-index-is-barrel",
+    "biological-architecture/compound-must-be-stateless",
+    "biological-architecture/compound-no-stores",
+    "biological-architecture/constants-in-constants-file",
+    "biological-architecture/dialect-through-the-seam",
+    "biological-architecture/document-sagas-are-generic",
+    "biological-architecture/documents-share-one-table",
+    "biological-architecture/effect-hook-naming",
+    "biological-architecture/max-comment-density",
+    "biological-architecture/molecule-atoms-only",
+    "biological-architecture/molecule-must-compose",
+    "biological-architecture/next-route-segment-is-thin-delegate",
+    "biological-architecture/no-brand-names",
+    "biological-architecture/no-card-shaped-div",
+    "biological-architecture/no-cross-feature-stores",
+    "biological-architecture/no-d1-transaction",
+    "biological-architecture/no-duplicate-jsx-patterns",
+    "biological-architecture/no-hook-in-component-disguise",
+    "biological-architecture/no-inert-hidden-jsx",
+    "biological-architecture/no-inline-data-in-jsx",
+    "biological-architecture/no-invalid-feature-folders",
+    "biological-architecture/no-logic-in-component-files",
+    "biological-architecture/no-orm-outside-db",
+    "biological-architecture/no-raw-html-atoms",
+    "biological-architecture/no-raw-sql-outside-allowed",
+    "biological-architecture/no-react-namespace",
+    "biological-architecture/no-renamed-html-props",
+    "biological-architecture/no-render-prop-reader",
+    "biological-architecture/no-trivial-wrapper-component",
+    "biological-architecture/no-ts-in-bio-folders",
+    "biological-architecture/no-type-definitions-in-components",
+    "biological-architecture/no-void-port",
+    "biological-architecture/organelle-dependency",
+    "biological-architecture/organelle-single-source",
+    "biological-architecture/queries-require-org-scope",
+    "biological-architecture/queue-loop-is-the-library",
+    "biological-architecture/ssot-no-inline-facts",
+    "biological-architecture/ssot-no-process-env",
+    "biological-architecture/step-opens-its-own-cell",
+    "biological-architecture/store-route-scopes-tenant-data",
+    "biological-architecture/tables-declare-their-plane",
+    "biological-architecture/tenant-tables-carry-org-id",
+    "biological-architecture/time-through-the-door",
+    "biological-architecture/tissue-must-compose",
+    "biological-architecture/tissue-no-data-props",
+    "biological-architecture/tissue-no-hooks",
+    "biological-architecture/tissue-no-organelles",
+    "biological-architecture/tissue-no-stores",
+    "biological-architecture/worker-handles-are-scoped",
+    "biological-architecture/zustand-v5-best-practices"
+  ]
+}

package/dist/chunk-BFFWNFJM.js

@@ -0,0 +1,6 @@
+// src/plugin-name.ts
+var PLUGIN_NAME = "biological-architecture";
+
+export {
+  PLUGIN_NAME
+};

package/dist/chunk-NZVMV3Y5.js

@@ -0,0 +1,339 @@
+// src/parity.ts
+import { spawnSync } from "child_process";
+import { cpSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "fs";
+import { tmpdir } from "os";
+import { join } from "path";
+var ANSI = /\[[0-9;]*m/g;
+var SUMMARY_COUNT = /^(\d+) problems?$/m;
+var RULE_IN_LINE = /\[(?:Error|Warning)\/([^\]]+)\]$/;
+var UNIX_FINDING = /^\S[^\n]*:\d+:\d+: .*\[(?:Error|Warning)\/[^\]\n]+\]$/;
+var FINDING_PLACE = /^(\S[^\n]*?:\d+:\d+): .*\[(?:Error|Warning)\/([^\]\n]+)\]$/;
+var ParityError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ParityError";
+  }
+};
+var normaliseFindings = (output, cwd) => output.replaceAll(ANSI, "").split("\n").map((line) => line.trim().replace(`${cwd}/`, "").replace(/^\.\//, "")).filter((line) => UNIX_FINDING.test(line)).toSorted();
+var readRun = ({ code, output }, cwd, side) => {
+  const findings = normaliseFindings(output, cwd);
+  const summary = SUMMARY_COUNT.exec(output);
+  const refuse = (why) => {
+    throw new ParityError(`config ${side}: ${why}
+${output.trim()}`);
+  };
+  if (summary?.[1] !== void 0 && Number(summary[1]) !== findings.length) {
+    return refuse(`oxlint says ${summary[1]} problems, ${findings.length} lines parsed as findings`);
+  }
+  if (findings.length === 0 && code !== 0) {
+    return refuse(`oxlint exited ${code} without reporting a single finding`);
+  }
+  return findings;
+};
+var UNATTRIBUTED = "(unattributed)";
+var ruleOf = (line) => RULE_IN_LINE.exec(line)?.[1] ?? UNATTRIBUTED;
+var asFile = (lines) => lines.length === 0 ? "" : `${lines.join("\n")}
+`;
+var changedLines = (changes) => changes.flatMap((one) => [`- A: ${one.a}`, `+ B: ${one.b}`]);
+var countByRule = (lines) => {
+  const counts = /* @__PURE__ */ new Map();
+  for (const line of lines) counts.set(ruleOf(line), (counts.get(ruleOf(line)) ?? 0) + 1);
+  return counts;
+};
+var missingFrom = (lines, other) => {
+  const remaining = /* @__PURE__ */ new Map();
+  for (const line of other) remaining.set(line, (remaining.get(line) ?? 0) + 1);
+  return lines.filter((line) => {
+    const left = remaining.get(line) ?? 0;
+    if (left === 0) return true;
+    remaining.set(line, left - 1);
+    return false;
+  });
+};
+var identityOf = (line) => {
+  const found = FINDING_PLACE.exec(line);
+  return found === null ? line : `${found[1]} [${found[2]}]`;
+};
+var byIdentity = (lines) => {
+  const grouped = /* @__PURE__ */ new Map();
+  for (const line of lines) {
+    const identity = identityOf(line);
+    grouped.set(identity, [...grouped.get(identity) ?? [], line]);
+  }
+  return grouped;
+};
+var compareFindings = ({ a, b }) => {
+  const inA = countByRule(a);
+  const inB = countByRule(b);
+  const groupedA = byIdentity(a);
+  const groupedB = byIdentity(b);
+  const onlyInA = [];
+  const onlyInB = [];
+  const messageChanged = [];
+  for (const identity of [.../* @__PURE__ */ new Set([...groupedA.keys(), ...groupedB.keys()])].toSorted()) {
+    const here = groupedA.get(identity) ?? [];
+    const there = groupedB.get(identity) ?? [];
+    const leftA = missingFrom(here, there);
+    const leftB = missingFrom(there, here);
+    for (const [index, line] of leftA.entries()) {
+      const other = leftB[index];
+      if (other === void 0) onlyInA.push(line);
+      else messageChanged.push({ a: line, b: other });
+    }
+    onlyInB.push(...leftB.slice(leftA.length));
+  }
+  return {
+    a,
+    b,
+    lost: onlyInA.length > 0,
+    messageChanged,
+    onlyInA,
+    onlyInB,
+    tally: [.../* @__PURE__ */ new Set([...inA.keys(), ...inB.keys()])].toSorted().map((rule) => ({
+      a: inA.get(rule) ?? 0,
+      b: inB.get(rule) ?? 0,
+      rule
+    }))
+  };
+};
+var formatSummary = (parity) => {
+  const rows = parity.tally.map(
+    (one) => `| \`${one.rule}\` | ${one.a} | ${one.b} | ${one.b - one.a >= 0 ? "+" : ""}${one.b - one.a} |`
+  );
+  const lost = parity.onlyInA.length === 0 ? "None. Every finding A reported, B reported too.\n" : `${parity.onlyInA.map((line) => `- \`${line}\``).join("\n")}
+`;
+  const gained = parity.onlyInB.length === 0 ? "None.\n" : `${parity.onlyInB.map((line) => `- \`${line}\``).join("\n")}
+`;
+  const changed = parity.messageChanged.length === 0 ? "None. Every finding both runs made is worded and graded the same.\n" : `${changedLines(parity.messageChanged).map((line) => `- \`${line}\``).join("\n")}
+`;
+  return [
+    "# findings parity",
+    "",
+    `- findings A: **${parity.a.length}**`,
+    `- findings B: **${parity.b.length}**`,
+    `- only in A (lost): **${parity.onlyInA.length}**`,
+    `- only in B (gained): **${parity.onlyInB.length}**`,
+    `- same finding, changed message or severity: **${parity.messageChanged.length}**`,
+    "",
+    `**${parity.lost ? "FAIL" : "PASS"}** \u2014 ${parity.lost ? "B lost findings A reported. A rule that fired under A and fires nowhere under B stops the adoption." : "B reported everything A did."}`,
+    "",
+    "## per rule",
+    "",
+    "| rule | A | B | delta |",
+    "|---|---:|---:|---:|",
+    ...rows,
+    "",
+    "## only in A (lost)",
+    "",
+    lost,
+    "## only in B (gained)",
+    "",
+    gained,
+    "## changed (same place, same rule, different message or severity)",
+    "",
+    "Reported, never counted against B: a reworded message is the same finding, and a rule graded",
+    "differently is a fact about the config. Neither reaches the exit code.",
+    "",
+    changed
+  ].join("\n");
+};
+var rulesNamedBy = (config) => {
+  const parsed = JSON.parse(readFileSync(config, "utf8"));
+  return Object.keys(parsed.rules ?? {});
+};
+var ruleIdOf = (line) => {
+  const token = RULE_IN_LINE.exec(line)?.[1];
+  if (token === void 0) return UNATTRIBUTED;
+  const at = token.indexOf("(");
+  return at === -1 ? token : `${token.slice(0, at)}/${token.slice(at + 1, -1)}`;
+};
+var MANIFEST_FILE = "manifest.json";
+var manifestOf = (plugin) => ({
+  plugin: plugin.meta.name,
+  rules: Object.keys(plugin.rules).map((rule) => `${plugin.meta.name}/${rule}`).toSorted()
+});
+var readManifest = (corpus) => {
+  const path = join(corpus, MANIFEST_FILE);
+  let parsed;
+  try {
+    parsed = JSON.parse(readFileSync(path, "utf8"));
+  } catch (error) {
+    throw new ParityError(`could not read ${path}: ${error.message}`);
+  }
+  const manifest = parsed;
+  if (typeof manifest.plugin !== "string" || !Array.isArray(manifest.rules)) {
+    throw new ParityError(`${path} names no plugin and no rules \u2014 it cannot scope a reach run`);
+  }
+  return { plugin: manifest.plugin, rules: manifest.rules };
+};
+var corpusOf = ({
+  configA,
+  configB,
+  corpus,
+  oxlint
+}) => {
+  const manifest = readManifest(corpus);
+  const exercised = new Set(manifest.rules);
+  const root = mkdtempSync(join(tmpdir(), "geonosis-corpus-"));
+  const here = join(root, "corpus");
+  const firedIn = (config, side) => new Set(
+    readRun(
+      lint({
+        config,
+        cwd: root,
+        extra: ["--no-ignore", "--disable-nested-config"],
+        oxlint,
+        paths: [here]
+      }),
+      root,
+      side
+    ).map(ruleIdOf)
+  );
+  let inA = /* @__PURE__ */ new Set();
+  let inB = /* @__PURE__ */ new Set();
+  try {
+    cpSync(corpus, here, { recursive: true });
+    inA = firedIn(configA, "A");
+    inB = firedIn(configB, "B");
+  } finally {
+    rmSync(root, { force: true, recursive: true });
+  }
+  const configured = [.../* @__PURE__ */ new Set([...rulesNamedBy(configA), ...rulesNamedBy(configB)])].toSorted();
+  const reach = configured.filter((rule) => exercised.has(rule)).map((rule) => ({ firedInA: inA.has(rule), firedInB: inB.has(rule), rule }));
+  return {
+    neither: reach.filter((one) => !one.firedInA && !one.firedInB).map((one) => one.rule),
+    outside: configured.filter((rule) => !exercised.has(rule)),
+    plugin: manifest.plugin,
+    reach
+  };
+};
+var formatCorpus = (report) => {
+  const rows = report.reach.map(
+    (one) => `| \`${one.rule}\` | ${one.firedInA ? "yes" : "NO"} | ${one.firedInB ? "yes" : "NO"} |`
+  );
+  const outside = report.outside.length === 0 ? "None \u2014 this corpus speaks for every rule the configs enable.\n" : `${report.outside.map((rule) => `- \`${rule}\``).join("\n")}
+`;
+  return [
+    "# corpus reach",
+    "",
+    `- rules in scope of this corpus: **${report.reach.length}**`,
+    `- fired under neither config: **${report.neither.length}**`,
+    `- outside this corpus: **${report.outside.length}**`,
+    "",
+    report.neither.length === 0 ? "**PASS** \u2014 every in-scope rule has at least one corpus file that fires it." : `**FAIL** \u2014 these rules fire nowhere in the corpus, so nothing shows they reach anything:
+${report.neither.map((rule) => `- \`${rule}\``).join("\n")}`,
+    "",
+    "## per rule",
+    "",
+    "| rule | fired under A | fired under B |",
+    "|---|---|---|",
+    ...rows,
+    "",
+    "## outside this corpus",
+    "",
+    `Configured rules this corpus never claimed to exercise. It speaks for \`${report.plugin}\` only,`,
+    "so it is no evidence either way about these and passes no verdict on them.",
+    "",
+    outside
+  ].join("\n");
+};
+var FLAGS = { "--a": "configA", "--b": "configB", "--out": "out", "--oxlint": "oxlint" };
+var CORPUS_FLAG = "--corpus";
+var parseParityArgs = (argv) => {
+  const at = argv.indexOf("--");
+  const flags = at === -1 ? argv : argv.slice(0, at);
+  const paths = at === -1 ? [] : argv.slice(at + 1);
+  const read = {};
+  let corpus = false;
+  let corpusDir;
+  for (let index = 0; index < flags.length; index += 1) {
+    const flag = flags[index];
+    const value = flags[index + 1];
+    if (flag === CORPUS_FLAG) {
+      corpus = true;
+      if (value !== void 0 && !value.startsWith("--")) {
+        corpusDir = value;
+        index += 1;
+      }
+      continue;
+    }
+    const name = FLAGS[flag];
+    if (name === void 0) throw new Error(`geonosis-lint-parity: unknown argument "${flag}"`);
+    if (value === void 0 || value.startsWith("--")) {
+      throw new Error(`geonosis-lint-parity: ${flag} needs a value`);
+    }
+    read[name] = value;
+    index += 1;
+  }
+  if (read.configA === void 0 || read.configB === void 0) {
+    throw new Error(
+      "geonosis-lint-parity: both --a and --b are required \u2014 one config compares to nothing"
+    );
+  }
+  return {
+    configA: read.configA,
+    configB: read.configB,
+    corpus,
+    ...corpusDir === void 0 ? {} : { corpusDir },
+    ...read.out === void 0 ? {} : { out: read.out },
+    ...read.oxlint === void 0 ? {} : { oxlint: read.oxlint },
+    paths: paths.length === 0 ? ["."] : paths
+  };
+};
+var lint = ({
+  config,
+  cwd,
+  extra = [],
+  oxlint,
+  paths
+}) => {
+  const run = spawnSync(oxlint, ["--format=unix", ...extra, "--config", config, ...paths], {
+    cwd,
+    encoding: "utf8",
+    env: { ...process.env, NO_COLOR: "1" },
+    maxBuffer: 64 * 1024 * 1024
+  });
+  if (run.error !== void 0)
+    throw new ParityError(`could not run ${oxlint}: ${run.error.message}`);
+  return { code: run.status ?? -1, output: `${run.stdout ?? ""}${run.stderr ?? ""}` };
+};
+var parityOf = ({
+  configA,
+  configB,
+  cwd,
+  out,
+  oxlint,
+  paths
+}) => {
+  const parity = compareFindings({
+    a: readRun(lint({ config: configA, cwd, oxlint, paths }), cwd, "A"),
+    b: readRun(lint({ config: configB, cwd, oxlint, paths }), cwd, "B")
+  });
+  if (out !== void 0) {
+    mkdirSync(out, { recursive: true });
+    writeFileSync(join(out, "a.txt"), asFile(parity.a));
+    writeFileSync(join(out, "b.txt"), asFile(parity.b));
+    writeFileSync(join(out, "only-in-a.txt"), asFile(parity.onlyInA));
+    writeFileSync(join(out, "only-in-b.txt"), asFile(parity.onlyInB));
+    writeFileSync(join(out, "changed.txt"), asFile(changedLines(parity.messageChanged)));
+    writeFileSync(join(out, "SUMMARY.md"), formatSummary(parity));
+  }
+  return parity;
+};
+
+export {
+  ParityError,
+  normaliseFindings,
+  readRun,
+  compareFindings,
+  formatSummary,
+  rulesNamedBy,
+  ruleIdOf,
+  MANIFEST_FILE,
+  manifestOf,
+  readManifest,
+  corpusOf,
+  formatCorpus,
+  parseParityArgs,
+  parityOf
+};

package/dist/chunk-SUTNA6YD.js

@@ -0,0 +1,268 @@
+import {
+  PLUGIN_NAME
+} from "./chunk-BFFWNFJM.js";
+
+// src/parity.ts
+import { spawnSync } from "child_process";
+import { cpSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "fs";
+import { tmpdir } from "os";
+import { join } from "path";
+var ANSI = /\[[0-9;]*m/g;
+var SUMMARY_COUNT = /^(\d+) problems?$/m;
+var RULE_IN_LINE = /\[(?:Error|Warning)\/([^\]]+)\]$/;
+var UNIX_FINDING = /^\S[^\n]*:\d+:\d+: .*\[(?:Error|Warning)\/[^\]\n]+\]$/;
+var ParityError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ParityError";
+  }
+};
+var normaliseFindings = (output, cwd) => output.replaceAll(ANSI, "").split("\n").map((line) => line.trim().replace(`${cwd}/`, "").replace(/^\.\//, "")).filter((line) => UNIX_FINDING.test(line)).toSorted();
+var readRun = ({ code, output }, cwd, side) => {
+  const findings = normaliseFindings(output, cwd);
+  const summary = SUMMARY_COUNT.exec(output);
+  const refuse = (why) => {
+    throw new ParityError(`config ${side}: ${why}
+${output.trim()}`);
+  };
+  if (summary?.[1] !== void 0 && Number(summary[1]) !== findings.length) {
+    return refuse(`oxlint says ${summary[1]} problems, ${findings.length} lines parsed as findings`);
+  }
+  if (findings.length === 0 && code !== 0) {
+    return refuse(`oxlint exited ${code} without reporting a single finding`);
+  }
+  return findings;
+};
+var UNATTRIBUTED = "(unattributed)";
+var ruleOf = (line) => RULE_IN_LINE.exec(line)?.[1] ?? UNATTRIBUTED;
+var asFile = (lines) => lines.length === 0 ? "" : `${lines.join("\n")}
+`;
+var countByRule = (lines) => {
+  const counts = /* @__PURE__ */ new Map();
+  for (const line of lines) counts.set(ruleOf(line), (counts.get(ruleOf(line)) ?? 0) + 1);
+  return counts;
+};
+var missingFrom = (lines, other) => {
+  const remaining = /* @__PURE__ */ new Map();
+  for (const line of other) remaining.set(line, (remaining.get(line) ?? 0) + 1);
+  return lines.filter((line) => {
+    const left = remaining.get(line) ?? 0;
+    if (left === 0) return true;
+    remaining.set(line, left - 1);
+    return false;
+  });
+};
+var compareFindings = ({ a, b }) => {
+  const inA = countByRule(a);
+  const inB = countByRule(b);
+  const onlyInA = missingFrom(a, b);
+  return {
+    a,
+    b,
+    lost: onlyInA.length > 0,
+    onlyInA,
+    onlyInB: missingFrom(b, a),
+    tally: [.../* @__PURE__ */ new Set([...inA.keys(), ...inB.keys()])].toSorted().map((rule) => ({
+      a: inA.get(rule) ?? 0,
+      b: inB.get(rule) ?? 0,
+      rule
+    }))
+  };
+};
+var formatSummary = (parity) => {
+  const rows = parity.tally.map(
+    (one) => `| \`${one.rule}\` | ${one.a} | ${one.b} | ${one.b - one.a >= 0 ? "+" : ""}${one.b - one.a} |`
+  );
+  const lost = parity.onlyInA.length === 0 ? "None. Every finding A reported, B reported too.\n" : `${parity.onlyInA.map((line) => `- \`${line}\``).join("\n")}
+`;
+  const gained = parity.onlyInB.length === 0 ? "None.\n" : `${parity.onlyInB.map((line) => `- \`${line}\``).join("\n")}
+`;
+  return [
+    "# findings parity",
+    "",
+    `- findings A: **${parity.a.length}**`,
+    `- findings B: **${parity.b.length}**`,
+    `- only in A (lost): **${parity.onlyInA.length}**`,
+    `- only in B (gained): **${parity.onlyInB.length}**`,
+    "",
+    `**${parity.lost ? "FAIL" : "PASS"}** \u2014 ${parity.lost ? "B lost findings A reported. A rule that fired under A and fires nowhere under B stops the adoption." : "B reported everything A did."}`,
+    "",
+    "## per rule",
+    "",
+    "| rule | A | B | delta |",
+    "|---|---:|---:|---:|",
+    ...rows,
+    "",
+    "## only in A (lost)",
+    "",
+    lost,
+    "## only in B (gained)",
+    "",
+    gained
+  ].join("\n");
+};
+var rulesNamedBy = (config) => {
+  const parsed = JSON.parse(readFileSync(config, "utf8"));
+  return Object.keys(parsed.rules ?? {});
+};
+var ruleIdOf = (line) => {
+  const token = RULE_IN_LINE.exec(line)?.[1];
+  if (token === void 0) return UNATTRIBUTED;
+  const at = token.indexOf("(");
+  return at === -1 ? token : `${token.slice(0, at)}/${token.slice(at + 1, -1)}`;
+};
+var CORPUS_PLUGIN = `${PLUGIN_NAME}/`;
+var corpusOf = ({
+  configA,
+  configB,
+  corpus,
+  oxlint
+}) => {
+  const root = mkdtempSync(join(tmpdir(), "geonosis-corpus-"));
+  const here = join(root, "corpus");
+  const firedIn = (config, side) => new Set(
+    readRun(
+      lint({
+        config,
+        cwd: root,
+        extra: ["--no-ignore", "--disable-nested-config"],
+        oxlint,
+        paths: [here]
+      }),
+      root,
+      side
+    ).map(ruleIdOf)
+  );
+  let inA = /* @__PURE__ */ new Set();
+  let inB = /* @__PURE__ */ new Set();
+  try {
+    cpSync(corpus, here, { recursive: true });
+    inA = firedIn(configA, "A");
+    inB = firedIn(configB, "B");
+  } finally {
+    rmSync(root, { force: true, recursive: true });
+  }
+  const configured = [.../* @__PURE__ */ new Set([...rulesNamedBy(configA), ...rulesNamedBy(configB)])].toSorted();
+  const reach = configured.filter((rule) => rule.startsWith(CORPUS_PLUGIN)).map((rule) => ({ firedInA: inA.has(rule), firedInB: inB.has(rule), rule }));
+  return {
+    neither: reach.filter((one) => !one.firedInA && !one.firedInB).map((one) => one.rule),
+    outside: configured.filter((rule) => !rule.startsWith(CORPUS_PLUGIN)),
+    reach
+  };
+};
+var formatCorpus = (report) => {
+  const rows = report.reach.map(
+    (one) => `| \`${one.rule}\` | ${one.firedInA ? "yes" : "NO"} | ${one.firedInB ? "yes" : "NO"} |`
+  );
+  const outside = report.outside.length === 0 ? "None \u2014 every configured rule belongs to this plugin.\n" : `${report.outside.map((rule) => `- \`${rule}\``).join("\n")}
+`;
+  return [
+    "# corpus reach",
+    "",
+    `- rules in scope of this corpus: **${report.reach.length}**`,
+    `- fired under neither config: **${report.neither.length}**`,
+    `- outside this corpus: **${report.outside.length}**`,
+    "",
+    report.neither.length === 0 ? "**PASS** \u2014 every in-scope rule has at least one corpus file that fires it." : `**FAIL** \u2014 these rules fire nowhere in the corpus, so nothing shows they reach anything:
+${report.neither.map((rule) => `- \`${rule}\``).join("\n")}`,
+    "",
+    "## per rule",
+    "",
+    "| rule | fired under A | fired under B |",
+    "|---|---|---|",
+    ...rows,
+    "",
+    `## outside this corpus`,
+    "",
+    `Configured rules from other plugins and the built-ins. This corpus exercises \`${CORPUS_PLUGIN}\``,
+    "only, so it is no evidence either way about these and passes no verdict on them.",
+    "",
+    outside
+  ].join("\n");
+};
+var FLAGS = { "--a": "configA", "--b": "configB", "--out": "out", "--oxlint": "oxlint" };
+var CORPUS_FLAG = "--corpus";
+var parseParityArgs = (argv) => {
+  const at = argv.indexOf("--");
+  const flags = (at === -1 ? argv : argv.slice(0, at)).filter((one) => one !== CORPUS_FLAG);
+  const paths = at === -1 ? [] : argv.slice(at + 1);
+  const corpus = (at === -1 ? argv : argv.slice(0, at)).includes(CORPUS_FLAG);
+  const read = {};
+  for (let index = 0; index < flags.length; index += 1) {
+    const flag = flags[index];
+    const name = FLAGS[flag];
+    if (name === void 0) throw new Error(`geonosis-lint-parity: unknown argument "${flag}"`);
+    const value = flags[index + 1];
+    if (value === void 0 || value.startsWith("--")) {
+      throw new Error(`geonosis-lint-parity: ${flag} needs a value`);
+    }
+    read[name] = value;
+    index += 1;
+  }
+  if (read.configA === void 0 || read.configB === void 0) {
+    throw new Error(
+      "geonosis-lint-parity: both --a and --b are required \u2014 one config compares to nothing"
+    );
+  }
+  return {
+    configA: read.configA,
+    configB: read.configB,
+    corpus,
+    ...read.out === void 0 ? {} : { out: read.out },
+    ...read.oxlint === void 0 ? {} : { oxlint: read.oxlint },
+    paths: paths.length === 0 ? ["."] : paths
+  };
+};
+var lint = ({
+  config,
+  cwd,
+  extra = [],
+  oxlint,
+  paths
+}) => {
+  const run = spawnSync(oxlint, ["--format=unix", ...extra, "--config", config, ...paths], {
+    cwd,
+    encoding: "utf8",
+    env: { ...process.env, NO_COLOR: "1" },
+    maxBuffer: 64 * 1024 * 1024
+  });
+  if (run.error !== void 0)
+    throw new ParityError(`could not run ${oxlint}: ${run.error.message}`);
+  return { code: run.status ?? -1, output: `${run.stdout ?? ""}${run.stderr ?? ""}` };
+};
+var parityOf = ({
+  configA,
+  configB,
+  cwd,
+  out,
+  oxlint,
+  paths
+}) => {
+  const parity = compareFindings({
+    a: readRun(lint({ config: configA, cwd, oxlint, paths }), cwd, "A"),
+    b: readRun(lint({ config: configB, cwd, oxlint, paths }), cwd, "B")
+  });
+  if (out !== void 0) {
+    mkdirSync(out, { recursive: true });
+    writeFileSync(join(out, "a.txt"), asFile(parity.a));
+    writeFileSync(join(out, "b.txt"), asFile(parity.b));
+    writeFileSync(join(out, "only-in-a.txt"), asFile(parity.onlyInA));
+    writeFileSync(join(out, "only-in-b.txt"), asFile(parity.onlyInB));
+    writeFileSync(join(out, "SUMMARY.md"), formatSummary(parity));
+  }
+  return parity;
+};
+
+export {
+  ParityError,
+  normaliseFindings,
+  readRun,
+  compareFindings,
+  formatSummary,
+  rulesNamedBy,
+  ruleIdOf,
+  corpusOf,
+  formatCorpus,
+  parseParityArgs,
+  parityOf
+};

package/dist/chunk-YIAUS4GG.js

@@ -0,0 +1,298 @@
+// src/parity.ts
+import { spawnSync } from "child_process";
+import { cpSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "fs";
+import { tmpdir } from "os";
+import { join } from "path";
+var ANSI = /\[[0-9;]*m/g;
+var SUMMARY_COUNT = /^(\d+) problems?$/m;
+var RULE_IN_LINE = /\[(?:Error|Warning)\/([^\]]+)\]$/;
+var UNIX_FINDING = /^\S[^\n]*:\d+:\d+: .*\[(?:Error|Warning)\/[^\]\n]+\]$/;
+var ParityError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ParityError";
+  }
+};
+var normaliseFindings = (output, cwd) => output.replaceAll(ANSI, "").split("\n").map((line) => line.trim().replace(`${cwd}/`, "").replace(/^\.\//, "")).filter((line) => UNIX_FINDING.test(line)).toSorted();
+var readRun = ({ code, output }, cwd, side) => {
+  const findings = normaliseFindings(output, cwd);
+  const summary = SUMMARY_COUNT.exec(output);
+  const refuse = (why) => {
+    throw new ParityError(`config ${side}: ${why}
+${output.trim()}`);
+  };
+  if (summary?.[1] !== void 0 && Number(summary[1]) !== findings.length) {
+    return refuse(`oxlint says ${summary[1]} problems, ${findings.length} lines parsed as findings`);
+  }
+  if (findings.length === 0 && code !== 0) {
+    return refuse(`oxlint exited ${code} without reporting a single finding`);
+  }
+  return findings;
+};
+var UNATTRIBUTED = "(unattributed)";
+var ruleOf = (line) => RULE_IN_LINE.exec(line)?.[1] ?? UNATTRIBUTED;
+var asFile = (lines) => lines.length === 0 ? "" : `${lines.join("\n")}
+`;
+var countByRule = (lines) => {
+  const counts = /* @__PURE__ */ new Map();
+  for (const line of lines) counts.set(ruleOf(line), (counts.get(ruleOf(line)) ?? 0) + 1);
+  return counts;
+};
+var missingFrom = (lines, other) => {
+  const remaining = /* @__PURE__ */ new Map();
+  for (const line of other) remaining.set(line, (remaining.get(line) ?? 0) + 1);
+  return lines.filter((line) => {
+    const left = remaining.get(line) ?? 0;
+    if (left === 0) return true;
+    remaining.set(line, left - 1);
+    return false;
+  });
+};
+var compareFindings = ({ a, b }) => {
+  const inA = countByRule(a);
+  const inB = countByRule(b);
+  const onlyInA = missingFrom(a, b);
+  return {
+    a,
+    b,
+    lost: onlyInA.length > 0,
+    onlyInA,
+    onlyInB: missingFrom(b, a),
+    tally: [.../* @__PURE__ */ new Set([...inA.keys(), ...inB.keys()])].toSorted().map((rule) => ({
+      a: inA.get(rule) ?? 0,
+      b: inB.get(rule) ?? 0,
+      rule
+    }))
+  };
+};
+var formatSummary = (parity) => {
+  const rows = parity.tally.map(
+    (one) => `| \`${one.rule}\` | ${one.a} | ${one.b} | ${one.b - one.a >= 0 ? "+" : ""}${one.b - one.a} |`
+  );
+  const lost = parity.onlyInA.length === 0 ? "None. Every finding A reported, B reported too.\n" : `${parity.onlyInA.map((line) => `- \`${line}\``).join("\n")}
+`;
+  const gained = parity.onlyInB.length === 0 ? "None.\n" : `${parity.onlyInB.map((line) => `- \`${line}\``).join("\n")}
+`;
+  return [
+    "# findings parity",
+    "",
+    `- findings A: **${parity.a.length}**`,
+    `- findings B: **${parity.b.length}**`,
+    `- only in A (lost): **${parity.onlyInA.length}**`,
+    `- only in B (gained): **${parity.onlyInB.length}**`,
+    "",
+    `**${parity.lost ? "FAIL" : "PASS"}** \u2014 ${parity.lost ? "B lost findings A reported. A rule that fired under A and fires nowhere under B stops the adoption." : "B reported everything A did."}`,
+    "",
+    "## per rule",
+    "",
+    "| rule | A | B | delta |",
+    "|---|---:|---:|---:|",
+    ...rows,
+    "",
+    "## only in A (lost)",
+    "",
+    lost,
+    "## only in B (gained)",
+    "",
+    gained
+  ].join("\n");
+};
+var rulesNamedBy = (config) => {
+  const parsed = JSON.parse(readFileSync(config, "utf8"));
+  return Object.keys(parsed.rules ?? {});
+};
+var ruleIdOf = (line) => {
+  const token = RULE_IN_LINE.exec(line)?.[1];
+  if (token === void 0) return UNATTRIBUTED;
+  const at = token.indexOf("(");
+  return at === -1 ? token : `${token.slice(0, at)}/${token.slice(at + 1, -1)}`;
+};
+var MANIFEST_FILE = "manifest.json";
+var manifestOf = (plugin) => ({
+  plugin: plugin.meta.name,
+  rules: Object.keys(plugin.rules).map((rule) => `${plugin.meta.name}/${rule}`).toSorted()
+});
+var readManifest = (corpus) => {
+  const path = join(corpus, MANIFEST_FILE);
+  let parsed;
+  try {
+    parsed = JSON.parse(readFileSync(path, "utf8"));
+  } catch (error) {
+    throw new ParityError(`could not read ${path}: ${error.message}`);
+  }
+  const manifest = parsed;
+  if (typeof manifest.plugin !== "string" || !Array.isArray(manifest.rules)) {
+    throw new ParityError(`${path} names no plugin and no rules \u2014 it cannot scope a reach run`);
+  }
+  return { plugin: manifest.plugin, rules: manifest.rules };
+};
+var corpusOf = ({
+  configA,
+  configB,
+  corpus,
+  oxlint
+}) => {
+  const manifest = readManifest(corpus);
+  const exercised = new Set(manifest.rules);
+  const root = mkdtempSync(join(tmpdir(), "geonosis-corpus-"));
+  const here = join(root, "corpus");
+  const firedIn = (config, side) => new Set(
+    readRun(
+      lint({
+        config,
+        cwd: root,
+        extra: ["--no-ignore", "--disable-nested-config"],
+        oxlint,
+        paths: [here]
+      }),
+      root,
+      side
+    ).map(ruleIdOf)
+  );
+  let inA = /* @__PURE__ */ new Set();
+  let inB = /* @__PURE__ */ new Set();
+  try {
+    cpSync(corpus, here, { recursive: true });
+    inA = firedIn(configA, "A");
+    inB = firedIn(configB, "B");
+  } finally {
+    rmSync(root, { force: true, recursive: true });
+  }
+  const configured = [.../* @__PURE__ */ new Set([...rulesNamedBy(configA), ...rulesNamedBy(configB)])].toSorted();
+  const reach = configured.filter((rule) => exercised.has(rule)).map((rule) => ({ firedInA: inA.has(rule), firedInB: inB.has(rule), rule }));
+  return {
+    neither: reach.filter((one) => !one.firedInA && !one.firedInB).map((one) => one.rule),
+    outside: configured.filter((rule) => !exercised.has(rule)),
+    plugin: manifest.plugin,
+    reach
+  };
+};
+var formatCorpus = (report) => {
+  const rows = report.reach.map(
+    (one) => `| \`${one.rule}\` | ${one.firedInA ? "yes" : "NO"} | ${one.firedInB ? "yes" : "NO"} |`
+  );
+  const outside = report.outside.length === 0 ? "None \u2014 this corpus speaks for every rule the configs enable.\n" : `${report.outside.map((rule) => `- \`${rule}\``).join("\n")}
+`;
+  return [
+    "# corpus reach",
+    "",
+    `- rules in scope of this corpus: **${report.reach.length}**`,
+    `- fired under neither config: **${report.neither.length}**`,
+    `- outside this corpus: **${report.outside.length}**`,
+    "",
+    report.neither.length === 0 ? "**PASS** \u2014 every in-scope rule has at least one corpus file that fires it." : `**FAIL** \u2014 these rules fire nowhere in the corpus, so nothing shows they reach anything:
+${report.neither.map((rule) => `- \`${rule}\``).join("\n")}`,
+    "",
+    "## per rule",
+    "",
+    "| rule | fired under A | fired under B |",
+    "|---|---|---|",
+    ...rows,
+    "",
+    "## outside this corpus",
+    "",
+    `Configured rules this corpus never claimed to exercise. It speaks for \`${report.plugin}\` only,`,
+    "so it is no evidence either way about these and passes no verdict on them.",
+    "",
+    outside
+  ].join("\n");
+};
+var FLAGS = { "--a": "configA", "--b": "configB", "--out": "out", "--oxlint": "oxlint" };
+var CORPUS_FLAG = "--corpus";
+var parseParityArgs = (argv) => {
+  const at = argv.indexOf("--");
+  const flags = at === -1 ? argv : argv.slice(0, at);
+  const paths = at === -1 ? [] : argv.slice(at + 1);
+  const read = {};
+  let corpus = false;
+  let corpusDir;
+  for (let index = 0; index < flags.length; index += 1) {
+    const flag = flags[index];
+    const value = flags[index + 1];
+    if (flag === CORPUS_FLAG) {
+      corpus = true;
+      if (value !== void 0 && !value.startsWith("--")) {
+        corpusDir = value;
+        index += 1;
+      }
+      continue;
+    }
+    const name = FLAGS[flag];
+    if (name === void 0) throw new Error(`geonosis-lint-parity: unknown argument "${flag}"`);
+    if (value === void 0 || value.startsWith("--")) {
+      throw new Error(`geonosis-lint-parity: ${flag} needs a value`);
+    }
+    read[name] = value;
+    index += 1;
+  }
+  if (read.configA === void 0 || read.configB === void 0) {
+    throw new Error(
+      "geonosis-lint-parity: both --a and --b are required \u2014 one config compares to nothing"
+    );
+  }
+  return {
+    configA: read.configA,
+    configB: read.configB,
+    corpus,
+    ...corpusDir === void 0 ? {} : { corpusDir },
+    ...read.out === void 0 ? {} : { out: read.out },
+    ...read.oxlint === void 0 ? {} : { oxlint: read.oxlint },
+    paths: paths.length === 0 ? ["."] : paths
+  };
+};
+var lint = ({
+  config,
+  cwd,
+  extra = [],
+  oxlint,
+  paths
+}) => {
+  const run = spawnSync(oxlint, ["--format=unix", ...extra, "--config", config, ...paths], {
+    cwd,
+    encoding: "utf8",
+    env: { ...process.env, NO_COLOR: "1" },
+    maxBuffer: 64 * 1024 * 1024
+  });
+  if (run.error !== void 0)
+    throw new ParityError(`could not run ${oxlint}: ${run.error.message}`);
+  return { code: run.status ?? -1, output: `${run.stdout ?? ""}${run.stderr ?? ""}` };
+};
+var parityOf = ({
+  configA,
+  configB,
+  cwd,
+  out,
+  oxlint,
+  paths
+}) => {
+  const parity = compareFindings({
+    a: readRun(lint({ config: configA, cwd, oxlint, paths }), cwd, "A"),
+    b: readRun(lint({ config: configB, cwd, oxlint, paths }), cwd, "B")
+  });
+  if (out !== void 0) {
+    mkdirSync(out, { recursive: true });
+    writeFileSync(join(out, "a.txt"), asFile(parity.a));
+    writeFileSync(join(out, "b.txt"), asFile(parity.b));
+    writeFileSync(join(out, "only-in-a.txt"), asFile(parity.onlyInA));
+    writeFileSync(join(out, "only-in-b.txt"), asFile(parity.onlyInB));
+    writeFileSync(join(out, "SUMMARY.md"), formatSummary(parity));
+  }
+  return parity;
+};
+
+export {
+  ParityError,
+  normaliseFindings,
+  readRun,
+  compareFindings,
+  formatSummary,
+  rulesNamedBy,
+  ruleIdOf,
+  MANIFEST_FILE,
+  manifestOf,
+  readManifest,
+  corpusOf,
+  formatCorpus,
+  parseParityArgs,
+  parityOf
+};

package/dist/index.js

@@ -2,6 +2,9 @@ import {
   PRESETS
 } from "./chunk-74VWOEPL.js";
 
+// src/index.ts
+import { createRequire } from "module";
+
 // src/rules/atom-no-deps.ts
 var FORBIDDEN_PATTERNS = [
   /molecules\//,
@@ -3909,11 +3912,12 @@ var rules = {
   "worker-handles-are-scoped": worker_handles_are_scoped_default,
   "zustand-v5-best-practices": zustand_v5_best_practices_default
 };
+var { version } = createRequire(import.meta.url)("../package.json");
 var plugin = {
   configs: PRESETS,
   meta: {
     name: "biological-architecture",
-    version: "0.1.0"
+    version
   },
   rules
 };

package/dist/parity-cli.js

@@ -4,22 +4,29 @@ import {
   formatSummary,
   parityOf,
   parseParityArgs
-} from "./chunk-UM6UIUH3.js";
+} from "./chunk-NZVMV3Y5.js";
 
 // src/parity-cli.ts
 import { existsSync, mkdirSync, writeFileSync } from "fs";
 import { dirname, join, resolve } from "path";
 import { fileURLToPath } from "url";
 var USAGE = `geonosis-lint-parity --a <config-a.json> --b <config-b.json> [--oxlint <path>] [--out <dir>] -- <paths\u2026>
-geonosis-lint-parity --corpus --a <config-a.json> --b <config-b.json> [--out <dir>]
+geonosis-lint-parity --corpus [<dir>] --a <config-a.json> --b <config-b.json> [--out <dir>]
 
 Runs oxlint twice over the same paths under two configs and diffs the findings. Exits 1 when a
 finding config A reported is missing under config B \u2014 a rule that fired before and fires nowhere
 now is the adoption stopping, whatever the version numbers say.
 
---corpus runs both configs over the reach corpus this package ships \u2014 one file per rule that the
-rule must fire on \u2014 and exits 1 when a configured rule fires under NEITHER. Run it first: a rule
-with no reach evidence reports parity with every other rule that also does nothing.`;
+--corpus runs both configs over a reach corpus \u2014 one file per rule that the rule must fire on \u2014
+and exits 1 when a rule the corpus claims to exercise fires under NEITHER. Run it first: a rule
+with no reach evidence reports parity with every other rule that also does nothing. It defaults to
+the corpus this package ships; give it a directory to use another plugin's. A corpus names the
+rules it speaks for in its own manifest.json, and rules outside that list are reported unjudged.
+
+oxlint resolves a jsPlugins specifier relative to the CONFIG FILE's directory, not the working
+directory. Write both configs INSIDE the workspace being linted, or name the plugin by absolute
+path \u2014 a config in a temp dir cannot find a plugin installed in the workspace, and the run is
+refused rather than counted as zero findings.`;
 var CORPUS = resolve(dirname(fileURLToPath(import.meta.url)), "../corpus");
 var resolveOxlint = (from) => {
   let dir = from;
@@ -44,7 +51,8 @@ var main = () => {
   const configB = resolve(cwd, args.configB);
   const oxlint = args.oxlint ?? resolveOxlint(cwd);
   if (args.corpus) {
-    const report = corpusOf({ configA, configB, corpus: CORPUS, oxlint });
+    const corpus = args.corpusDir === void 0 ? CORPUS : resolve(cwd, args.corpusDir);
+    const report = corpusOf({ configA, configB, corpus, oxlint });
     const text = formatCorpus(report);
     process.stdout.write(`${text}
 `);

package/dist/parity.js

@@ -1,24 +1,32 @@
 import {
+  MANIFEST_FILE,
   ParityError,
   compareFindings,
   corpusOf,
   formatCorpus,
   formatSummary,
+  manifestOf,
   normaliseFindings,
   parityOf,
   parseParityArgs,
+  readManifest,
   readRun,
+  ruleIdOf,
   rulesNamedBy
-} from "./chunk-UM6UIUH3.js";
+} from "./chunk-NZVMV3Y5.js";
 export {
+  MANIFEST_FILE,
   ParityError,
   compareFindings,
   corpusOf,
   formatCorpus,
   formatSummary,
+  manifestOf,
   normaliseFindings,
   parityOf,
   parseParityArgs,
+  readManifest,
   readRun,
+  ruleIdOf,
   rulesNamedBy
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@geonosis/oxlint-plugin-biological-architecture",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "Biological tier architecture as lint — the union of the dielime and during.day rule sets, shipped as presets.",
   "keywords": [
     "oxlint",