@drkmttr/adhere 0.7.1 → 0.8.0

package/src/excerpt.ts

@@ -0,0 +1,255 @@
+import { scan } from "#highlight.ts";
+
+/**
+ * The lines a finding shows: the statement its line is in, such as the
+ * function around it, and a few lines on either side of the line.
+ */
+export interface Excerpt {
+  /** The number of the first line, counting from 1. */
+  readonly start: number;
+  readonly lines: ReadonlyArray<string>;
+}
+
+/** How far an excerpt reaches on either side of the finding's line, in whole statements. */
+const AROUND = 3;
+/** The most lines a statement can have and still be shown whole. */
+const WHOLE = 30;
+
+/** Lines of the code, first to last, counting from 1. */
+interface Range {
+  readonly first: number;
+  readonly last: number;
+}
+
+const holds = (range: Range, line: number): boolean => range.first <= line && line <= range.last;
+
+/**
+ * A token that shapes the code: a bracket, a separator, an operator, or a
+ * value, such as a name, a keyword, or a literal. Only a template literal
+ * ends on a later line than the one it starts on.
+ */
+interface Piece {
+  readonly text: string;
+  readonly role: "open" | "close" | "separator" | "operator" | "value";
+  readonly line: number;
+  readonly end: number;
+  /** Whether whitespace or a comment comes right before it. */
+  readonly spaced: boolean;
+}
+
+const ROLES: Readonly<Record<string, Piece["role"]>> = {
+  "(": "open",
+  "[": "open",
+  "{": "open",
+  ")": "close",
+  "]": "close",
+  "}": "close",
+  ";": "separator",
+  ",": "separator",
+};
+
+/**
+ * The code as pieces, without whitespace and comments, and the comments and
+ * literals that span lines: a line that starts inside one does not read as
+ * code on its own.
+ */
+const piecesOf = (code: string) => {
+  const pieces: Array<Piece> = [];
+  const spans: Array<Range> = [];
+  let line = 1;
+  let spaced = true;
+  for (const { text, kind } of scan(code)) {
+    const end = line + text.split("\n").length - 1;
+    if (kind !== undefined && end > line) spans.push({ first: line, last: end });
+    if (kind === "comment" || text.trim().length === 0) {
+      spaced = true;
+    } else if (kind !== undefined || /^[\w$]/.test(text)) {
+      pieces.push({ text, role: "value", line, end, spaced });
+      spaced = false;
+    } else {
+      // A run of punctuation, like `});` or `=>{`: each bracket and separator is a piece.
+      for (const part of text.match(/[()[\]{};,]|[^()[\]{};,]+/g) ?? []) {
+        pieces.push({ text: part, role: ROLES[part] ?? "operator", line, end, spaced });
+        spaced = false;
+      }
+    }
+    line = end;
+  }
+  return { pieces, spans };
+};
+
+/**
+ * Where each group closes: the index of the piece that opens it, mapped to
+ * the index of the one that closes it. Type arguments broken over lines, from
+ * a `Type<` that ends a line to a `>` that starts one, are a group too, so
+ * their commas do not end a statement; a `<` that no such `>` closes was a
+ * comparison. A bracket left open runs to the end.
+ */
+const closesOf = (pieces: ReadonlyArray<Piece>): ReadonlyMap<number, number> => {
+  const closes = new Map<number, number>();
+  const opened: Array<number> = [];
+  const isAngle = (index: number | undefined): index is number =>
+    index !== undefined && pieces[index]?.text === "<";
+  pieces.forEach((piece, index) => {
+    const before = pieces[index - 1];
+    const after = pieces[index + 1];
+    const top = opened.at(-1);
+    if (piece.role === "open") {
+      opened.push(index);
+    } else if (piece.text === "<") {
+      const endsLine = after === undefined || after.line > piece.line;
+      if (endsLine && !piece.spaced && before?.role === "value") opened.push(index);
+    } else if (piece.text === ">" && isAngle(top) && (before?.end ?? 0) < piece.line) {
+      opened.pop();
+      closes.set(top, index);
+    } else if (piece.role === "close" || piece.text === ";") {
+      while (isAngle(opened.at(-1))) opened.pop();
+      const opener = piece.role === "close" ? opened.pop() : undefined;
+      if (opener !== undefined) closes.set(opener, index);
+    }
+  });
+  for (const opener of opened) {
+    if (!isAngle(opener)) closes.set(opener, pieces.length - 1);
+  }
+  return closes;
+};
+
+/** Operators that leave an expression open at the end of a line: `=`, `=>`, `&&`, `.`. */
+const LEAVES_OPEN = /[-+*/%&|^<>=?:.]$/;
+/** Operators that carry the expression above on at the start of a line: `.pipe(`, `? a`, `| B`. */
+const CARRIES_ON = /^[-+*/%&|^>=?:.]/;
+/** Words that need more after them at the end of a line. */
+const OPEN_WORDS = new Set(["as", "await", "extends", "implements", "keyof", "new", "satisfies"]);
+/** Words that go on with the statement above at the start of a line. */
+const ON_WORDS = new Set(["as", "catch", "else", "extends", "finally", "implements", "satisfies"]);
+
+const isStep = (text: string): boolean => text === "++" || text === "--";
+
+const leavesOpen = (piece: Piece): boolean =>
+  piece.role === "operator"
+    ? LEAVES_OPEN.test(piece.text) && !isStep(piece.text)
+    : piece.role === "value" && OPEN_WORDS.has(piece.text);
+
+const carriesOn = (piece: Piece): boolean =>
+  piece.role === "operator"
+    ? CARRIES_ON.test(piece.text) && !isStep(piece.text)
+    : piece.role === "value" && ON_WORDS.has(piece.text);
+
+/** A statement's lines, and the groups directly inside it, as the pieces that open and close each. */
+interface Statement extends Range {
+  readonly groups: ReadonlyArray<readonly [number, number]>;
+}
+
+/**
+ * The statements in the pieces from `from` up to `to`, each group inside one
+ * taken whole. A statement ends at a `;` or `,`, or at a line break that
+ * neither side carries across: about where JavaScript inserts a semicolon.
+ */
+const statementsIn = (
+  pieces: ReadonlyArray<Piece>,
+  closes: ReadonlyMap<number, number>,
+  from: number,
+  to: number,
+): ReadonlyArray<Statement> => {
+  const statements: Array<Statement> = [];
+  let current:
+    | { first: number; last: number; groups: Array<readonly [number, number]> }
+    | undefined;
+  let open = false;
+  let index = from;
+  while (index < to) {
+    const piece = pieces[index];
+    if (piece === undefined) break;
+    if (current !== undefined && piece.line > current.last && !open && !carriesOn(piece)) {
+      statements.push(current);
+      current = undefined;
+    }
+    const close = Math.min(closes.get(index) ?? index, to - 1);
+    const end = pieces[close]?.end ?? piece.end;
+    current ??= { first: piece.line, last: end, groups: [] };
+    current.last = end;
+    if (close > index) current.groups.push([index, close]);
+    // A group's closing bracket leaves nothing open.
+    open = close === index && leavesOpen(piece);
+    if (piece.role === "separator") {
+      statements.push(current);
+      current = undefined;
+    }
+    index = close + 1;
+  }
+  if (current !== undefined) statements.push(current);
+  return statements;
+};
+
+/**
+ * The statements `line` is in, outermost first: the one at the top level,
+ * then the one around `line` inside the group of that statement it is in,
+ * and so on inward. A line where two statements meet is in both, together.
+ */
+const statementsAround = (
+  pieces: ReadonlyArray<Piece>,
+  closes: ReadonlyMap<number, number>,
+  line: number,
+  from = 0,
+  to = pieces.length,
+): ReadonlyArray<Range> => {
+  const around = statementsIn(pieces, closes, from, to).filter((statement) =>
+    holds(statement, line),
+  );
+  const [outer, inner] = [around[0], around.at(-1)];
+  if (outer === undefined || inner === undefined) return [];
+  const group = around
+    .flatMap((statement) => statement.groups)
+    .find(
+      ([open, close]) => (pieces[open]?.line ?? line) < line && line <= (pieces[close]?.line ?? 0),
+    );
+  return [
+    { first: outer.first, last: inner.last },
+    ...(group === undefined ? [] : statementsAround(pieces, closes, line, group[0] + 1, group[1])),
+  ];
+};
+
+/**
+ * The excerpt for a finding on `line`: the outermost statement around it
+ * with at most `WHOLE` lines, such as the function it is in, and up to
+ * `AROUND` lines on either side of `line`. A comment or template literal
+ * that spans lines counts as a statement inside the one it is in.
+ *
+ * Around `line`, the excerpt shows only whole statements, never the end of
+ * the one above or the start of the one below, so it cannot start partway
+ * through a comment, whose lines do not read as code on their own. What
+ * `line` itself is in can show in part: a long function's first line, above
+ * the statement of its body. It ends at code, since a comment at the end
+ * would be about code the excerpt leaves out.
+ */
+export const excerptOf = (lines: ReadonlyArray<string>, line: number): Excerpt => {
+  const { pieces, spans } = piecesOf(lines.join("\n"));
+  const closes = closesOf(pieces);
+  /** What a line is in, outermost first. */
+  const around = (at: number): ReadonlyArray<Range> => [
+    ...statementsAround(pieces, closes, at),
+    ...spans.filter((span) => holds(span, at)),
+  ];
+  const scope = around(line).find((range) => range.last - range.first < WHOLE);
+  const top = Math.max(1, Math.min(scope?.first ?? line, line - AROUND));
+  const bottom = Math.min(lines.length, Math.max(scope?.last ?? line, line + AROUND));
+  /** What a line is in that `line` is not, which an edge shows whole or not at all. */
+  const beside = (at: number) => around(at).filter((range) => !holds(range, line));
+  let first = Math.max(
+    top,
+    ...beside(top)
+      .filter((range) => range.first < top)
+      .map((range) => range.last + 1),
+  );
+  let last = Math.min(
+    bottom,
+    ...beside(bottom)
+      .filter((range) => range.last > bottom)
+      .map((range) => range.first - 1),
+  );
+  const isBlank = (at: number) => (lines[at - 1] ?? "").trim().length === 0;
+  const hasCode = (at: number) => pieces.some((piece) => piece.line <= at && at <= piece.end);
+  while (first < line && isBlank(first)) first += 1;
+  while (last > line && !hasCode(last)) last -= 1;
+  return { start: first, lines: lines.slice(first - 1, last) };
+};

