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

package/dist/chunk-YIAUS4GG.js

@@ -1,298 +0,0 @@
-// 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/parity-cli.js

@@ -1,84 +0,0 @@
-import {
-  corpusOf,
-  formatCorpus,
-  formatSummary,
-  parityOf,
-  parseParityArgs
-} 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 [<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 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;
-  for (; ; ) {
-    const bin = resolve(dir, "node_modules/.bin/oxlint");
-    if (existsSync(bin)) return bin;
-    const parent = dirname(dir);
-    if (parent === dir) return "oxlint";
-    dir = parent;
-  }
-};
-var main = () => {
-  const argv = process.argv.slice(2);
-  if (argv.includes("--help") || argv.includes("-h") || argv.length === 0) {
-    process.stdout.write(`${USAGE}
-`);
-    return 0;
-  }
-  const args = parseParityArgs(argv);
-  const cwd = process.cwd();
-  const configA = resolve(cwd, args.configA);
-  const configB = resolve(cwd, args.configB);
-  const oxlint = args.oxlint ?? resolveOxlint(cwd);
-  if (args.corpus) {
-    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}
-`);
-    if (args.out !== void 0) {
-      const out = resolve(cwd, args.out);
-      mkdirSync(out, { recursive: true });
-      writeFileSync(join(out, "CORPUS.md"), text);
-    }
-    return report.neither.length > 0 ? 1 : 0;
-  }
-  const parity = parityOf({
-    configA,
-    configB,
-    cwd,
-    ...args.out === void 0 ? {} : { out: resolve(cwd, args.out) },
-    oxlint,
-    paths: args.paths
-  });
-  process.stdout.write(`${formatSummary(parity)}
-`);
-  return parity.lost ? 1 : 0;
-};
-try {
-  process.exit(main());
-} catch (error) {
-  process.stderr.write(`${error.message}
-`);
-  process.exit(2);
-}

package/dist/parity.js

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