@avi2dg/checks 0.56.0 → 0.57.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@avi2dg/checks",
-  "version": "0.56.0",
+  "version": "0.57.0",
   "description": "Deterministic checks shared across a set of TypeScript repositories",
   "author": {
     "name": "avi2d",
@@ -90,8 +90,7 @@
     "src/quality/browser/",
     "src/complexity/suppressions-ratchet.ts",
     "src/complexity/repetition.ts",
-    "src/complexity/unused.ts",
-    "src/complexity/exports.ts",
+    "src/complexity/graphwalk.ts",
     "src/complexity/knip.ts",
     "src/testing/quarantine-clock.ts",
     "src/docs/sentence-length.ts",
@@ -121,7 +120,6 @@
     "src/quality/presets/stylelint.ts",
     "src/quality/effect-scope.ts",
     "src/quality/jsonc-patch.ts",
-    "src/dependencies/imports.ts",
     "src/dependencies/kit-defaults.ts",
     "oxlintrc.json",
     "stryker.preset.js",
@@ -188,8 +186,7 @@
     "checks-css-size": "src/quality/css-size.ts",
     "checks-suppressions-ratchet": "src/complexity/suppressions-ratchet.ts",
     "checks-repetition": "src/complexity/repetition.ts",
-    "checks-unused": "src/complexity/unused.ts",
-    "checks-exports": "src/complexity/exports.ts",
+    "checks-graphwalk": "src/complexity/graphwalk.ts",
     "checks-quarantine-clock": "src/testing/quarantine-clock.ts",
     "checks-docs": "src/docs/docs.ts",
     "checks-copy": "src/docs/copy.ts",
@@ -201,7 +198,6 @@
     "checks-frontend-syntax": "src/quality/frontend-syntax.ts",
     "checks-no-plain-js": "src/quality/no-plain-js.ts",
     "checks-browser": "src/quality/browser/browser.ts",
-    "checks-imports": "src/dependencies/imports.ts",
     "checks-effect-scope": "src/quality/effect-scope.ts"
   },
   "scripts": {
@@ -214,6 +210,7 @@
     "test:fast": "bun scripts/test-fast.ts",
     "test:unit": "bun src/testing/test.ts --tier=unit",
     "test:e2e": "bun src/testing/test.ts --tier=e2e --parallel=4",
+    "test:live": "bun src/testing/test.ts --tier=live",
     "mutate": "bunx stryker run",
     "mutate:incremental": "bunx stryker run --incremental"
   },

package/src/complexity/graphwalk.ts