package/src/highlight.ts

@@ -27,11 +27,11 @@ const NOT_KEYS = words("default super this");
 /** The groups that name their token's kind. */
 const CLASSES = ["comment", "string", "constant"] as const;
 
-/** One group per token class, tried in order at each position. */
+/** One group per token class, tried in order at each position. A template literal is read apart. */
 const TOKEN = new RegExp(
   [
     /(?<comment>\/\/[^\n]*|\/\*[\s\S]*?(?:\*\/|$))/,
-    /(?<string>"(?:[^"\\\n]|\\.)*"?|'(?:[^'\\\n]|\\.)*'?|`(?:[^`\\]|\\[\s\S])*`?)/,
+    /(?<string>"(?:[^"\\\n]|\\.)*"?|'(?:[^'\\\n]|\\.)*'?)/,
     /(?<constant>0[box][\da-f_]+n?|\d[\d_]*(?:\.\d[\d_]*)?(?:e[+-]?\d+)?n?)/,
     /(?<word>[a-z_$][\w$]*)/,
     /(?<space>\s+)/,
@@ -71,36 +71,98 @@ const kindOf = (word: string, previous: string | undefined, isKey: boolean): Kin
   return KEYWORDS.has(word) ? "keyword" : PRIMITIVES.has(word) ? "type" : undefined;
 };
 
