@geonosis/ratchet 1.4.0 → 2.1.0

package/README.md

@@ -363,11 +363,12 @@ Every counter takes its `command` from the config, so the toolchain stays the re
 | `testFailures` | the runner's own failure summary — or, with `report: "vitest-json"`, `numFailedTests` out of the JSON report the command wrote; throws when nothing is readable, when the report is absent, and when the report failed with nothing failing | `command`, `report`, `reportPath` |
 | `unformattedFiles` | paths `--list-different` names that exist on disk | `command` |
 | `cloneCount` | jscpd's `Found N clones` | `command` |
-| `knipIssues` | the totals under knip's unused-* headings | `command`, `headings` |
+| `knipIssues` | the total under EVERY heading knip's compact reporter emits — the shape `<Title> (N)`, not a list of titles, so a heading the kit has not heard of is debt rather than a silent zero. `headings` narrows it, and every printed heading the narrowing leaves out must be named under `excusedHeadings` with a reason or the run refuses | `command`, `headings`, `excusedHeadings` |
 | `boundaryIssues` | `N issues found` from a boundary scan | `command` |
 | `archViolations` | lines matching a marker your own architecture scan prints, refusing a non-zero exit that printed none of them — a scan that could not run is not a clean scan | `command`, `match` |
 | `sumOfCounts` | the total of one capture group across a per-file census (`grep -rc`) | `command`, `match` |
 | `lawLineCount` | the lines of the law file — a ceiling that can only come down | `path` |
+| `probelessRules` | the rules an oxlint config ENABLES that the plugin it loads declares no `probe()` for. Those are the ones `geonosis-doctor`'s `exercised` can only answer UNJUDGED about, which #137 makes a WARN naming the kit as owner — and a WARN the kit carries across releases is a downgraded rule by another name. The plugin is imported from the tree it is pointed at, and one that cannot be loaded is a refusal, never a zero | `config`, `plugin` |
 | `runtimeCodeShipped` | 0 when a change shipped runtime code, 1 when it shipped none | `command`, `patterns` |
 | `disabledCiJobs` | lines of `if: false` across the workflow files — a job switched off to get a release through, still off. A condition that merely mentions `false` is not one. No workflows directory at all reads 0 | `dir` |
 | `bundleBytes` | one integer out of whatever your sizing command printed, separators and all; with `match`, the group that pattern names rather than the last integer, refusing when it matches nothing. **Tolerates.** | `command`, `match`, `tolerance` |
@@ -375,6 +376,7 @@ Every counter takes its `command` from the config, so the toolchain stays the re
 | `testsWithoutRunner` | workspaces holding `*.test.*`, `*.spec.*` or `__tests__/` with no `test` script — the suites nobody runs, which read exactly like suites that pass | `script` |
 | `packagesWithoutTypecheck` | workspaces with no `typecheck` script | `script` |
 | `walkFindings` | the defects in the report `geonosis-walk` wrote, over every page; with `classes`, only those classes, refusing a class the walk does not have. A missing or unparsable report is a refusal — the walk writes none when it could not run | `report`, `classes` |
+| `orphanTodos` | debt markers outside the plan graph: one naming no plan, and one naming a plan that is not in the plans directory. Leading zeroes are a spelling, so `(021)` finds `21-…md`. Fixtures, dependencies and build output are not read | `markers`, `plans`, `roots` |
 
 ### `tolerance`, and the two counters that accept one
 

package/dist/{chunk-ESN6ULZZ.js → chunk-H4PLCM5J.js}