@@ -0,0 +1,374 @@
+#!/usr/bin/env bun
+import { BunServices } from "@effect/platform-bun";
+import { Console, Effect, FileSystem, Path, Schema } from "effect";
+import { LINTED_SOURCE, TYPESCRIPT_SOURCE, type TrackedContent } from "../core/gates.ts";
+import { checkoutFiles, collect, commitOf, git, pathsAt, rangeEnds, refArgs } from "../core/git.ts";
+import { PASSED, runExitMain, UNDECIDED, Usage, VIOLATED } from "../core/main.ts";
+import { knipReport } from "./knip.ts";
+
+const NAME = "graphwalk";
+const UNUSED = "unused";
+const EXPORTS = "exports";
+const IMPORTS = "imports";
+const WRITE = "--write";
+const USAGE = `usage: graphwalk.ts [<ref> | <base-ref> <head-ref> | ${WRITE}]`;
+
+const INCLUDED = ["--include", "files,exports,types"];
+const JUDGED = /[.]tsx?$|[.]astro$/;
+
+export const BASELINE_FILE = "exports-baseline.json";
+
+export const PROJECT_CONFIG = "dependency-cruiser.config.ts";
+
+export const OWN_CONFIGS = [
+  ".dependency-cruiser.json",
+  ".dependency-cruiser.js",
+  ".dependency-cruiser.cjs",
+  ".dependency-cruiser.mjs",
+  ".dependency-cruiser.ts",
+  ".dependency-cruiser.cts",
+  ".dependency-cruiser.mts",
+] as const;
+
+export const CRUISED = ["*.ts", "*.tsx", "*.mts", "*.cts"] as const;
+
+const KIT_DEFAULTS = "kit-defaults.ts";
+
+export type Status = "passed" | "violated" | "undecided";
+
+class GraphwalkError extends Schema.TaggedError<GraphwalkError>()("GraphwalkError", {
+  message: Schema.String,
+}) {}
+
+const UnusedSymbolSchema = Schema.Struct({ file: Schema.String, kind: Schema.Literals(["export", "type"]), name: Schema.String });
+
+export type UnusedSymbol = typeof UnusedSymbolSchema.Type;
+
+export type Baseline = readonly UnusedSymbol[];
+
+export type Drift = { readonly unlisted: readonly UnusedSymbol[]; readonly added: readonly UnusedSymbol[]; readonly stale: readonly UnusedSymbol[] };
+
+const Violation = Schema.Struct({ from: Schema.String, to: Schema.String, rule: Schema.Struct({ name: Schema.String, severity: Schema.String }) });
+
+export type Violation = typeof Violation.Type;
+
+const decodeKnipFiles = Schema.decodeUnknownEffect(
+  Schema.fromJsonString(Schema.Struct({ issues: Schema.Array(Schema.Struct({ files: Schema.optional(Schema.Array(Schema.Struct({ name: Schema.String }))) })) })),
+);
+
+const decodeKnipSymbols = Schema.decodeUnknownEffect(
+  Schema.fromJsonString(Schema.Struct({ issues: Schema.Array(Schema.Struct({ file: Schema.String, exports: Schema.optional(Schema.Array(Schema.Struct({ name: Schema.String }))), types: Schema.optional(Schema.Array(Schema.Struct({ name: Schema.String }))) })) })),
+);
+
+const decodeBaseline = Schema.decodeUnknownEffect(Schema.fromJsonString(Schema.Array(UnusedSymbolSchema)));
+
+const decodeCruise = Schema.decodeUnknownEffect(
+  Schema.fromJsonString(Schema.Struct({ summary: Schema.Struct({ violations: Schema.Array(Violation), error: Schema.Int, totalCruised: Schema.Int }) })),
+);
+
+const byPosition = (a: UnusedSymbol, b: UnusedSymbol): number => a.file.localeCompare(b.file) || a.kind.localeCompare(b.kind) || a.name.localeCompare(b.name);
+
+const keyOf = ({ file, kind, name }: UnusedSymbol): string => `${kind}\0${file}\0${name}`;
+
+function outside(symbols: readonly UnusedSymbol[], others: readonly UnusedSymbol[]): readonly UnusedSymbol[] {
+  const known = new Set(others.map(keyOf));
+  return symbols.filter((symbol) => !known.has(keyOf(symbol))).toSorted(byPosition);
+}
+
+const describe = (symbol: UnusedSymbol): string => `  ${symbol.file}: ${symbol.name} (${symbol.kind})`;
+
+export const filesOf = Effect.fn("filesOf")(function* (stdout: string) {
+  const { issues } = yield* decodeKnipFiles(stdout).pipe(
+    Effect.mapError((cause) => new GraphwalkError({ message: `knip's JSON report does not decode: ${cause.message}` })),
+  );
+  return issues
+    .flatMap(({ files = [] }) => files.map(({ name }) => name))
+    .filter((file) => JUDGED.test(file))
+    .toSorted();
+});
+
+export function unusedReport({ tracked, files }: { readonly tracked: number; readonly files: readonly string[] }): string {
+  if (files.length === 0) return `${UNUSED}: no unreferenced files among ${tracked} tracked .ts/.tsx/.astro file(s)`;
+  return [`${UNUSED}: ${files.length} unreferenced file(s):`, ...files.map((file) => `  ${file}`)].join("\n");
+}
+
+export const symbolsOf = Effect.fn("symbolsOf")(function* (stdout: string) {
+  const { issues } = yield* decodeKnipSymbols(stdout).pipe(
+    Effect.mapError((cause) => new GraphwalkError({ message: `knip's JSON report does not decode: ${cause.message}` })),
+  );
+  return issues
+    .flatMap(({ file, exports = [], types = [] }): readonly UnusedSymbol[] => [
+      ...exports.map(({ name }): UnusedSymbol => ({ file, kind: "export", name })),
+      ...types.map(({ name }): UnusedSymbol => ({ file, kind: "type", name })),
+    ])
+    .toSorted(byPosition);
+});
+
+export const baselineOf = Effect.fn("baselineOf")(function* (text: string, where: string) {
+  return yield* decodeBaseline(text).pipe(
+    Effect.mapError((cause) => new GraphwalkError({ message: `${where} does not decode: ${cause.message}` })),
+  );
+});
+
+export function driftOf({
+  reported,
+  base,
+  head,
+  unusedAtBase,
+}: {
+  readonly reported: Baseline;
+  readonly base: Baseline;
+  readonly head: Baseline;
+  readonly unusedAtBase: Baseline;
+}): Drift {
+  return {
+    unlisted: outside(reported, head),
+    added: outside(head, [...base, ...unusedAtBase]),
+    stale: outside(head, reported),
+  };
+}
+
+export function exportsReport(head: Baseline, { unlisted, added, stale }: Drift): string {
+  const sections = [
+    { symbols: unlisted, what: `unused export(s) not in ${BASELINE_FILE}:` },
+    { symbols: added, what: `${BASELINE_FILE} export(s) the range adds that its base did not leave unused, remove the export instead:` },
+    { symbols: stale, what: `${BASELINE_FILE} export(s) no longer reported, remove them:` },
+  ].filter(({ symbols }) => symbols.length > 0);
+  if (sections.length > 0) {
+    return sections.flatMap(({ symbols, what }) => [`${EXPORTS}: ${symbols.length} ${what}`, ...symbols.map(describe)]).join("\n");
+  }
+  return head.length === 0
+    ? `${EXPORTS}: no unused exports or types`
+    : `${EXPORTS}: ${head.length} unused export(s) in ${BASELINE_FILE}, and no new ones`;
+}
+
+export function describeViolation({ from, to, rule }: Violation): string {
+  return from === to ? `  ${rule.severity} ${rule.name}: ${from}` : `  ${rule.severity} ${rule.name}: ${from} → ${to}`;
+}
+
+const unconfiguredLine = (section: string): string =>
+  `${section}: no knip configuration names entry files, so add a knip.config.ts calling defineConfig from @avi2dg/checks/knip`;
+
+const trackedIn = Effect.fn("trackedIn")(function* (root: string, source: TrackedContent) {
+  return (yield* git(["ls-files", "--", ...source.pathspecs], root))
+    .split("\n")
+    .map((line) => line.trim())
+    .filter((line) => line !== "");
+});
+
+const baselinePath = Effect.fn("baselinePath")(function* (root: string) {
+  return (yield* Path.Path).join(root, BASELINE_FILE);
+});
+
+const baselineInTree = Effect.fn("baselineInTree")(function* (root: string) {
+  const fs = yield* FileSystem.FileSystem;
+  const at = yield* baselinePath(root);
+  if (!(yield* fs.exists(at))) return [] satisfies Baseline;
+  return yield* fs.readFileString(at).pipe(Effect.flatMap((text) => baselineOf(text, BASELINE_FILE)));
+});
+
+const baselineAt = Effect.fn("baselineAt")(function* (treeish: string, root: string) {
+  const blob = (yield* git(["ls-tree", "--object-only", treeish, "--", BASELINE_FILE], root)).trim();
+  if (blob === "") return [] satisfies Baseline;
+  return yield* baselineOf(yield* git(["cat-file", "blob", blob], root), `${BASELINE_FILE} at ${treeish}`);
+});
+
+// Knip loads the configuration's imports, such as the kit's knip builder, from a node_modules the checkout lacks.
+const unusedAt = Effect.fn("unusedAt")(
+  function* (rev: string, root: string) {
+    const files = yield* pathsAt(rev, [], root);
+    if (files.length === 0) return [] satisfies Baseline;
+    const fs = yield* FileSystem.FileSystem;
+    const path = yield* Path.Path;
+    const tree = yield* checkoutFiles(rev, files, yield* fs.makeTempDirectoryScoped({ prefix: "checks-graphwalk-" }), root);
+    const modules = path.join(root, "node_modules");
+    if (yield* fs.exists(modules)) yield* fs.symlink(modules, path.join(tree, "node_modules"));
+    const reported = yield* knipReport(tree, INCLUDED).pipe(
+      Effect.mapError((cause) => new GraphwalkError({ message: `at ${rev}: ${cause.message}` })),
+    );
+    return reported.kind === "unconfigured" ? [] : yield* symbolsOf(reported.stdout);
+  },
+  Effect.scoped,
+);
+
+// Knip scans the checked-out tree, and a pull request's merge checkout holds the base branch tip beside the range head.
+const judgedBase = Effect.fn("judgedBase")(function* (first: string, second: string | undefined, root: string) {
+  const { base } = yield* rangeEnds(first, second, root);
+  if (second === undefined) return base;
+  const head = yield* commitOf(second, root);
+  const parents = (yield* git(["rev-parse", "HEAD^@"], root)).split("\n").filter((line) => line !== "");
+  const [other, ...rest] = parents.filter((parent) => parent !== head);
+  return parents.includes(head) && other !== undefined && rest.length === 0 ? other : base;
+});
+
+const configOf = Effect.fn("configOf")(function* (root: string) {
+  const fs = yield* FileSystem.FileSystem;
+  const path = yield* Path.Path;
+  for (const name of [PROJECT_CONFIG, ...OWN_CONFIGS]) {
+    if (yield* fs.exists(path.join(root, name))) return { file: name, shown: name };
+  }
+  return { file: path.join(import.meta.dir, "..", "dependencies", KIT_DEFAULTS), shown: "the kit's defaults" };
+});
+
+const depcruise = Effect.fn("depcruise")(function* () {
+  const path = yield* Path.Path;
+  const main = yield* Effect.try({
+    try: () => new URL("../../bin/dependency-cruiser.mjs", import.meta.resolve("dependency-cruiser")),
+    catch: () => new GraphwalkError({ message: "cannot resolve dependency-cruiser, a peer dependency of the kit" }),
+  });
+  return yield* path.fromFileUrl(main);
+});
+
+const trackedInTree = Effect.fn("trackedInTree")(function* (root: string) {
+  const fs = yield* FileSystem.FileSystem;
+  const path = yield* Path.Path;
+  const listed = yield* git(["ls-files", "-z", "--", ...CRUISED], root);
+  return yield* Effect.filter(listed.split("\0").filter(Boolean), (file) => fs.exists(path.join(root, file)), { concurrency: "unbounded" });
+});
+
+const runSection = Effect.fn("runSection")(function* (
+  section: string,
+  body: Effect.Effect<Status, { readonly message: string }, BunServices.BunServices>,
+) {
+  return yield* body.pipe(
+    Effect.catch((cause) => Console.error(`${section}: ${cause.message}`).pipe(Effect.as<Status>("undecided"))),
+  );
+});
+
+const unusedSection = (tracked: number, stdout: string) =>
+  runSection(
+    UNUSED,
+    Effect.gen(function* () {
+      const files = yield* filesOf(stdout);
+      yield* Console.log(unusedReport({ tracked, files }));
+      return files.length === 0 ? "passed" : "violated";
+    }),
+  );
+
+const exportsSection = (root: string, stdout: string, first: string, second: string | undefined) =>
+  runSection(
+    EXPORTS,
+    Effect.gen(function* () {
+      const head = yield* baselineInTree(root);
+      const reported = yield* symbolsOf(stdout);
+      const baseRev = yield* judgedBase(first, second, root);
+      const base = yield* baselineAt(baseRev, root);
+      const unusedAtBase = outside(head, base).length === 0 ? [] : yield* unusedAt(baseRev, root);
+      const drift = driftOf({ reported, base, head, unusedAtBase });
+      yield* Console.log(exportsReport(head, drift));
+      return drift.unlisted.length === 0 && drift.added.length === 0 && drift.stale.length === 0 ? "passed" : "violated";
+    }),
+  );
+
+const importsSection = (root: string) =>
+  runSection(
+    IMPORTS,
+    Effect.gen(function* () {
+      const files = yield* trackedInTree(root);
+      if (files.length === 0) return yield* new GraphwalkError({ message: "no tracked TypeScript to cruise" });
+      const config = yield* configOf(root);
+      const run = yield* collect(process.execPath, [yield* depcruise(), "--config", config.file, "--output-type", "json", ...files], root).pipe(
+        Effect.mapError((cause) => new GraphwalkError({ message: `cannot run dependency-cruiser: ${cause.message}` })),
+      );
+      const { summary } = yield* decodeCruise(run.stdout).pipe(
+        Effect.mapError(
+          () => new GraphwalkError({ message: `dependency-cruiser exits ${run.exitCode} with no report: ${(run.stdout + run.stderr).trim()}` }),
+        ),
+      );
+      const cruised = `${summary.totalCruised} module(s) cruised against ${config.shown}`;
+      if (summary.violations.length === 0) {
+        yield* Console.log(`${IMPORTS}: ${cruised}, no violation`);
+        return "passed";
+      }
+      yield* Console.error(
+        [`${IMPORTS}: ${summary.violations.length} violation(s) in ${cruised}`, ...summary.violations.map(describeViolation)].join("\n"),
+      );
+      return summary.error === 0 ? "passed" : "violated";
+    }),
+  );
+
+function exitOf(statuses: readonly Status[]): number {
+  if (statuses.includes("violated")) return VIOLATED;
+  if (statuses.includes("undecided")) return UNDECIDED;
+  return PASSED;
+}
+
+const seed = Effect.fn("seed")(function* (root: string, tracked: number) {
+  if (tracked === 0) return yield* new GraphwalkError({ message: "no tracked TypeScript source to scan" });
+  const reported = yield* knipReport(root, INCLUDED).pipe(Effect.mapError((cause) => new GraphwalkError({ message: cause.message })));
+  if (reported.kind === "unconfigured") {
+    yield* Console.log(unconfiguredLine(EXPORTS));
+    return VIOLATED;
+  }
+  const symbols = yield* symbolsOf(reported.stdout);
+  yield* (yield* FileSystem.FileSystem).writeFileString(yield* baselinePath(root), `${JSON.stringify(symbols, null, 2)}\n`);
+  yield* Console.log(`${EXPORTS}: wrote ${symbols.length} unused export(s) to ${BASELINE_FILE}`);
+  return PASSED;
+});
+
+const lintOnlyGate = Effect.fn("lintOnlyGate")(function* (root: string, args: readonly string[]) {
+  if ((yield* trackedInTree(root)).length === 0) return yield* new GraphwalkError({ message: "no tracked TypeScript or Astro source to scan" });
+  if (args.length > 0) yield* refArgs(args, USAGE);
+  return exitOf([yield* importsSection(root)]);
+});
+
+const knipFailedGate = Effect.fn("knipFailedGate")(function* (root: string, message: string, hasTypescript: boolean) {
+  yield* Console.error(`${UNUSED}: ${message}`);
+  if (!hasTypescript) {
+    if ((yield* trackedInTree(root)).length === 0) return UNDECIDED;
+    return exitOf(["undecided", yield* importsSection(root)]);
+  }
+  yield* Console.error(`${EXPORTS}: ${message}`);
+  return exitOf(["undecided", "undecided", yield* importsSection(root)]);
+});
+
+const unconfiguredGate = Effect.fn("unconfiguredGate")(function* (root: string, hasTypescript: boolean) {
+  yield* Console.log(unconfiguredLine(UNUSED));
+  yield* Console.log(unconfiguredLine(EXPORTS));
+  const cruised = hasTypescript || (yield* trackedInTree(root)).length > 0 ? yield* importsSection(root) : "passed";
+  return exitOf(["violated", "violated", cruised]);
+});
+
+const judgedGate = Effect.fn("judgedGate")(function* (root: string, linted: number, typescript: number, stdout: string, first: string, second: string | undefined) {
+  const unlisted = yield* unusedSection(linted, stdout);
+  if (typescript === 0) {
+    if ((yield* trackedInTree(root)).length === 0) return exitOf([unlisted]);
+    return exitOf([unlisted, yield* importsSection(root)]);
+  }
+  const drifted = yield* exportsSection(root, stdout, first, second);
+  return exitOf([unlisted, drifted, yield* importsSection(root)]);
+});
+
+const gate = Effect.gen(function* () {
+  const args = process.argv.slice(2);
+  const root = (yield* git(["rev-parse", "--show-toplevel"])).trim();
+  if (args.length === 1 && args[0] === WRITE) {
+    const tracked = yield* trackedIn(root, TYPESCRIPT_SOURCE);
+    return yield* seed(root, tracked.length).pipe(
+      Effect.catch((cause: { readonly message: string }) => Console.error(`${EXPORTS}: ${cause.message}`).pipe(Effect.as(UNDECIDED))),
+    );
+  }
+  const linted = yield* trackedIn(root, LINTED_SOURCE);
+  if (linted.length === 0) return yield* lintOnlyGate(root, args);
+  const { first, second } = args.length === 0 ? { first: "HEAD", second: undefined } : yield* refArgs(args, USAGE);
+  const typescript = yield* trackedIn(root, TYPESCRIPT_SOURCE);
+  const knipOutcome = yield* knipReport(root, INCLUDED).pipe(
+    Effect.mapError((cause) => new GraphwalkError({ message: cause.message })),
+    Effect.map((reported) => ({ failed: false as const, reported })),
+    Effect.catch((cause: { readonly message: string }) => Effect.succeed({ failed: true as const, message: cause.message })),
+  );
+  if (knipOutcome.failed) return yield* knipFailedGate(root, knipOutcome.message, typescript.length > 0);
+  const reported = knipOutcome.reported;
+  if (reported.kind === "unconfigured") return yield* unconfiguredGate(root, typescript.length > 0);
+  return yield* judgedGate(root, linted.length, typescript.length, reported.stdout, first, second);
+}).pipe(
+  Effect.catch((cause: { readonly message: string }) =>
+    (cause instanceof Usage ? Console.error(`${NAME}: ${cause.message}`) : Console.error(`${UNUSED}: ${cause.message}`)).pipe(
+      Effect.as(UNDECIDED),
+    ),
+  ),
+);
+
+if (import.meta.main) {
+  runExitMain(gate);
+}