+/** Whether a token is what the next one reads as before it: not whitespace or a comment. */
+const counts = (token: Token): boolean => token.kind !== "comment" && token.text.trim().length > 0;
+
+/** The token at `at`, after `previous`, the last one that counts. */
+const tokenAt = (code: string, at: number, previous: string | undefined): Token | undefined => {
+  if (code[at] === "`") return { text: code.slice(at, templateEnd(code, at)), kind: "string" };
+  const regex = regexMayStart(previous) ? matchAt(REGEX, code, at) : null;
+  const match = regex ?? matchAt(TOKEN, code, at);
+  // `punctuation` matches any character the other groups do not.
+  if (match === null) return undefined;
+  const text = match[0];
+  const groups = match.groups ?? {};
+  const kind: Kind | undefined =
+    regex !== null
+      ? "string"
+      : groups.word !== undefined
+        ? kindOf(groups.word, previous, matchAt(KEY, code, at + text.length) !== null)
+        : CLASSES.find((name) => groups[name] !== undefined);
+  return kind === undefined ? { text } : { text, kind };
+};
+
+/**
+ * Where the template literal that opens at `at` closes: past its closing
+ * backtick, or at the end of the code. The code in each `${…}` is read as
+ * tokens, so a brace or a template in it, as in `${xs.map((x) => `${x}`)}`,
+ * does not close the template early.
+ */
+const templateEnd = (code: string, at: number): number => {
+  let index = at + 1;
+  while (index < code.length && code[index] !== "`") {
+    if (code[index] === "\\") index += 2;
+    else if (code.startsWith("${", index)) index = substitutionEnd(code, index + 2);
+    else index += 1;
+  }
+  return Math.min(index + 1, code.length);
+};
+
+/** Where the code of a `${…}` that starts at `at` ends: past the brace that closes it. */
+const substitutionEnd = (code: string, at: number): number => {
+  let depth = 0;
+  let previous: string | undefined;
+  let index = at;
+  while (index < code.length) {
+    const token = tokenAt(code, index, previous);
+    if (token === undefined) break;
+    // Braces are punctuation; one in a string or a nested template is text.
+    if (token.kind === undefined) {
+      for (let offset = 0; offset < token.text.length; offset += 1) {
+        if (token.text[offset] === "{") depth += 1;
+        else if (token.text[offset] === "}") {
+          if (depth === 0) return index + offset + 1;
+          depth -= 1;
+        }
+      }
+    }
+    if (counts(token)) previous = token.text;
+    index += token.text.length;
+  }
+  return code.length;
+};
+
+/**
+ * The code's tokens, in order. A token that crosses a newline, like a block
+ * comment or a template literal, stays whole.
+ */
+export const scan = (code: string): ReadonlyArray<Token> => {
+  const tokens: Array<Token> = [];
+  let previous: string | undefined;
+  let at = 0;
+  while (at < code.length) {
+    const token = tokenAt(code, at, previous);
+    if (token === undefined) break;
+    tokens.push(token);
+    if (counts(token)) previous = token.text;
+    at += token.text.length;
+  }
+  return tokens;
+};
+
 /**
  * The code's lines, each as tokens. A token that crosses a newline, like a
  * block comment or a template literal, is cut into one token per line.
  */
 export const tokenize = (code: string): ReadonlyArray<ReadonlyArray<Token>> => {
   const lines: Array<Array<Token>> = [[]];
-  // The last token that was not whitespace or a comment.
-  let previous: string | undefined;
-  let at = 0;
-  while (at < code.length) {
-    const regex = regexMayStart(previous) ? matchAt(REGEX, code, at) : null;
-    const match = regex ?? matchAt(TOKEN, code, at);
-    // `punctuation` matches any character the other groups do not.
-    if (match === null) break;
-    const text = match[0];
-    const groups = match.groups ?? {};
-    const kind: Kind | undefined =
-      regex !== null
-        ? "string"
-        : groups.word !== undefined
-          ? kindOf(groups.word, previous, matchAt(KEY, code, at + text.length) !== null)
-          : CLASSES.find((name) => groups[name] !== undefined);
+  for (const { text, kind } of scan(code)) {
     for (const [index, piece] of text.split("\n").entries()) {
       if (index > 0) lines.push([]);
       if (piece.length > 0) {
         lines.at(-1)?.push(kind === undefined ? { text: piece } : { text: piece, kind });
       }
     }
-    if (groups.comment === undefined && groups.space === undefined) previous = text;
-    at += text.length;
   }
   return lines;
 };

package/src/init.ts

@@ -20,18 +20,24 @@ export default {
 `;
 
 const SMALL_FILES = `---
-description: A file should be small and focused, with one primary responsibility.
+description: A file should be small and focused, with one primary responsibility, and should not mix unrelated concerns.
 threshold: 0.8
 ---
 
-A guideline, so its description and its code say should. A rule that must
-hold says must and never instead, as name-domain-actions does. Use this rule
-as a template for repository-specific conventions.
+A guideline, so its description and its code say should and should not. A
+rule that must hold says must and never instead, as name-domain-actions does.
+Use this rule as a template for repository-specific conventions.
 
 \`\`\`ts should
 export const parsePort = (value: string) =>
   Port.make(Number.parseInt(value, 10));
 \`\`\`
+
+\`\`\`ts should not
+export const parsePort = (value: string) => Port.make(Number.parseInt(value, 10));
+export const sendWelcomeEmail = (to: Email) => Mailer.send(to, welcomeTemplate);
+export const renderInvoice = (invoice: Invoice) => Html.table(invoice.lines);
+\`\`\`
 `;
 
 const NAME_EFFECTS = `---

package/src/main.ts

@@ -4,7 +4,7 @@ import * as adhere from "#index.ts";
 import { version } from "#version.ts";
 import { BunRuntime, BunServices } from "@effect/platform-bun";
 import { plugin } from "bun";
-import { Effect } from "effect";
+import { Cause, Effect, Layer, Logger, References, Runtime } from "effect";
 import { Command } from "effect/unstable/cli";
 
 // A config file may import `@drkmttr/adhere`, for `defineConfig`. The compiled
@@ -17,8 +17,39 @@ plugin({
   },
 });
 
+/**
+ * Every log on stderr, so stdout carries the report and nothing else. The
+ * pretty logger picks its stream from `LogToStderr`, not from an option.
+ */
+const logger = Layer.merge(
+  Logger.layer([Logger.consolePretty()]),
+  Layer.succeed(References.LogToStderr, true),
+);
+
+/**
+ * How a failed run says so, through the logger above: runMain's own report
+ * goes to stdout. A failure adhere declares, such as a refused request or a
+ * config that does not decode, is its message alone; its stack would only
+ * point into adhere. A defect, which is a bug, keeps its whole cause.
+ */
+const report = (cause: Cause.Cause<unknown>): Effect.Effect<void> => {
+  if (Cause.hasInterruptsOnly(cause)) return Effect.void;
+  const error = Cause.squash(cause);
+  const marked = typeof error === "object" && error !== null && Runtime.errorReported in error;
+  if (
+    marked &&
+    (error as { readonly [Runtime.errorReported]: boolean })[Runtime.errorReported] === false
+  ) {
+    return Effect.void;
+  }
+  return !Cause.hasDies(cause) && error instanceof Error
+    ? Effect.logError(error.message)
+    : Effect.logError(cause);
+};
+
 Command.run(cli, { version }).pipe(
-  // oxlint-disable-next-line effecttsgo/strict-effect-provide -- this executable entrypoint supplies Bun's process services.
-  Effect.provide(BunServices.layer),
-  BunRuntime.runMain,
+  Effect.tapCause(report),
+  // oxlint-disable-next-line effecttsgo/strict-effect-provide -- this executable entrypoint supplies Bun's process services and the logger.
+  Effect.provide(Layer.merge(BunServices.layer, logger)),
+  (program) => BunRuntime.runMain(program, { disableErrorReporting: true }),
 );

package/src/mechanical.ts

@@ -0,0 +1,89 @@
+import type { Rule } from "#config.ts";
+import type { RuleEntry } from "#rules.ts";
+import { AuditCache, sha256, type Tally } from "#services/AuditCache.ts";
+import { linterQuestion } from "#services/Jev.ts";
+import { Effect } from "effect";
+
+/**
+ * The linter check asks, beside a rule's judge question, whether a regular
+ * linter could have decided the file against the rule. The answer is about
+ * the rule, so lint asks it on this many files per rule and then stops.
+ */
+export const SAMPLE = 10;
+
+/** A tally's key: the model and the question, which carries the rule, so an edited rule starts over. */
+export const tallyKeyOf = (model: string, rule: Rule) =>
+  sha256(`${model}\u0000${JSON.stringify(linterQuestion(rule))}`);
+
+/** A rule and its linter check so far: the files lint asked on, and how many Jev said a linter could check. */
+export interface Tallied {
+  readonly entry: RuleEntry;
+  readonly asked: number;
+  readonly flagged: number;
+}
+
+export const talliedOf = (entry: RuleEntry, tally: Tally | undefined): Tallied => {
+  const answers = Object.values(tally?.files ?? {});
+  return { entry, asked: answers.length, flagged: answers.filter((p) => p > 0.5).length };
+};
+
+/** The project's rules with their tallies. A preset's rules are left out: they are not the user's to change. */
+export const tallyProjectRules = Effect.fn("mechanical.tally")(function* (
+  entries: ReadonlyArray<RuleEntry>,
+  model: string,
+) {
+  const cache = yield* AuditCache;
+  return yield* Effect.forEach(
+    entries.filter((entry) => entry.preset === undefined),
+    (entry) =>
+      Effect.map(Effect.flatMap(tallyKeyOf(model, entry.rule), cache.tally), (tally) =>
+        talliedOf(entry, tally),
+      ),
+  );
+});
+
+/**
+ * Of a full sample, the share Jev said a linter could check: from 0.7 a
+ * linter should probably check the rule, and from 0.3 the rule reads
+ * differently from file to file.
+ */
+const LINTER = 0.7;
+const MIXED = 0.3;
+
+const displayPath = (file: string, root: string): string =>
+  file.startsWith(`${root}/`) ? file.slice(root.length + 1) : file;
+
+/** One flagged rule's advice, from its tally. */
+const adviceOf = ({ asked, flagged }: Tallied): string =>
+  flagged >= LINTER * asked
+    ? `Flagged on ${flagged} of ${asked} files: a regular linter should probably check this rule.`
+    : `Flagged on ${flagged} of ${asked} files: say more precisely what the rule applies to.`;
+
+/** The linter check's part of `adhere validate`'s report: each rule it flags, then any it has too few answers for. */
+export const formatLinterCheck = (
+  tallied: ReadonlyArray<Tallied>,
+  root: string,
+): ReadonlyArray<string> => {
+  if (tallied.length === 0) return [];
+  const sampled = tallied.filter((one) => one.asked >= SAMPLE);
+  const flagged = sampled.filter((one) => one.flagged >= MIXED * one.asked);
+  const waiting = tallied.length - sampled.length;
+  return [
+    ...(flagged.length === 0
+      ? sampled.length === 0
+        ? []
+        : ["The linter check flags no rule."]
+      : [
+          `${flagged.length} ${flagged.length === 1 ? "rule" : "rules"} flagged by the linter check:`,
+          ...flagged.flatMap((one) => [
+            `  ${one.entry.id}${one.entry.file === undefined ? "" : ` (${displayPath(one.entry.file, root)})`}`,
+            `    ${adviceOf(one)}`,
+          ]),
+        ]),
+    ...(waiting === 0
+      ? []
+      : [
+          `${waiting} ${waiting === 1 ? "rule has" : "rules have"} fewer than ${SAMPLE} answers from lint yet, which asks as it judges files.`,
+        ]),
+  ];
+};

package/src/presets.ts

@@ -7,8 +7,7 @@ import type { Preset } from "#config.ts";
  * is the check Bun's docs give for this. Measured on Bun 1.4. The `typeof`
  * guard is for Vitest, which imports this module on Node.
  */
-const isStandaloneExecutable =
-  typeof Bun !== "undefined" && Bun.isStandaloneExecutable;
+const isStandaloneExecutable = typeof Bun !== "undefined" && Bun.isStandaloneExecutable;
 
 const presetsRoot = isStandaloneExecutable
   ? new URL("./presets/", import.meta.url)

package/src/rules.ts

@@ -18,6 +18,8 @@ export interface RuleEntry {
   readonly rule: Rule;
   readonly scope: string;
   readonly file?: string;
+  /** The built-in rule set the rule came from, when it is not the project's own. */
+  readonly preset?: string;
 }
 
 export type RuleSet = ReadonlyArray<RuleEntry>;

package/src/services/AdhereConfig.ts

@@ -21,10 +21,9 @@ import {
 } from "#rules.ts";
 import { Context, Effect, FileSystem, Layer, Path, Record } from "effect";
 
-export class AdhereConfig extends Context.Service<
-  AdhereConfig,
-  ResolvedConfig
->()("@drkmttr/adhere/services/AdhereConfig") {}
+export class AdhereConfig extends Context.Service<AdhereConfig, ResolvedConfig>()(
+  "@drkmttr/adhere/services/AdhereConfig",
+) {}
 
 const loadConfigFile = Effect.fn("AdhereConfig.load")(function* (file: string) {
   const path = yield* Path.Path;
@@ -72,14 +71,12 @@ export const AdhereConfigLive = (overrides: Overrides) =>
         });
       }
       const configFile = found[0];
-      const hasPreset =
-        overrides.presets !== undefined && overrides.presets.length > 0;
+      const hasPreset = overrides.presets !== undefined && overrides.presets.length > 0;
       const config: Decoded =
         configFile === undefined
           ? yield* decodeConfig({})
           : yield* loadConfigFile(path.join(cwd, configFile));
-      const discoveredEntries =
-        config.rules === undefined ? yield* loadAdhereRuleSet(cwd) : [];
+      const discoveredEntries = config.rules === undefined ? yield* loadAdhereRuleSet(cwd) : [];
       const hasProjectRules = discoveredEntries.length > 0;
       if (configFile === undefined && !hasProjectRules && !hasPreset) {
         return yield* ConfigUnavailable.make({
@@ -89,18 +86,17 @@ export const AdhereConfigLive = (overrides: Overrides) =>
       const projectEntries: RuleSet =
         config.rules === undefined
           ? discoveredEntries
-          : globalRuleSet(
-              yield* materializeRules(config.rules ?? {}, cwd),
-              cwd,
-            );
+          : globalRuleSet(yield* materializeRules(config.rules ?? {}, cwd), cwd);
       const rules = applicableRules(cwd, projectEntries);
-      const registry = yield* Effect.forEach(
-        presetsOf(config, overrides),
-        (name) => loadPreset(name, cwd),
+      const registry = yield* Effect.forEach(presetsOf(config, overrides), (name) =>
+        loadPreset(name, cwd),
       ).pipe(Effect.map(Record.fromEntries));
       const resolved = resolveConfig({ ...config, rules }, overrides, registry);
-      const presetEntries = Object.entries(registry).flatMap(([, preset]) =>
-        globalRuleSet(preset.rules, cwd),
+      const presetEntries = Object.entries(registry).flatMap(([name, preset]) =>
+        globalRuleSet(preset.rules, cwd).map((entry) => ({ ...entry, preset: name })),
+      );
+      yield* Effect.logDebug(
+        `config: ${configFile ?? "no config file"}; presets ${Object.keys(registry).join(", ") || "none"}; ${presetEntries.length} preset and ${projectEntries.length} project rules; model ${resolved.model}, threshold ${resolved.threshold}${resolved.rpm === undefined ? "" : `, at most ${resolved.rpm} requests a minute`}`,
       );
       return AdhereConfig.of({
         ...resolved,