@avi2dg/checks 0.9.0 → 0.11.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@avi2dg/checks",
-  "version": "0.9.0",
+  "version": "0.11.0",
   "description": "Deterministic checks shared across the captain's TypeScript repos",
   "license": "MIT",
   "repository": {
@@ -21,6 +21,9 @@
     "scripts/gates.ts",
     "scripts/lint.ts",
     "scripts/test-layout.ts",
+    "scripts/test.ts",
+    "scripts/test-report.ts",
+    "scripts/flake.ts",
     "scripts/commit-identity.ts",
     "scripts/mutation-compare.ts",
     "scripts/ci-wiring.ts",
@@ -29,6 +32,11 @@
     "scripts/comment-gate.ts",
     "scripts/suppressions-ratchet.ts",
     "scripts/backtest.ts",
+    "scripts/quality-file.ts",
+    "scripts/quality.ts",
+    "presets/effect.oxlint.json",
+    "presets/effect.language-service.json",
+    "quality.schema.json",
     "oxlintrc.json",
     "stryker.preset.js",
     "tsconfig.effect.json",
@@ -41,6 +49,8 @@
     "./scripts/lint-coverage.sh": "./scripts/lint-coverage.sh",
     "./scripts/lint.ts": "./scripts/lint.ts",
     "./scripts/test-layout.ts": "./scripts/test-layout.ts",
+    "./scripts/test.ts": "./scripts/test.ts",
+    "./scripts/flake.ts": "./scripts/flake.ts",
     "./scripts/commit-identity.ts": "./scripts/commit-identity.ts",
     "./scripts/mutation-compare.ts": "./scripts/mutation-compare.ts",
     "./scripts/ci-wiring.ts": "./scripts/ci-wiring.ts",
@@ -49,6 +59,11 @@
     "./scripts/comment-gate.ts": "./scripts/comment-gate.ts",
     "./scripts/suppressions-ratchet.ts": "./scripts/suppressions-ratchet.ts",
     "./scripts/backtest.ts": "./scripts/backtest.ts",
+    "./scripts/quality-file.ts": "./scripts/quality-file.ts",
+    "./scripts/quality.ts": "./scripts/quality.ts",
+    "./presets/effect.oxlint.json": "./presets/effect.oxlint.json",
+    "./presets/effect.language-service.json": "./presets/effect.language-service.json",
+    "./quality.schema.json": "./quality.schema.json",
     "./oxlintrc.json": "./oxlintrc.json",
     "./stryker.preset.js": "./stryker.preset.js",
     "./tsconfig.effect.json": "./tsconfig.effect.json",
@@ -58,28 +73,21 @@
     "checks-lint": "scripts/lint.ts",
     "checks-lint-coverage": "scripts/lint-coverage.sh",
     "checks-test-layout": "scripts/test-layout.ts",
+    "checks-test": "scripts/test.ts",
+    "checks-flake": "scripts/flake.ts",
     "checks-commit-identity": "scripts/commit-identity.ts",
     "checks-mutation-compare": "scripts/mutation-compare.ts",
     "checks-ci-wiring": "scripts/ci-wiring.ts",
     "checks-comment-gate": "scripts/comment-gate.ts",
     "checks-suppressions-ratchet": "scripts/suppressions-ratchet.ts",
-    "checks-backtest": "scripts/backtest.ts"
+    "checks-backtest": "scripts/backtest.ts",
+    "checks-quality": "scripts/quality.ts"
   },
   "scripts": {
-    "build": "bun build effect-channel/index.ts --outdir dist --target node --format esm",
+    "build": "bun build effect-channel/index.ts --outdir dist --target node --format esm && bun scripts/quality-schema.ts",
     "lint": "oxlint --type-aware && bun scripts/lint.ts && depcruise --config .dependency-cruiser.cjs .",
     "typecheck": "tsc --noEmit && effect-tsgo diagnostics --project tsconfig.json --format text --strict",
-    "test": "bun test --randomize"
-  },
-  "ciWiring": {
-    "gates": [
-      "bun run build",
-      "git diff --exit-code dist/",
-      "bun run lint",
-      "bun run typecheck",
-      "bun run test",
-      "./node_modules/.bin/commitlint"
-    ]
+    "test": "bun scripts/test.ts"
   },
   "peerDependencies": {
     "@swc/core": "1.16.2",
@@ -94,6 +102,7 @@
     "@oxlint/plugins": "1.83.0",
     "@swc/core": "1.16.2",
     "@types/bun": "^1.3.0",
+    "ajv": "8.20.0",
     "dependency-cruiser": "18.4.0",
     "effect": "4.0.0-rc.115",
     "oxlint": "1.83.0",

package/presets/effect.language-service.json

@@ -0,0 +1,8 @@
+{
+  "diagnosticSeverity": {
+    "nodeBuiltinImport": "error",
+    "asyncFunction": "error",
+    "newPromise": "error",
+    "extendsNativeError": "error"
+  }
+}

package/presets/effect.oxlint.json

@@ -0,0 +1,11 @@
+{
+  "plugins": ["node", "promise", "unicorn"],
+  "rules": {
+    "node/no-sync": "error",
+    "oxc/no-async-await": "error",
+    "promise/avoid-new": "error",
+    "unicorn/no-process-exit": "error",
+    "effect-channel/no-throw": "error",
+    "effect-channel/no-try-catch": "error"
+  }
+}

package/quality.schema.json

@@ -0,0 +1,197 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "type": "object",
+  "properties": {
+    "$schema": {
+      "type": "string"
+    },
+    "defaultBranch": {
+      "type": "string",
+      "minLength": 1,
+      "description": "The branch pull requests merge into; main when absent"
+    },
+    "gates": {
+      "type": "object",
+      "properties": {
+        "ci": {
+          "type": "array",
+          "prefixItems": [
+            {
+              "$ref": "#/$defs/Command"
+            }
+          ],
+          "minItems": 1,
+          "items": {
+            "$ref": "#/$defs/Command"
+          },
+          "description": "The commands CI runs on every pull request to the default branch, each one plain command"
+        },
+        "scheduled": {
+          "type": "array",
+          "items": {
+            "$ref": "#/$defs/Command"
+          },
+          "description": "The commands a cron-scheduled workflow runs"
+        },
+        "lint": {
+          "type": "array",
+          "items": {
+            "type": "string",
+            "enum": [
+              "checks-lint-coverage",
+              "checks-test-layout",
+              "checks-commit-identity",
+              "checks-comment-gate",
+              "checks-suppressions-ratchet",
+              "checks-ci-wiring",
+              "checks-quality"
+            ]
+          },
+          "allOf": [
+            {
+              "contains": {
+                "const": "checks-commit-identity"
+              }
+            },
+            {
+              "contains": {
+                "const": "checks-comment-gate"
+              }
+            },
+            {
+              "contains": {
+                "const": "checks-suppressions-ratchet"
+              }
+            },
+            {
+              "contains": {
+                "const": "checks-ci-wiring"
+              }
+            }
+          ]
+        }
+      },
+      "additionalProperties": false
+    },
+    "commitIdentity": {
+      "type": "object",
+      "properties": {
+        "authors": {
+          "type": "array",
+          "prefixItems": [
+            {
+              "$ref": "#/$defs/Identity"
+            }
+          ],
+          "minItems": 1,
+          "items": {
+            "$ref": "#/$defs/Identity"
+          },
+          "description": "The identities allowed to author and commit, in place of the kit's default owner"
+        }
+      },
+      "required": [
+        "authors"
+      ],
+      "additionalProperties": false
+    },
+    "sources": {
+      "type": "object",
+      "properties": {
+        "production": {
+          "type": "array",
+          "items": {
+            "$ref": "#/$defs/PathGlob"
+          },
+          "description": "The source the repository ships, as against tests and tooling"
+        },
+        "effect": {
+          "type": "object",
+          "properties": {
+            "paths": {
+              "type": "array",
+              "prefixItems": [
+                {
+                  "$ref": "#/$defs/PathGlob"
+                }
+              ],
+              "minItems": 1,
+              "items": {
+                "$ref": "#/$defs/PathGlob"
+              },
+              "description": "Where source is written in Effect, held to the Effect rules of oxlint and the language service"
+            },
+            "exempt": {
+              "type": "array",
+              "items": {
+                "$ref": "#/$defs/PathGlob"
+              },
+              "description": "Files under paths the Effect rules pass over"
+            }
+          },
+          "required": [
+            "paths"
+          ],
+          "additionalProperties": false
+        }
+      },
+      "additionalProperties": false
+    },
+    "agentRules": {
+      "type": "object",
+      "properties": {
+        "on": {
+          "type": "array",
+          "items": {
+            "$ref": "#/$defs/RuleName"
+          },
+          "description": "Catalogued Rules switched on here"
+        },
+        "off": {
+          "type": "array",
+          "items": {
+            "$ref": "#/$defs/RuleName"
+          },
+          "description": "Catalogued Rules switched off here"
+        }
+      },
+      "additionalProperties": false
+    }
+  },
+  "additionalProperties": false,
+  "title": "quality.json",
+  "description": "What a repository has opted into from @avi2dg/checks, read by its bins and agent Rule selection",
+  "$defs": {
+    "Command": {
+      "type": "string",
+      "minLength": 1
+    },
+    "Identity": {
+      "type": "object",
+      "properties": {
+        "name": {
+          "type": "string",
+          "minLength": 1
+        },
+        "email": {
+          "type": "string",
+          "minLength": 1
+        }
+      },
+      "required": [
+        "name",
+        "email"
+      ],
+      "additionalProperties": false
+    },
+    "PathGlob": {
+      "type": "string",
+      "pattern": "^(?!\\.\\.?(?:\\/|$))(?:\\*\\*|(?:[\\w.@+-]|\\*(?!\\*))+)(?:\\/(?!\\.\\.?(?:\\/|$))(?:\\*\\*|(?:[\\w.@+-]|\\*(?!\\*))+))*\\/(?:[\\w.@+-]|\\*(?!\\*))*\\.\\w+$",
+      "description": "A glob from the repository root that oxlint, the Effect language service and git read alike: a directory first, * within a segment, ** as a whole one, a file name with an extension last, and no braces, ?, [ or leading ./"
+    },
+    "RuleName": {
+      "type": "string",
+      "pattern": "^[a-z0-9]+(?:-[a-z0-9]+)*$"
+    }
+  }
+}