package/src/complexity/knip.ts

@@ -1,6 +1,5 @@
-import { Console, Effect, FileSystem, Path, Schema } from "effect";
-import type { TrackedContent } from "../core/gates.ts";
-import { collect, git } from "../core/git.ts";
+import { Effect, FileSystem, Path, Schema } from "effect";
+import { collect } from "../core/git.ts";
 
 class KnipError extends Schema.TaggedError<KnipError>()("KnipError", {
   message: Schema.String,
@@ -53,17 +52,3 @@ export const knipReport = Effect.fn("knipReport")(function* (root: string, args:
   }
   return { kind: "reported", stdout: run.stdout } as const;
 });
-
-export const scanTree = Effect.fn("scanTree")(function* (name: string, args: readonly string[], source: TrackedContent) {
-  const root = (yield* git(["rev-parse", "--show-toplevel"])).trim();
-  const tracked = (yield* git(["ls-files", "--", ...source.pathspecs], root))
-    .split("\n")
-    .map((line) => line.trim())
-    .filter((line) => line !== "");
-  if (tracked.length === 0) return yield* new KnipError({ message: `no tracked ${source.content} to scan` });
-  const reported = yield* knipReport(root, args);
-  if (reported.kind === "unconfigured") {
-    yield* Console.log(`${name}: no knip configuration names entry files, so add a knip.config.ts calling defineConfig from @avi2dg/checks/knip`);
-  }
-  return { root, tracked: tracked.length, reported };
-});

package/src/complexity/repetition.ts

@@ -1,7 +1,8 @@
 #!/usr/bin/env bun
 import { Console, Effect, FileSystem, Path, Schema } from "effect";
-import { changedPaths, checkoutFiles, collect, git, pathsAt, rangeFromArgs } from "../core/git.ts";
-import { runMain } from "../core/main.ts";
+import { changedPaths, checkoutFiles, collect, commitOf, git, pathsAt, rangeFromArgs } from "../core/git.ts";
+import { WHOLE_TREE } from "../core/gates.ts";
+import { Usage, runMain } from "../core/main.ts";
 
 export type Fragment = {
   readonly file: string;
@@ -29,7 +30,7 @@ class JscpdUnreadable extends Schema.TaggedError<JscpdUnreadable>()("JscpdUnread
 }) {}
 
 const NAME = "repetition";
-const USAGE = "usage: repetition.ts <ref> | <base-ref> <head-ref>";
+const USAGE = "usage: repetition.ts <ref> | <base-ref> <head-ref> | --whole-tree <head-ref>";
 const MIN_TOKENS = 50;
 const MIN_LINES = 5;
 const MEASURE = `at ${MIN_TOKENS} tokens and ${MIN_LINES} lines`;
@@ -164,31 +165,65 @@ const runHold = Effect.fn("runHold")(function* (root: string, config: string, ba
   return heldOf(sources, rises, after) satisfies Held;
 });
 
+const runWholeTree = Effect.fn("runWholeTree")(function* (root: string, config: string, head: string) {
+  const { sources, clones } = yield* scan(root, head, config, []);
+  const after = repeatedLines(clones);
+  const rises = risesOf([...after.keys()], new Map(), after, new Map(), clones);
+  return heldOf(sources, rises, after) satisfies Held;
+});
+
+function cloneLines(clones: readonly Clone[]): readonly string[] {
+  return clones.map(([own, other]) => `    ${own.file}:${own.start}-${own.end} repeats ${other.file}:${other.start}-${other.end}`);
+}
+
 export function describe({ file, before, after, clones }: Rise): readonly string[] {
-  return [
-    `  ${file}: ${after} repeated line(s), up from ${before}`,
-    ...clones.map(([own, other]) => `    ${own.file}:${own.start}-${own.end} repeats ${other.file}:${other.start}-${other.end}`),
-  ];
+  return [`  ${file}: ${after} repeated line(s), up from ${before}`, ...cloneLines(clones)];
+}
+
+function wholeTreeRise({ file, after, clones }: Rise): readonly string[] {
+  return [`  ${file}: ${after} repeated line(s)`, ...cloneLines(clones)];
 }
 
+const noticeOf = (advisory: Held["advisory"]): readonly string[] =>
+  advisory.size === 0
+    ? []
+    : [
+        `${NAME}: advisory, ${advisory.size} file(s) repeat lines the hold does not fail:`,
+        ...[...advisory].map(([file, lines]) => `  ${file}: ${lines} repeated line(s)`),
+      ];
+
 export function report({ measured, rises, advisory }: Held): string {
   const verdict =
     rises.length === 0
       ? [`${NAME}: ${measured} file(s) ${CONFIG} holds repeat no more lines than where the range starts, ${MEASURE}`]
       : [`${NAME}: ${rises.length} file(s) ${CONFIG} holds repeat more lines than where the range starts, ${MEASURE}:`, ...rises.flatMap(describe)];
-  const notice =
-    advisory.size === 0
-      ? []
-      : [
-          `${NAME}: advisory, ${advisory.size} file(s) repeat lines the hold does not fail:`,
-          ...[...advisory].map(([file, lines]) => `  ${file}: ${lines} repeated line(s)`),
-        ];
-  return [...verdict, ...notice].join("\n");
+  return [...verdict, ...noticeOf(advisory)].join("\n");
+}
+
+export function reportWholeTree({ measured, rises }: Held): string {
+  const verdict =
+    rises.length === 0
+      ? [`${NAME}: ${measured} file(s) ${CONFIG} holds repeat no lines at the head, ${MEASURE}`]
+      : [`${NAME}: ${rises.length} file(s) ${CONFIG} holds repeat lines at the head, ${MEASURE}:`, ...rises.flatMap(wholeTreeRise)];
+  return verdict.join("\n");
 }
 
 const hold = Effect.gen(function* () {
   const root = (yield* git(["rev-parse", "--show-toplevel"])).trim();
-  const { base, head } = yield* rangeFromArgs(process.argv.slice(2), USAGE, root);
+  const args = process.argv.slice(2);
+  if (args[0] === WHOLE_TREE) {
+    const headArg = args[1];
+    if (args.length !== 2 || headArg === undefined) return yield* new Usage({ message: USAGE });
+    const wholeHead = yield* commitOf(headArg);
+    if ((yield* pathsAt(wholeHead, [`:(literal)${CONFIG}`], root)).length === 0) {
+      yield* Console.log(`${NAME}: the head holds no ${CONFIG}, so no file is measured`);
+      return true;
+    }
+    const whole = yield* runWholeTree(root, yield* git(["show", `${wholeHead}:${CONFIG}`], root), wholeHead);
+    yield* Console.log(reportWholeTree(whole));
+    return whole.rises.length === 0;
+  }
+  const { base, head } = yield* rangeFromArgs(args, USAGE, root);
   if ((yield* pathsAt(head, [`:(literal)${CONFIG}`], root)).length === 0) {
     yield* Console.log(`${NAME}: the head holds no ${CONFIG}, so no file is measured`);
     return true;

package/src/complexity/suppressions-ratchet.ts

@@ -1,7 +1,8 @@
 #!/usr/bin/env bun
 import { Console, Effect, Schema } from "effect";
-import { git, commitOf, parentOrEmptyTree, refArgs } from "../core/git.ts";
-import { runMain } from "../core/main.ts";
+import { git, commitOf, emptyTree, parentOrEmptyTree, refArgs } from "../core/git.ts";
+import { WHOLE_TREE } from "../core/gates.ts";
+import { Usage, runMain } from "../core/main.ts";
 
 export const SUPPRESSIONS = ["oxlint-suppressions.json", "stylelint-suppressions.json"] as const;
 
@@ -23,7 +24,7 @@ export class SuppressionsError extends Schema.TaggedError<SuppressionsError>()("
   message: Schema.String,
 }) {}
 
-const USAGE = "usage: suppressions-ratchet.ts <ref> | <base-ref> <head-ref>";
+const USAGE = "usage: suppressions-ratchet.ts <ref> | <base-ref> <head-ref> | --whole-tree <head-ref>";
 
 const parseJson = Schema.decodeUnknownEffect(Schema.fromJsonString(Schema.Unknown));
 const decodeObject = Schema.decodeUnknownEffect(Schema.Record(Schema.String, Schema.Unknown));
@@ -124,11 +125,19 @@ export const runTip = Effect.fn("runTip")(function* (tip: string) {
   return yield* compareAt(yield* parentOrEmptyTree(tipCommit), tipCommit);
 });
 
+export const runWholeTree = Effect.fn("runWholeTree")(function* (head: string) {
+  return yield* compareAt(yield* emptyTree(), yield* commitOf(head));
+});
+
 const ratchet = Effect.gen(function* () {
   const { first, second } = yield* refArgs(process.argv.slice(2), USAGE);
-
+  if (first === WHOLE_TREE) {
+    if (second === undefined) return yield* new Usage({ message: USAGE });
+    const whole = yield* runWholeTree(second);
+    yield* Console.log(report(whole));
+    return whole.rises.length === 0;
+  }
   const result = second !== undefined ? yield* runRange(first, second) : yield* runTip(first);
-
   yield* Console.log(report(result));
   return result.rises.length === 0;
 });

package/src/core/gates.ts

@@ -26,6 +26,7 @@ export type KitGate = {
   readonly args?: readonly string[];
   readonly env?: Readonly<Record<string, string>>;
   readonly appliesTo: typeof EVERY_REPOSITORY | TrackedContent;
+  readonly night?: true;
 };
 
 export const ENTRY_POINT: Program = { bin: "checks-lint", script: "core/lint.ts" };
@@ -48,8 +49,10 @@ const STYLESHEET: TrackedContent = { pathspecs: ["*.css"], content: "a styleshee
 
 const COPY_DECLARATION: TrackedContent = { pathspecs: ["copy.json"], content: "a copy declaration" };
 
+export const WHOLE_TREE = "--whole-tree";
+
 export const KIT_GATES = [
-  { bin: "checks-lint-coverage", vector: "quality", file: "lint-coverage.sh", reads: "tree", appliesTo: LINTED_SOURCE },
+  { bin: "checks-lint-coverage", vector: "quality", file: "lint-coverage.sh", reads: "tree", appliesTo: LINTED_SOURCE, night: true },
   { bin: "checks-test-layout", vector: "testing", file: "test-layout.ts", reads: "tree", appliesTo: TYPESCRIPT_SOURCE },
   { bin: "checks-commit-identity", vector: "delivery", file: "commit-identity.ts", reads: "range", appliesTo: EVERY_REPOSITORY },
   { bin: "checks-comment-gate", vector: "quality", file: "comment-gate.ts", reads: "range", appliesTo: EVERY_REPOSITORY },
@@ -57,16 +60,14 @@ export const KIT_GATES = [
   { bin: "checks-frontend-syntax", vector: "quality", file: "frontend-syntax.ts", reads: "tree", appliesTo: FRONTEND_SYNTAX_DECLARATION },
   { bin: "checks-css-size", vector: "quality", file: "css-size.ts", reads: "tree", appliesTo: STYLESHEET },
   { bin: "checks-no-plain-js", vector: "quality", file: "no-plain-js.ts", reads: "tree", appliesTo: TYPESCRIPT_SOURCE },
-  { bin: "checks-suppressions-ratchet", vector: "complexity", file: "suppressions-ratchet.ts", reads: "range", appliesTo: EVERY_REPOSITORY },
+  { bin: "checks-suppressions-ratchet", vector: "complexity", file: "suppressions-ratchet.ts", reads: "range", appliesTo: EVERY_REPOSITORY, night: true },
   { bin: "checks-ci-wiring", vector: "delivery", file: "ci-wiring.ts", reads: "tree", appliesTo: EVERY_REPOSITORY },
   { bin: "checks-secrets", vector: "delivery", file: "secrets.ts", reads: "range", appliesTo: EVERY_REPOSITORY },
   { bin: "checks-docs", vector: "docs", file: "docs.ts", reads: "range", alsoReads: "every agent file at the head commit", appliesTo: EVERY_REPOSITORY },
   { bin: "checks-copy", vector: "docs", file: "copy.ts", reads: "tree", appliesTo: COPY_DECLARATION },
-  { bin: "checks-repetition", vector: "complexity", file: "repetition.ts", reads: "range", appliesTo: TYPESCRIPT_SOURCE },
-  { bin: "checks-unused", vector: "complexity", file: "unused.ts", reads: "tree", appliesTo: LINTED_SOURCE },
-  { bin: "checks-exports", vector: "complexity", file: "exports.ts", reads: "range", appliesTo: TYPESCRIPT_SOURCE },
-  { bin: "checks-quarantine-clock", vector: "testing", file: "quarantine-clock.ts", reads: "range", appliesTo: EVERY_REPOSITORY },
-  { bin: "checks-imports", vector: "dependencies", file: "imports.ts", reads: "tree", appliesTo: TYPESCRIPT_SOURCE },
+  { bin: "checks-repetition", vector: "complexity", file: "repetition.ts", reads: "range", appliesTo: TYPESCRIPT_SOURCE, night: true },
+  { bin: "checks-graphwalk", vector: "complexity", file: "graphwalk.ts", reads: "range", appliesTo: LINTED_SOURCE },
+  { bin: "checks-quarantine-clock", vector: "testing", file: "quarantine-clock.ts", reads: "range", appliesTo: EVERY_REPOSITORY, night: true },
   {
     bin: "checks-advisories",
     vector: "dependencies",
@@ -74,5 +75,9 @@ export const KIT_GATES = [
     reads: "range",
     env: { [ADVISORIES_DEFER_SCAN]: "1" },
     appliesTo: BUN_LOCKFILE,
-  },
+  }
 ] as const satisfies readonly KitGate[];
+
+export const NIGHT_GATES: readonly KitGate[] = KIT_GATES.filter((gate) => "night" in gate);
+
+export const PR_GATES: readonly KitGate[] = KIT_GATES.filter((gate) => !("night" in gate));

package/src/core/git.ts

@@ -168,7 +168,9 @@ export const changedLines = Effect.fn("changedLines")(function* (
   return parseAddedLines(diff);
 });
 
-const emptyTree = (cwd?: string) => git(["hash-object", "-t", "tree", "/dev/null"], cwd).pipe(Effect.map((sha) => sha.trim()));
+export const emptyTree = Effect.fn("emptyTree")(function* (cwd?: string) {
+  return (yield* git(["hash-object", "-t", "tree", "/dev/null"], cwd)).trim();
+});
 
 export const pathsAt = Effect.fn("pathsAt")(function* (rev: string, pathspecs: readonly string[], cwd?: string) {
   const listed = yield* git(["diff", "--name-only", "-z", "--no-renames", yield* emptyTree(cwd), rev, "--", ...pathspecs], cwd);