@@ -708,20 +708,39 @@ ${said.slice(-500)}`
     return Number(found);
   }
 };
-var DEFAULT_HEADINGS = [
-  "Unused files",
-  "Unused dependencies",
-  "Unused devDependencies",
-  "Unused exports",
-  "Unused exported types"
-];
+var HEADING = /^([A-Z][A-Za-z ]+?) \((\d+)\)\s*$/gm;
+var headingsIn = (output) => {
+  const found = /* @__PURE__ */ new Map();
+  for (const [, heading = "", count = "0"] of output.matchAll(HEADING)) {
+    found.set(heading, Number(count));
+  }
+  return found;
+};
+var excusesIn = (params) => {
+  const declared = params["excusedHeadings"];
+  return new Set(
+    typeof declared === "object" && declared !== null && !Array.isArray(declared) ? Object.keys(declared) : []
+  );
+};
 var knipIssues = {
   id: "knipIssues",
   probe: { ...captured("Unused files (1)\nsrc/gone.ts\n"), expect: 1 },
+  readingParams: ["headings"],
   run: async ({ params, run }) => {
     const command = stringParam("knipIssues", params, "command", "npx knip --reporter compact");
-    const output = run(command).output;
-    return stringsParam(params, "headings", DEFAULT_HEADINGS).map((heading) => Number(output.match(new RegExp(`${heading} \\((\\d+)\\)`))?.[1] ?? 0)).reduce((sum, count) => sum + count, 0);
+    const printed = headingsIn(run(command).output);
+    const counted = stringsParam(params, "headings", [...printed.keys()]);
+    const excused = excusesIn(params);
+    const dropped = [...printed.entries()].filter(
+      ([heading, count]) => count > 0 && !counted.includes(heading) && !excused.has(heading)
+    );
+    if (dropped.length > 0) {
+      throw new CounterError(
+        "knipIssues",
+        `knip printed ${dropped.map(([heading, count]) => `${heading} (${count})`).join(", ")} and the configured "headings" counts ${counted.join(", ")} \u2014 three ways out: add each to "headings", name it under "excusedHeadings" with the reason this repo does not hold it, or remove "headings" altogether and count every heading knip prints`
+      );
+    }
+    return counted.reduce((sum, heading) => sum + (printed.get(heading) ?? 0), 0);
   }
 };
 var ISSUES = /(\d+) issues? found/;
@@ -1010,6 +1029,100 @@ var oxlintRule = {
   }
 };
 
+// src/counters/probes.ts
+import { existsSync as existsSync8, readFileSync as readFileSync9 } from "fs";
+import { createRequire } from "module";
+import { join as join6, resolve as resolve10 } from "path";
+import { pathToFileURL } from "url";
+var ID = "probelessRules";
+var OFF = /* @__PURE__ */ new Set([0, "0", "allow", "off", false]);
+var severityOf2 = (level) => Array.isArray(level) ? level[0] : level;
+var enabledIn = (config, namespace) => {
+  const on = /* @__PURE__ */ new Set();
+  for (const block of [
+    config.rules ?? {},
+    ...(config.overrides ?? []).map((one) => one.rules ?? {})
+  ]) {
+    for (const [id, level] of Object.entries(block)) {
+      if (id.startsWith(`${namespace}/`) && !OFF.has(severityOf2(level))) {
+        on.add(id.slice(namespace.length + 1));
+      }
+    }
+  }
+  return [...on].toSorted();
+};
+var probedBy = async (cwd, plugin) => {
+  let entry;
+  try {
+    entry = createRequire(join6(cwd, "noop.js")).resolve(plugin);
+  } catch (error) {
+    throw new CounterError(
+      ID,
+      `could not resolve ${plugin} from ${cwd} \u2014 ${String(error.message).split("\n")[0]}. A plugin nobody can load says nothing about which rules ship a probe, and it is not zero of them`
+    );
+  }
+  let loaded;
+  try {
+    loaded = await import(pathToFileURL(entry).href);
+  } catch (error) {
+    throw new CounterError(ID, `could not import ${entry} \u2014 ${error.message}`);
+  }
+  const namespace = loaded.default?.meta?.name;
+  if (typeof namespace !== "string" || namespace === "") {
+    throw new CounterError(
+      ID,
+      `${plugin} declares no meta.name, so nothing says which rule ids in the config are its own`
+    );
+  }
+  return {
+    namespace,
+    probed: new Set(
+      Object.entries(loaded.default?.rules ?? {}).filter(([, rule]) => typeof rule?.probe === "function").map(([name]) => name)
+    )
+  };
+};
+var PLUGIN = "@geonosis/oxlint-plugin-biological-architecture";
+var probelessRules = {
+  id: ID,
+  probe: {
+    expect: 1,
+    input: (dir) => {
+      plant(
+        dir,
+        ".oxlintrc.json",
+        JSON.stringify({
+          jsPlugins: ["probe-plugin"],
+          rules: { "x/probed": "error", "x/bare": "error" }
+        })
+      );
+      plant(
+        dir,
+        "node_modules/probe-plugin/package.json",
+        '{"name":"probe-plugin","main":"index.js"}'
+      );
+      plant(
+        dir,
+        "node_modules/probe-plugin/index.js",
+        "export default { meta: { name: 'x' }, rules: { probed: { probe: () => [], create: () => ({}) }, bare: { create: () => ({}) } } }\n"
+      );
+    },
+    params: { plugin: "probe-plugin" }
+  },
+  run: async ({ cwd, params }) => {
+    const relative = stringParam(ID, params, "config", ".oxlintrc.json");
+    const path = resolve10(cwd, relative);
+    if (!existsSync8(path)) throw new CounterError(ID, `no oxlint config at ${relative}`);
+    let config;
+    try {
+      config = JSON.parse(readFileSync9(path, "utf8"));
+    } catch (error) {
+      throw new CounterError(ID, `${relative} does not parse: ${error.message}`);
+    }
+    const { namespace, probed } = await probedBy(cwd, stringParam(ID, params, "plugin", PLUGIN));
+    return enabledIn(config, namespace).filter((rule) => !probed.has(rule)).length;
+  }
+};
+
 // src/counters/runtime-code.ts
 var DEFAULT_PATTERNS = ["^(apps|packages)/[^/]+/src/"];
 var NOT_RUNTIME = /(\.test\.|\.spec\.|__tests__\/|__fixtures__\/|\.d\.ts$)/;
@@ -1035,15 +1148,15 @@ var runtimeCodeShipped = {
 
 // src/counters/scripts.ts
 import { readdirSync as readdirSync3 } from "fs";
-import { join as join7 } from "path";
+import { join as join8 } from "path";
 
 // src/counters/workspace.ts
-import { existsSync as existsSync8, readdirSync as readdirSync2, readFileSync as readFileSync9 } from "fs";
-import { join as join6, resolve as resolve10 } from "path";
+import { existsSync as existsSync9, readdirSync as readdirSync2, readFileSync as readFileSync10 } from "fs";
+import { join as join7, resolve as resolve11 } from "path";
 var SKIP = /^(node_modules|\.)/;
 var childDirs = (dir) => {
   try {
-    return readdirSync2(dir, { withFileTypes: true }).filter((entry) => entry.isDirectory() && !SKIP.test(entry.name)).map((entry) => join6(dir, entry.name));
+    return readdirSync2(dir, { withFileTypes: true }).filter((entry) => entry.isDirectory() && !SKIP.test(entry.name)).map((entry) => join7(dir, entry.name));
   } catch {
     return [];
   }
@@ -1053,14 +1166,14 @@ var expand = (root, pattern) => {
   const segments = pattern.split("/").filter((one) => one !== "" && one !== ".");
   let dirs = [root];
   for (const segment of segments) {
-    dirs = segment === "*" ? dirs.flatMap((dir) => childDirs(dir)) : segment === "**" ? dirs.flatMap((dir) => descendants(dir, 3)) : dirs.map((dir) => join6(dir, segment)).filter((dir) => existsSync8(dir));
+    dirs = segment === "*" ? dirs.flatMap((dir) => childDirs(dir)) : segment === "**" ? dirs.flatMap((dir) => descendants(dir, 3)) : dirs.map((dir) => join7(dir, segment)).filter((dir) => existsSync9(dir));
   }
   return dirs;
 };
 var QUOTED = /^['"]|['"]$/g;
 var cleaned = (value) => value.replace(/#.*$/, "").trim().replaceAll(QUOTED, "");
 var pnpmPatterns = (path) => {
-  const lines = readFileSync9(path, "utf8").split("\n");
+  const lines = readFileSync10(path, "utf8").split("\n");
   const at = lines.findIndex((line) => line.startsWith("packages:"));
   if (at === -1) return [];
   const inline = lines[at]?.slice("packages:".length).trim() ?? "";
@@ -1079,31 +1192,31 @@ var pnpmPatterns = (path) => {
   return patterns;
 };
 var npmPatterns = (path) => {
-  const parsed = JSON.parse(readFileSync9(path, "utf8"));
+  const parsed = JSON.parse(readFileSync10(path, "utf8"));
   const declared = Array.isArray(parsed.workspaces) ? parsed.workspaces : parsed.workspaces?.packages ?? [];
   return declared.filter((one) => typeof one === "string");
 };
 var nameOf = (dir) => {
-  const manifest = join6(dir, "package.json");
-  if (!existsSync8(manifest)) return void 0;
+  const manifest = join7(dir, "package.json");
+  if (!existsSync9(manifest)) return void 0;
   try {
-    const { name } = JSON.parse(readFileSync9(manifest, "utf8"));
+    const { name } = JSON.parse(readFileSync10(manifest, "utf8"));
     return typeof name === "string" && name !== "" ? name : void 0;
   } catch {
     return void 0;
   }
 };
 var workspaceDirs = (cwd) => {
-  const root = resolve10(cwd);
-  const pnpm = join6(root, "pnpm-workspace.yaml");
-  const manifest = join6(root, "package.json");
-  const patterns = existsSync8(pnpm) ? pnpmPatterns(pnpm) : existsSync8(manifest) ? npmPatterns(manifest) : [];
-  const dirs = patterns.filter((pattern) => !pattern.startsWith("!")).flatMap((pattern) => expand(root, pattern)).filter((dir) => existsSync8(join6(dir, "package.json")));
+  const root = resolve11(cwd);
+  const pnpm = join7(root, "pnpm-workspace.yaml");
+  const manifest = join7(root, "package.json");
+  const patterns = existsSync9(pnpm) ? pnpmPatterns(pnpm) : existsSync9(manifest) ? npmPatterns(manifest) : [];
+  const dirs = patterns.filter((pattern) => !pattern.startsWith("!")).flatMap((pattern) => expand(root, pattern)).filter((dir) => existsSync9(join7(dir, "package.json")));
   return [...new Set(dirs)];
 };
 var manifestOf = (dir) => {
   try {
-    const parsed = JSON.parse(readFileSync9(join6(dir, "package.json"), "utf8"));
+    const parsed = JSON.parse(readFileSync10(join7(dir, "package.json"), "utf8"));
     return typeof parsed === "object" && parsed !== null ? parsed : void 0;
   } catch {
     return void 0;
@@ -1133,7 +1246,7 @@ var holdsTests = (dir, depth = 6) => {
     if (entry.isDirectory()) {
       if (entry.name === TEST_DIR) return true;
       if (SKIP2.test(entry.name) || depth === 0) continue;
-      if (holdsTests(join7(dir, entry.name), depth - 1)) return true;
+      if (holdsTests(join8(dir, entry.name), depth - 1)) return true;
       continue;
     }
     if (TEST_FILE.test(entry.name)) return true;
@@ -1192,8 +1305,8 @@ var sumOfCounts = {
 };
 
 // src/counters/suppressions.ts
-import { readdirSync as readdirSync4, readFileSync as readFileSync10 } from "fs";
-import { join as join8, resolve as resolve11 } from "path";
+import { readdirSync as readdirSync4, readFileSync as readFileSync11 } from "fs";
+import { join as join9, resolve as resolve12 } from "path";
 var CODE_FILE = /\.(?:ts|tsx|js|jsx|mjs|cjs|mts|cts|vue|svelte|astro)$/;
 var SKIP3 = /^(?:node_modules|dist|coverage|\.[^.]|__fixtures__)/;
 var SUPPRESSION = /(?:eslint|oxlint|biome)-(?:disable|ignore)(?:-next-line|-line)?|@ts-expect-error|@ts-ignore/g;
@@ -1208,12 +1321,12 @@ var countIn = (dir, depth = 12) => {
   for (const entry of entries) {
     if (SKIP3.test(entry.name)) continue;
     if (entry.isDirectory()) {
-      if (depth > 0) found += countIn(join8(dir, entry.name), depth - 1);
+      if (depth > 0) found += countIn(join9(dir, entry.name), depth - 1);
       continue;
     }
     if (!CODE_FILE.test(entry.name)) continue;
     try {
-      found += readFileSync10(join8(dir, entry.name), "utf8").match(SUPPRESSION)?.length ?? 0;
+      found += readFileSync11(join9(dir, entry.name), "utf8").match(SUPPRESSION)?.length ?? 0;
     } catch {
     }
   }
@@ -1227,14 +1340,14 @@ var suppressionCount = {
   },
   run: async ({ cwd, params }) => {
     const roots = stringsParam(params, "roots", ["."]);
-    return roots.reduce((sum, root) => sum + countIn(resolve11(cwd, root)), 0);
+    return roots.reduce((sum, root) => sum + countIn(resolve12(cwd, root)), 0);
   }
 };
 
 // src/counters/tests.ts
-import { existsSync as existsSync9, mkdtempSync as mkdtempSync2, readFileSync as readFileSync11, rmSync as rmSync4 } from "fs";
+import { existsSync as existsSync10, mkdtempSync as mkdtempSync2, readFileSync as readFileSync12, rmSync as rmSync4 } from "fs";
 import { tmpdir as tmpdir2 } from "os";
-import { join as join9, resolve as resolve12 } from "path";
+import { join as join10, resolve as resolve13 } from "path";
 var COUNTER = "testFailures";
 var VITEST_LINE = /^\s*Tests {2,}(.+?)\s*$/;
 var VITEST_TOTAL = /\(\d+\)$/;
@@ -1266,7 +1379,7 @@ ${output.trim().slice(-500)}`
   );
 };
 var fromReport = (path) => {
-  if (!existsSync9(path)) {
+  if (!existsSync10(path)) {
     throw new CounterError(
       COUNTER,
       `the runner wrote no report at ${path} \u2014 a crash before the reporter is not a pass`
@@ -1274,7 +1387,7 @@ var fromReport = (path) => {
   }
   let report;
   try {
-    report = JSON.parse(readFileSync11(path, "utf8"));
+    report = JSON.parse(readFileSync12(path, "utf8"));
   } catch (error) {
     throw new CounterError(
       COUNTER,
@@ -1298,14 +1411,14 @@ var fromReport = (path) => {
 };
 var reportPathFor = (cwd, params, command) => {
   const named = params.reportPath;
-  if (typeof named === "string" && named !== "") return { own: false, path: resolve12(cwd, named) };
+  if (typeof named === "string" && named !== "") return { own: false, path: resolve13(cwd, named) };
   if (!command.includes(PLACEHOLDER)) {
     throw new CounterError(
       COUNTER,
       `report: "${VITEST_JSON}" needs somewhere to put the report \u2014 write ${PLACEHOLDER} into the command (--outputFile=${PLACEHOLDER}) or give the entry a "reportPath"`
     );
   }
-  return { own: true, path: join9(mkdtempSync2(join9(tmpdir2(), "geonosis-report-")), "report.json") };
+  return { own: true, path: join10(mkdtempSync2(join10(tmpdir2(), "geonosis-report-")), "report.json") };
 };
 var testFailures = {
   id: COUNTER,
@@ -1354,8 +1467,74 @@ var testFailures = {
       run(command.replaceAll(PLACEHOLDER, path));
       return fromReport(path);
     } finally {
-      if (own) rmSync4(join9(path, ".."), { force: true, recursive: true });
+      if (own) rmSync4(join10(path, ".."), { force: true, recursive: true });
+    }
+  }
+};
+
+// src/counters/todos.ts
+import { existsSync as existsSync11, readdirSync as readdirSync5, readFileSync as readFileSync13 } from "fs";
+import { join as join11, resolve as resolve14 } from "path";
+var CODE_FILE2 = /\.(?:ts|tsx|js|jsx|mjs|cjs|mts|cts|vue|svelte|astro)$/;
+var SKIP4 = /^(?:node_modules|dist|coverage|\.[^.]|__fixtures__)/;
+var PLAN_FILE = /^(\d{3,})-[a-z\d][a-z\d.-]*\.md$/;
+var plansIn = (dir) => {
+  if (!existsSync11(dir)) return /* @__PURE__ */ new Set();
+  const found = /* @__PURE__ */ new Set();
+  for (const name of readdirSync5(dir)) {
+    const number = PLAN_FILE.exec(name)?.[1];
+    if (number !== void 0) found.add(String(Number(number)));
+  }
+  return found;
+};
+var countIn2 = (dir, marker, plans, depth = 12) => {
+  let entries;
+  try {
+    entries = readdirSync5(dir, { withFileTypes: true });
+  } catch {
+    return 0;
+  }
+  let found = 0;
+  for (const entry of entries) {
+    if (SKIP4.test(entry.name)) continue;
+    if (entry.isDirectory()) {
+      if (depth > 0) found += countIn2(join11(dir, entry.name), marker, plans, depth - 1);
+      continue;
     }
+    if (!CODE_FILE2.test(entry.name)) continue;
+    let text = "";
+    try {
+      text = readFileSync13(join11(dir, entry.name), "utf8");
+    } catch {
+      continue;
+    }
+    for (const match of text.matchAll(marker)) {
+      const cited = match[1];
+      if (cited === void 0 || !plans.has(String(Number(cited)))) found += 1;
+    }
+  }
+  return found;
+};
+var orphanTodos = {
+  id: "orphanTodos",
+  probe: {
+    expect: 2,
+    input: (dir) => plant(
+      dir,
+      "src/planted.ts",
+      "// TODO: no plan named at all\n// TODO(099): a plan nobody wrote\nexport const a = 1\n"
+    )
+  },
+  readingParams: ["markers"],
+  run: async ({ cwd, params }) => {
+    const markers = stringsParam(params, "markers", ["TODO", "FIXME"]);
+    const plans = plansIn(resolve14(cwd, stringParam("orphanTodos", params, "plans", "plans")));
+    const marker = new RegExp(
+      `\\b(?:${markers.map(escapeForRegex).join("|")})\\b(?:\\((\\d+)\\))?`,
+      "g"
+    );
+    const roots = stringsParam(params, "roots", ["."]);
+    return roots.reduce((sum, root) => sum + countIn2(resolve14(cwd, root), marker, plans), 0);
   }
 };
 
@@ -1394,8 +1573,8 @@ var typecheckErrors = {
 };
 
 // src/counters/walk.ts
-import { existsSync as existsSync10, readFileSync as readFileSync12 } from "fs";
-import { resolve as resolve13 } from "path";
+import { existsSync as existsSync12, readFileSync as readFileSync14 } from "fs";
+import { resolve as resolve15 } from "path";
 var DEFAULT_REPORT2 = ".geonosis/walk-report.json";
 var CLASSES = /* @__PURE__ */ new Set([
   "buy-box-above-fold",
@@ -1439,8 +1618,8 @@ var walkFindings = {
   },
   run: async ({ cwd, params }) => {
     const relative = stringParam("walkFindings", params, "report", DEFAULT_REPORT2);
-    const path = resolve13(cwd, relative);
-    if (!existsSync10(path)) {
+    const path = resolve15(cwd, relative);
+    if (!existsSync12(path)) {
       throw new CounterError(
         "walkFindings",
         `no walk report at ${relative} \u2014 run \`geonosis-walk\` before measuring it`
@@ -1448,7 +1627,7 @@ var walkFindings = {
     }
     let report;
     try {
-      report = JSON.parse(readFileSync12(path, "utf8"));
+      report = JSON.parse(readFileSync14(path, "utf8"));
     } catch (error) {
       throw new CounterError(
         "walkFindings",
@@ -1482,7 +1661,9 @@ var COUNTERS = [
   oxlintErrors,
   oxlintRule,
   oxlintWarnings,
+  orphanTodos,
   packagesWithoutTypecheck,
+  probelessRules,
   runtimeCodeShipped,
   sumOfCounts,
   testFailures,

package/dist/cli.js

@@ -7,7 +7,7 @@ import {
   runRatchet,
   versionOf,
   writeEnvelope
-} from "./chunk-ESN6ULZZ.js";
+} from "./chunk-H4PLCM5J.js";
 
 // src/cli.ts
 import process from "process";

package/dist/index.js

@@ -18,7 +18,7 @@ import {
   runRatchet,
   versionOf,
   writeEnvelope
-} from "./chunk-ESN6ULZZ.js";
+} from "./chunk-H4PLCM5J.js";
 export {
   CONFIG_FILE,
   COUNTERS,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@geonosis/ratchet",
-  "version": "1.4.0",
+  "version": "2.1.0",
   "types": "./dist/index.d.ts",
   "description": "Debt as a number that may only shrink — one ratchet, pluggable counters.",
   "keywords": [