package/scripts/ci-wiring.ts

@@ -2,15 +2,8 @@
 import { Console, Effect, FileSystem, Path, Schema } from "effect";
 import { git } from "./git.ts";
 import { runMain } from "./main.ts";
-import {
-  DEFAULT_BRANCH,
-  ENTRY_POINT,
-  EVERY_REPOSITORY,
-  KIT_GATES,
-  LintWiring,
-  selectedGates,
-  type KitGate,
-} from "./gates.ts";
+import { DEFAULT_BRANCH, ENTRY_POINT, EVERY_REPOSITORY, KIT_GATES, QUALITY_FILE, selectedGates, type KitGate } from "./gates.ts";
+import { readQuality, type Quality } from "./quality-file.ts";
 
 export type Command = readonly string[];
 
@@ -21,6 +14,7 @@ export type Gate = {
 
 export type Declaration = {
   readonly gates: readonly Gate[];
+  readonly scheduled: readonly Gate[];
   readonly defaultBranch: string;
   readonly lintGates: readonly KitGate[];
 };
@@ -53,6 +47,8 @@ type RunStep = {
   readonly script: string;
 };
 
+type Trigger = (workflow: Workflow) => string | undefined;
+
 export class WiringError extends Schema.TaggedError<WiringError>()("WiringError", {
   message: Schema.String,
 }) {}
@@ -161,7 +157,7 @@ function selects(patterns: readonly string[], branch: string): boolean {
   return selected;
 }
 
-function triggerBlocker(workflow: Workflow, branch: string): string | undefined {
+const pullRequestTrigger = (branch: string): Trigger => (workflow) => {
   const on = isRecord(workflow.document) ? workflow.document["on"] : undefined;
   const events = isRecord(on) ? Object.keys(on) : (names(on) ?? []);
   if (!events.includes("pull_request")) return `${workflow.path} does not trigger on pull_request`;
@@ -183,7 +179,14 @@ function triggerBlocker(workflow: Workflow, branch: string): string | undefined
   const missing = types === undefined ? [] : GATING_TYPES.filter((type) => !types.includes(type));
   if (missing.length > 0) return `${workflow.path} limits pull_request to types without ${missing.join(", ")}`;
   return undefined;
-}
+};
+
+const scheduleTrigger: Trigger = (workflow) => {
+  const on = isRecord(workflow.document) ? workflow.document["on"] : undefined;
+  const schedule = isRecord(on) ? on["schedule"] : undefined;
+  const crons = Array.isArray(schedule) ? schedule.filter((entry) => isRecord(entry) && typeof entry["cron"] === "string") : [];
+  return crons.length > 0 ? undefined : `${workflow.path} does not trigger on a schedule`;
+};
 
 // GitHub prefixes any other if: with success(), so only a status function overrides a needed job's skip.
 function skippedBy(jobs: Readonly<Record<string, unknown>>, id: string, seen: readonly string[]): string | undefined {
@@ -202,7 +205,7 @@ function localCall(uses: unknown): string | undefined {
   return typeof uses === "string" && uses.startsWith("./") ? uses.slice(2) : undefined;
 }
 
-function runSteps(workflows: readonly Workflow[], branch: string): readonly RunStep[] {
+function runSteps(workflows: readonly Workflow[], trigger: Trigger): readonly RunStep[] {
   const documents = new Map(workflows.map((workflow) => [workflow.path, workflow.document]));
   const steps: RunStep[] = [];
 
@@ -240,7 +243,7 @@ function runSteps(workflows: readonly Workflow[], branch: string): readonly RunS
   };
 
   for (const workflow of workflows) {
-    visit(workflow.document, workflow.path, triggerBlocker(workflow, branch), [workflow.path]);
+    visit(workflow.document, workflow.path, trigger(workflow), [workflow.path]);
   }
   return steps;
 }
@@ -250,10 +253,9 @@ function entryPointCommand(gate: Command, lintGates: readonly KitGate[]): Comman
   return index === -1 ? undefined : [...gate.slice(0, index), ENTRY_POINT.bin];
 }
 
-export function findGaps(declaration: Declaration, workflows: readonly Workflow[]): readonly Gap[] {
-  const steps = runSteps(workflows, declaration.defaultBranch);
-  return declaration.gates.flatMap((gate) => {
-    const entryPoint = entryPointCommand(gate.words, declaration.lintGates);
+function gapsAmong(gates: readonly Gate[], steps: readonly RunStep[], lintGates: readonly KitGate[]): readonly Gap[] {
+  return gates.flatMap((gate) => {
+    const entryPoint = entryPointCommand(gate.words, lintGates);
     const commands = [
       { command: gate.command, words: gate.words },
       ...(entryPoint === undefined ? [] : [{ command: entryPoint.join(" "), words: entryPoint }]),
@@ -274,10 +276,16 @@ export function findGaps(declaration: Declaration, workflows: readonly Workflow[
   });
 }
 
-export function formatReport(declaration: Declaration, gaps: readonly Gap[]): string {
-  const target = `pull requests to ${declaration.defaultBranch}`;
-  if (gaps.length === 0) return `ci-wiring: ${declaration.gates.length} gate(s) run on ${target}`;
-  const lines = [`ci-wiring: ${gaps.length} of ${declaration.gates.length} gate(s) do not run on ${target}:`];
+export function findGaps(declaration: Declaration, workflows: readonly Workflow[]): readonly Gap[] {
+  return gapsAmong(declaration.gates, runSteps(workflows, pullRequestTrigger(declaration.defaultBranch)), declaration.lintGates);
+}
+
+export function findScheduledGaps(declaration: Declaration, workflows: readonly Workflow[]): readonly Gap[] {
+  return gapsAmong(declaration.scheduled, runSteps(workflows, scheduleTrigger), declaration.lintGates);
+}
+
+function gapLines(gaps: readonly Gap[]): readonly string[] {
+  const lines: string[] = [];
   for (const gap of gaps) {
     lines.push(`  ${gap.gate}`);
     if (gap.blocked.length === 0) {
@@ -285,38 +293,48 @@ export function formatReport(declaration: Declaration, gaps: readonly Gap[]): st
     }
     for (const { location, blocker } of gap.blocked) lines.push(`    ${location}: ${blocker}`);
   }
-  return lines.join("\n");
+  return lines;
+}
+
+export function formatReport(declaration: Declaration, gaps: readonly Gap[]): string {
+  const target = `pull requests to ${declaration.defaultBranch}`;
+  if (gaps.length === 0) return `ci-wiring: ${declaration.gates.length} gate(s) run on ${target}`;
+  return [`ci-wiring: ${gaps.length} of ${declaration.gates.length} gate(s) do not run on ${target}:`, ...gapLines(gaps)].join("\n");
 }
 
-const decodeWiring = Schema.decodeUnknownEffect(LintWiring);
+export function formatScheduledReport(declaration: Declaration, gaps: readonly Gap[]): string {
+  const total = declaration.scheduled.length;
+  if (gaps.length === 0) return `ci-wiring: ${total} scheduled command(s) run on a schedule`;
+  return [`ci-wiring: ${gaps.length} of ${total} scheduled command(s) do not run on a schedule:`, ...gapLines(gaps)].join("\n");
+}
 
-export const parseDeclaration = Effect.fnUntraced(function* (
-  manifest: unknown,
-  source: string,
-): Effect.fn.Return<Declaration, WiringError> {
-  const configured = isRecord(manifest) && isRecord(manifest["ciWiring"]) ? manifest["ciWiring"] : {};
-  const listed: unknown = configured["gates"];
-  if (!Array.isArray(listed) || listed.length === 0) {
-    return yield* new WiringError({ message: `${source} sets no ciWiring.gates, a non-empty array of commands` });
-  }
-  const commands: readonly unknown[] = listed;
+const plainCommands = Effect.fnUntraced(function* (
+  listed: readonly string[],
+  subject: string,
+): Effect.fn.Return<readonly Gate[], WiringError> {
   const gates: Gate[] = [];
-  for (const command of commands) {
-    const words = typeof command === "string" ? plainCommand(command) : undefined;
-    if (typeof command !== "string" || words === undefined) {
-      return yield* new WiringError({
-        message: `${source} ciWiring gate ${JSON.stringify(command)} is not one plain command`,
-      });
+  for (const command of listed) {
+    const words = plainCommand(command);
+    if (words === undefined) {
+      return yield* new WiringError({ message: `${subject} ${JSON.stringify(command)} is not one plain command` });
     }
     gates.push({ command, words });
   }
-  const { ciWiring } = yield* decodeWiring(manifest).pipe(
-    Effect.mapError((cause) => new WiringError({ message: `${source}: ${cause.message}` })),
-  );
+  return gates;
+});
+
+export const parseDeclaration = Effect.fnUntraced(function* (
+  { defaultBranch, gates: declared }: Quality,
+  source: string,
+): Effect.fn.Return<Declaration, WiringError> {
+  if (declared?.ci === undefined) {
+    return yield* new WiringError({ message: `${QUALITY_FILE} declares no gates.ci, a non-empty array of commands` });
+  }
   return {
-    gates,
-    defaultBranch: ciWiring?.defaultBranch ?? DEFAULT_BRANCH,
-    lintGates: selectedGates(ciWiring?.lintGates),
+    gates: yield* plainCommands(declared.ci, `${source} gate`),
+    scheduled: yield* plainCommands(declared.scheduled ?? [], `${source} scheduled command`),
+    defaultBranch: defaultBranch ?? DEFAULT_BRANCH,
+    lintGates: selectedGates(declared.lint),
   };
 });
 
@@ -345,10 +363,10 @@ export function formatOmissions(lintGates: readonly KitGate[], omissions: readon
   if (omitted.length === 0) return undefined;
   if (omissions.length === 0) {
     const bins = omitted.map((gate) => gate.bin).join(", ");
-    return `ci-wiring: ciWiring.lintGates leaves out ${bins}, none of which this repository's contents make applicable`;
+    return `ci-wiring: ${QUALITY_FILE} gates.lint leaves out ${bins}, none of which this repository's contents make applicable`;
   }
   return [
-    `ci-wiring: ciWiring.lintGates leaves out ${omissions.length} gate(s) this repository's contents make applicable:`,
+    `ci-wiring: ${QUALITY_FILE} gates.lint leaves out ${omissions.length} gate(s) this repository's contents make applicable:`,
     ...omissions.map(({ gate, content, files }) => `  ${gate}: the repository tracks ${content} (${sample(files)})`),
   ].join("\n");
 }
@@ -359,16 +377,9 @@ export const parseWorkflow = (path: string, text: string): Effect.Effect<Workflo
     catch: (error) => new WiringError({ message: `cannot parse ${path}: ${String(error)}` }),
   });
 
-const parseJson = Schema.decodeUnknownEffect(Schema.fromJsonString(Schema.Unknown));
-
 export const readDeclaration = Effect.fn("readDeclaration")(function* (root: string) {
-  const fs = yield* FileSystem.FileSystem;
-  const path = (yield* Path.Path).join(root, "package.json");
-  const manifest = yield* fs.readFileString(path).pipe(
-    Effect.flatMap(parseJson),
-    Effect.mapError((cause) => new WiringError({ message: `cannot read ${path} as JSON: ${cause.message}` })),
-  );
-  return yield* parseDeclaration(manifest, path);
+  const { source, quality } = yield* readQuality(root);
+  return yield* parseDeclaration(quality, source);
 });
 
 export const readWorkflows = Effect.fn("readWorkflows")(function* (root: string) {
@@ -389,7 +400,8 @@ export const readWorkflows = Effect.fn("readWorkflows")(function* (root: string)
 const wiring = Effect.gen(function* () {
   const root = (yield* git(["rev-parse", "--show-toplevel"])).trim();
   const declaration = yield* readDeclaration(root);
-  const gaps = findGaps(declaration, yield* readWorkflows(root));
+  const workflows = yield* readWorkflows(root);
+  const gaps = findGaps(declaration, workflows);
   const omissions = yield* findOmissions(root, declaration.lintGates);
   const gapReport = formatReport(declaration, gaps);
   yield* gaps.length > 0 ? Console.error(gapReport) : Console.log(gapReport);
@@ -397,7 +409,11 @@ const wiring = Effect.gen(function* () {
   if (omissionReport !== undefined) {
     yield* omissions.length > 0 ? Console.error(omissionReport) : Console.log(omissionReport);
   }
-  return gaps.length === 0 && omissions.length === 0;
+  if (declaration.scheduled.length === 0) return gaps.length === 0 && omissions.length === 0;
+  const scheduledGaps = findScheduledGaps(declaration, workflows);
+  const scheduledReport = formatScheduledReport(declaration, scheduledGaps);
+  yield* scheduledGaps.length > 0 ? Console.error(scheduledReport) : Console.log(scheduledReport);
+  return gaps.length === 0 && omissions.length === 0 && scheduledGaps.length === 0;
 });
 
 if (import.meta.main) runMain("ci-wiring", wiring);

package/scripts/commit-identity.ts

@@ -1,10 +1,8 @@
 #!/usr/bin/env bun
-import { Console, Effect, FileSystem, Path, Schema } from "effect";
+import { Console, Effect, Schema } from "effect";
 import { git } from "./git.ts";
 import { runMain, Usage } from "./main.ts";
-
-const Identity = Schema.Struct({ name: Schema.String, email: Schema.String });
-type Identity = typeof Identity.Type;
+import { readQuality, type Identity } from "./quality-file.ts";
 
 type Commit = {
   readonly sha: string;
@@ -32,16 +30,6 @@ const RECORD = "\u001e";
 
 const USAGE = "usage: commit-identity.ts <ref> | <base-ref> <head-ref>";
 
-const Manifest = Schema.Struct({
-  commitIdentity: Schema.optional(Schema.Struct({ authors: Schema.NonEmptyArray(Identity) })),
-});
-const parseJson = Schema.decodeUnknownEffect(Schema.fromJsonString(Schema.Unknown));
-const decodeManifest = Schema.decodeUnknownEffect(Manifest);
-
-class InvalidAllowlist extends Schema.TaggedError<InvalidAllowlist>()("InvalidAllowlist", {
-  message: Schema.String,
-}) {}
-
 class UnreadableLog extends Schema.TaggedError<UnreadableLog>()("UnreadableLog", {
   message: Schema.String,
 }) {}
@@ -51,25 +39,8 @@ function render(identity: Identity): string {
 }
 
 const allowedAuthors = Effect.gen(function* () {
-  const fs = yield* FileSystem.FileSystem;
-  const path = yield* Path.Path;
-  const root = (yield* git(["rev-parse", "--show-toplevel"])).trim();
-  const manifestPath = path.join(root, "package.json");
-  if (!(yield* fs.exists(manifestPath))) return DEFAULT_AUTHORS;
-
-  const parsed = yield* fs.readFileString(manifestPath).pipe(
-    Effect.flatMap(parseJson),
-    Effect.mapError((cause) => new InvalidAllowlist({ message: `cannot read ${manifestPath} as JSON: ${cause.message}` })),
-  );
-  const manifest = yield* decodeManifest(parsed).pipe(
-    Effect.mapError(
-      () =>
-        new InvalidAllowlist({
-          message: `${manifestPath} sets commitIdentity without a non-empty authors array of {name, email}`,
-        }),
-    ),
-  );
-  return manifest.commitIdentity?.authors ?? DEFAULT_AUTHORS;
+  const { quality } = yield* readQuality((yield* git(["rev-parse", "--show-toplevel"])).trim());
+  return quality.commitIdentity?.authors ?? DEFAULT_AUTHORS;
 });
 
 const readCommits = Effect.fn("readCommits")(function* (revisions: readonly string[]) {