chaffjs 0.16.0 → 0.18.0

package/src/compare/render.ts

@@ -0,0 +1,102 @@
+import { ATOM_KINDS, type Atom, type AtomKind } from "./atom.ts";
+import type { Reformed } from "./match.ts";
+import type { Change, Outcome, Side } from "./outcome.ts";
+import type { CompareText } from "./text.ts";
+
+/** How much of a fact is shown: a code block is shown by its first line. */
+const SHOWN_WIDTH = 60;
+
+/** One line of a fact as written: a code block or a wrapped quotation is shown on one line, cut at SHOWN_WIDTH. */
+const shown = (text: string): string => {
+  const oneLine = text.replace(/\s+/gu, " ").trim();
+  return oneLine.length > SHOWN_WIDTH ? `${oneLine.slice(0, SHOWN_WIDTH)}…` : oneLine;
+};
+
+const totalOf = (side: Side): number => ATOM_KINDS.reduce((sum, kind) => sum + side.counts[kind], 0);
+
+/** The count line. Every kind is listed, zeros too: "nothing dropped" reads as N facts checked, never as nothing looked at. */
+const checkedLine = (outcome: Outcome, text: CompareText): string => {
+  const perKind = ATOM_KINDS.map((kind) => `${text.kinds[kind]} ${String(outcome.before.counts[kind])}→${String(outcome.after.counts[kind])}`);
+  return text.checked(totalOf(outcome.before), totalOf(outcome.after), perKind.join(text.separator));
+};
+
+const failing = (changes: readonly Change[]): number => changes.filter((change) => !change.allowed).length;
+
+const verdict = (outcome: Outcome, text: CompareText): string => (outcome.ok ? text.clean : text.failed(failing(outcome.dropped), failing(outcome.added)));
+
+const kindColumn = (kind: AtomKind, text: CompareText): string => `${text.kind[kind]}: `;
+
+const changeLine = (change: Change, path: string, flag: string, text: CompareText): string =>
+  `  ${kindColumn(change.kind, text)}${shown(change.text)}  (${path}:${String(change.line)})${change.allowed ? text.allowed(flag) : ""}`;
+
+const reformedLine = (pair: Reformed, text: CompareText): string =>
+  `  ${kindColumn(pair.before.kind, text)}${shown(pair.before.text)} → ${shown(pair.after.text)}  (${text.lines(pair.before.line, pair.after.line)})`;
+
+const block = (heading: string, lines: readonly string[]): string[] => (lines.length === 0 ? [] : ["", heading, ...lines]);
+
+const unreadBlock = (outcome: Outcome, text: CompareText): string[] => {
+  const sides = [outcome.before, outcome.after];
+  const lines = sides.flatMap((side) => side.unread.map((unread) => `  ${side.path}: ${text.unread(unread.kind, unread.reason)}`));
+  return block(text.unreadHeading, lines);
+};
+
+/** For a person: what was dropped and added, with the line in each file, then what only changed its form. */
+export const renderFriendly = (outcome: Outcome, text: CompareText): string => {
+  const { before, after } = outcome;
+  return [
+    `${before.path} → ${after.path}`,
+    ...block(
+      text.droppedHeading(outcome.dropped.length, before.path, after.path),
+      outcome.dropped.map((change) => changeLine(change, before.path, "--allow-dropped", text)),
+    ),
+    ...block(
+      text.addedHeading(outcome.added.length, after.path),
+      outcome.added.map((change) => changeLine(change, after.path, "--allow-added", text)),
+    ),
+    ...block(
+      text.reformedHeading(outcome.reformed.length),
+      outcome.reformed.map((pair) => reformedLine(pair, text)),
+    ),
+    ...unreadBlock(outcome, text),
+    "",
+    checkedLine(outcome, text),
+    verdict(outcome, text),
+  ].join("\n");
+};
+
+const compactChange = (change: Change, path: string, word: string): string =>
+  `${path}:${String(change.line)}: ${word} ${change.kind} ${shown(change.text)}${change.allowed ? " (allowed)" : ""}`;
+
+/** For an engineer and grep: one line per fact, the words dropped / added / reformed and the kind in English. */
+export const renderCompact = (outcome: Outcome, text: CompareText): string => {
+  const { before, after } = outcome;
+  return [
+    ...outcome.dropped.map((change) => compactChange(change, before.path, "dropped")),
+    ...outcome.added.map((change) => compactChange(change, after.path, "added")),
+    ...outcome.reformed.map(
+      (pair) =>
+        `${before.path}:${String(pair.before.line)} → ${after.path}:${String(pair.after.line)}: reformed ${pair.before.kind} ${shown(pair.before.text)} → ${shown(pair.after.text)}`,
+    ),
+    ...before.unread.map((unread) => `${before.path}: unread ${unread.kind} (${unread.reason})`),
+    ...after.unread.map((unread) => `${after.path}: unread ${unread.kind} (${unread.reason})`),
+    checkedLine(outcome, text),
+    text.tally(failing(outcome.dropped), failing(outcome.added), outcome.reformed.length),
+  ].join("\n");
+};
+
+const atomJson = (atom: Atom): Readonly<Record<string, string | number>> => ({ kind: atom.kind, key: atom.key, text: atom.text, line: atom.line });
+
+/** For an AI to act on: every dropped and added fact with its line, the reformed pairs, and the counts per kind. */
+export const renderJson = (outcome: Outcome): string =>
+  JSON.stringify(
+    {
+      ok: outcome.ok,
+      before: outcome.before,
+      after: outcome.after,
+      dropped: outcome.dropped.map((change) => ({ ...atomJson(change), allowed: change.allowed })),
+      added: outcome.added.map((change) => ({ ...atomJson(change), allowed: change.allowed })),
+      reformed: outcome.reformed.map((pair) => ({ kind: pair.before.kind, key: pair.before.key, before: atomJson(pair.before), after: atomJson(pair.after) })),
+    },
+    null,
+    2,
+  );

package/src/compare/spans.ts

@@ -0,0 +1,17 @@
+import type { Span } from "../plugin.ts";
+import { firstEndingAfter } from "../soft-break.ts";
+import { mergeSpans } from "../span-merge.ts";
+
+/** Spans made ready for lookups: sorted and merged, so each lookup is a binary search, not a scan of every span. */
+export type SpanIndex = readonly Span[];
+
+export const spanIndex = (spans: readonly Span[]): SpanIndex => mergeSpans(spans, false);
+
+/** Whether span shares at least one character with a span in the index. */
+export const overlapsAny = (index: SpanIndex, span: Span): boolean => {
+  const region = index[firstEndingAfter(index, span.start)];
+  return region !== undefined && region.start < span.end;
+};
+
+/** Whether the character at offset is inside a span in the index. */
+export const coversOffset = (index: SpanIndex, offset: number): boolean => overlapsAny(index, { start: offset, end: offset + 1 });

package/src/compare/text-atoms.ts

@@ -0,0 +1,95 @@
+import { QUOTATION_MARKS, quotedSpans } from "../quoted-span.ts";
+import type { Span } from "../plugin.ts";
+import type { Atom } from "./atom.ts";
+import { coversOffset, overlapsAny, spanIndex, type SpanIndex } from "./spans.ts";
+
+/** Where a reader looks, and how it says where it found something. */
+export type TextInput = { readonly text: string; readonly source: string; readonly lineOf: (offset: number) => number };
+
+/** A fact found in the text: where it is and its key. */
+export type Found = Span & { readonly key: string };
+
+export const atomsOf = (found: readonly Found[], kind: Atom["kind"], input: TextInput): Atom[] =>
+  found.map((fact) => ({ kind, key: fact.key, text: input.source.slice(fact.start, fact.end), line: input.lineOf(fact.start) }));
+
+const DIGIT = "[0-9０-９]";
+const DATE_SEPARATOR = "[-/.／．]";
+
+/** 2026/4/1, 2026-04-01, 2026.4.1: a year of four digits first, so the order is never in doubt. */
+const NUMERIC_DATE = new RegExp(`(?<![0-9０-９])(${DIGIT}{4})${DATE_SEPARATOR}(${DIGIT}{1,2})${DATE_SEPARATOR}(${DIGIT}{1,2})(?![0-9０-９])`, "gu");
+
+const MONTHS = 12;
+const LAST_DAY = 31;
+const PADDED = 2;
+
+const dateKey = (year: string, month: string, day: string): string | undefined => {
+  const [m, d] = [Number(month.normalize("NFKC")), Number(day.normalize("NFKC"))];
+  if (m < 1 || m > MONTHS || d < 1 || d > LAST_DAY) return undefined;
+  return [year.normalize("NFKC"), String(m).padStart(PADDED, "0"), String(d).padStart(PADDED, "0")].join("-");
+};
+
+/** Dates written in figures only, where the language's date reader did not already read a date. */
+export const numericDates = (text: string, taken: SpanIndex): Found[] =>
+  [...text.matchAll(NUMERIC_DATE)].flatMap((match) => {
+    const key = dateKey(match[1] ?? "", match[2] ?? "", match[3] ?? "");
+    const span = { start: match.index, end: match.index + match[0].length };
+    return key === undefined || overlapsAny(taken, span) ? [] : [{ ...span, key }];
+  });
+
+/** A footnote mark `[^1]`, or the footnote itself `[^1]:`. */
+const FOOTNOTE = /\[\^[^\]\s]+\]:?/gu;
+
+export const footnotes = (text: string): Found[] =>
+  [...text.matchAll(FOOTNOTE)].map((match) => ({ start: match.index, end: match.index + match[0].length, key: match[0] }));
+
+/** 1,200 or 12.5 or ３: the digits, a thousands separator only between groups of three, and a decimal part. */
+const NUMBER = /[0-9０-９]+(?:[,，][0-9０-９]{3})*(?:[.．][0-9０-９]+)?/gu;
+
+const valueOf = (written: string): string => String(Number(written.normalize("NFKC").replace(/,/gu, "")));
+
+/** Numbers no other reader took: written with no unit the language package knows, or with none at all. */
+export const bareNumbers = (input: TextInput, taken: SpanIndex): Atom[] =>
+  [...input.text.matchAll(NUMBER)].flatMap((match): Atom[] => {
+    if (coversOffset(taken, match.index)) return [];
+    const value = valueOf(match[0]);
+    return [{ kind: "number", key: `${value} `, text: match[0], line: input.lineOf(match.index), unitless: true, value }];
+  });
+
+/** A paragraph break: a quotation does not run over one, and reading paragraph by paragraph keeps each read short. */
+const PARAGRAPH_BREAK = /\n[ \t]*\n/gu;
+
+const paragraphsOf = (text: string): Span[] => {
+  const breaks = [...text.matchAll(PARAGRAPH_BREAK)].map((match) => match.index);
+  return [-1, ...breaks].map((from, index) => ({ start: from + 1, end: breaks[index] ?? text.length }));
+};
+
+/** What is quoted, as one spelling: line breaks and runs of spaces are how it was wrapped, not what it says. */
+const quoteKey = (inner: string): string => inner.normalize("NFKC").replace(/\s+/gu, " ").trim();
+
+/** Quoted strings: 「」『』, “” and "". The key is what is inside; the marks are how it is written. */
+export const quotations = (input: TextInput): Atom[] =>
+  paragraphsOf(input.text).flatMap((paragraph) =>
+    quotedSpans(input.text.slice(paragraph.start, paragraph.end), QUOTATION_MARKS).flatMap((inner) => {
+      const key = quoteKey(input.text.slice(paragraph.start + inner.start, paragraph.start + inner.end));
+      const span = { start: paragraph.start + inner.start - 1, end: paragraph.start + inner.end + 1 };
+      return key === "" ? [] : atomsOf([{ ...span, key }], "quote", input);
+    }),
+  );
+
+const occurrences = (text: string, name: string): Span[] => {
+  const found: Span[] = [];
+  for (let at = text.indexOf(name); at !== -1; at = text.indexOf(name, at + name.length)) found.push({ start: at, end: at + name.length });
+  return found;
+};
+
+/** The team's own names (chaff.yaml's `names:`), wherever they are written. Longer names first: "Acme Cloud" before "Acme". */
+export const teamNames = (text: string, names: readonly string[]): Found[] => {
+  const longestFirst = [...new Set(names.filter((name) => name !== ""))].toSorted((left, right) => right.length - left.length);
+  return longestFirst
+    .reduce<Found[]>((taken, name) => {
+      const index = spanIndex(taken);
+      const fresh = occurrences(text, name).filter((span) => !overlapsAny(index, span));
+      return [...taken, ...fresh.map((span) => ({ ...span, key: name }))];
+    }, [])
+    .toSorted((left, right) => left.start - right.start);
+};

package/src/compare/text.ts

@@ -0,0 +1,120 @@
+import type { Texts } from "../ui.ts";
+import type { AtomKind, UnreadReason } from "./atom.ts";
+import { counted } from "../render/plural.ts";
+
+export type CompareText = {
+  readonly usage: string;
+  readonly unknownKind: (kind: string, kinds: string) => string;
+  /** A kind counted (numbers 3→3) and a kind of one fact (number: 1,000円). */
+  readonly kinds: Readonly<Record<AtomKind, string>>;
+  readonly kind: Readonly<Record<AtomKind, string>>;
+  readonly unread: (kind: AtomKind, reason: UnreadReason) => string;
+  readonly unreadHeading: string;
+  readonly droppedHeading: (count: number, before: string, after: string) => string;
+  readonly addedHeading: (count: number, after: string) => string;
+  readonly reformedHeading: (count: number) => string;
+  readonly allowed: (flag: string) => string;
+  readonly lines: (before: number, after: number) => string;
+  readonly checked: (before: number, after: number, perKind: string) => string;
+  readonly separator: string;
+  readonly clean: string;
+  readonly failed: (dropped: number, added: number) => string;
+  /** The tally of the compact output. */
+  readonly tally: (dropped: number, added: number, reformed: number) => string;
+};
+
+const KINDS_JA: Readonly<Record<AtomKind, string>> = {
+  number: "数",
+  date: "日付",
+  time: "時刻",
+  url: "URL",
+  code: "コード",
+  name: "固有名詞",
+  quote: "引用",
+  heading: "見出し",
+  reference: "条項の参照",
+  footnote: "脚注",
+};
+
+const KINDS_EN: Readonly<Record<AtomKind, string>> = {
+  number: "numbers",
+  date: "dates",
+  time: "times",
+  url: "URLs",
+  code: "code",
+  name: "names",
+  quote: "quotations",
+  heading: "headings",
+  reference: "references",
+  footnote: "footnotes",
+};
+
+const KIND_EN: Readonly<Record<AtomKind, string>> = {
+  number: "number",
+  date: "date",
+  time: "time",
+  url: "URL",
+  code: "code",
+  name: "name",
+  quote: "quotation",
+  heading: "heading",
+  reference: "reference",
+  footnote: "footnote",
+};
+
+const UNREAD_JA: Readonly<Record<UnreadReason, (kind: AtomKind) => string>> = {
+  "no-structure": (kind) =>
+    kind === "number" ? "言語パッケージが単位を読まないので、数字だけを比べました" : "言語パッケージが文書の構造を読まないので、読んでいません",
+  "no-dates": () => "言語パッケージが日付を読まないので、数字だけで書いた日付（2026-04-01）だけを比べました",
+  "no-pos": () => "品詞を読む解析器が無いので、chaff.yaml の names: だけを比べました",
+  "plain-text": () => "Markdown ではないので、コードの記法がありません",
+};
+
+const UNREAD_EN: Readonly<Record<UnreadReason, (kind: AtomKind) => string>> = {
+  "no-structure": (kind) =>
+    kind === "number"
+      ? "the language package reads no units, so only the figures were compared"
+      : "the language package reads no document structure, so none were read",
+  "no-dates": () => "the language package reads no dates, so only dates written in figures (2026-04-01) were compared",
+  "no-pos": () => "there is no part-of-speech tagger, so only chaff.yaml's names: were compared",
+  "plain-text": () => "the document is not Markdown, so it has no code markup",
+};
+
+export const COMPARE_TEXT: Texts<CompareText> = {
+  ja: {
+    usage: "使い方: chaff compare <書き換える前> <書き換えた後> [--compact | --json] [--allow-dropped <種類>] [--allow-added <種類>] [--language ja|en|…]",
+    unknownKind: (kind, kinds) => `知らない種類です: ${kind}（使えるのは ${kinds}）`,
+    kinds: KINDS_JA,
+    kind: KINDS_JA,
+    unread: (kind, reason) => `${KINDS_JA[kind]}: ${UNREAD_JA[reason](kind)}`,
+    unreadHeading: "読めなかったもの",
+    droppedHeading: (count, before, after) => `✗ 落ちた事実 ${String(count)} 件（${before} にあって ${after} に無い）`,
+    addedHeading: (count, after) => `✗ 足された事実 ${String(count)} 件（${after} にだけある）`,
+    reformedHeading: (count) => `i 書き方だけ変わった事実 ${String(count)} 件`,
+    allowed: (flag) => `（${flag} で許可）`,
+    lines: (before, after) => `${String(before)} 行目 → ${String(after)} 行目`,
+    checked: (before, after, perKind) => `照合した事実 ${String(before)} 件 → ${String(after)} 件: ${perKind}`,
+    separator: "、",
+    clean: "落ちた事実も足された事実もありません",
+    failed: (dropped, added) => `落ちた事実 ${String(dropped)} 件、足された事実 ${String(added)} 件`,
+    tally: (dropped, added, reformed) => `落ちた ${String(dropped)} 件、足された ${String(added)} 件、書き方だけ ${String(reformed)} 件`,
+  },
+  en: {
+    usage: "usage: chaff compare <before> <after> [--compact | --json] [--allow-dropped <kind>] [--allow-added <kind>] [--language ja|en|…]",
+    unknownKind: (kind, kinds) => `Unknown kind: ${kind} (the kinds are ${kinds})`,
+    kinds: KINDS_EN,
+    kind: KIND_EN,
+    unread: (kind, reason) => `${KINDS_EN[kind]}: ${UNREAD_EN[reason](kind)}`,
+    unreadHeading: "Not fully read",
+    droppedHeading: (count, before, after) => `✗ ${counted(count, "fact")} dropped (in ${before}, not in ${after})`,
+    addedHeading: (count, after) => `✗ ${counted(count, "fact")} added (only in ${after})`,
+    reformedHeading: (count) => `i ${counted(count, "fact")} written another way`,
+    allowed: (flag) => ` (allowed by ${flag})`,
+    lines: (before, after) => `line ${String(before)} → line ${String(after)}`,
+    checked: (before, after, perKind) => `Facts checked: ${String(before)} → ${String(after)}: ${perKind}`,
+    separator: ", ",
+    clean: "No fact dropped or added",
+    failed: (dropped, added) => `${counted(dropped, "fact")} dropped, ${counted(added, "fact")} added`,
+    tally: (dropped, added, reformed) => `${String(dropped)} dropped, ${String(added)} added, ${String(reformed)} written another way`,
+  },
+};

package/src/compare/tree-atoms.ts

@@ -0,0 +1,80 @@
+import { preOrder } from "../tree-walk.ts";
+import type { Span, StructureNode } from "../plugin.ts";
+import type { Atom, AtomKind } from "./atom.ts";
+import { coversOffset, overlapsAny, type SpanIndex } from "./spans.ts";
+
+/** Facts the structure reader found, and where they are written, so no other reader reads the same digits again. */
+export type TreeFacts = { readonly atoms: readonly Atom[]; readonly taken: readonly Span[] };
+
+export type TreeInput = {
+  readonly tree: StructureNode;
+  readonly source: string;
+  /** Code and URLs: what the reader found there belongs to them. */
+  readonly blanked: SpanIndex;
+  /** Times of day: 3時30分 is one time, not the quantities 3 時 and 30 分. */
+  readonly times: SpanIndex;
+  readonly lineOf: (offset: number) => number;
+};
+
+/** Numbered units that are the document's own structure. Items (a list's 1. 2. 3.) are left out: prose may replace a list. */
+const NUMBERED: ReadonlySet<string> = new Set(["chapter", "article"]);
+
+const attr = (node: StructureNode, name: string): string => String(node.attrs[name] ?? "");
+
+/** The unit as one spelling: ＧＢ and GB, ％ and % are one unit. */
+const unitKey = (unit: string): string => unit.normalize("NFKC");
+
+const quantityAtom = (node: StructureNode, text: string, line: number): Atom => {
+  const value = attr(node, "value");
+  return { kind: "number", key: `${value} ${unitKey(attr(node, "unit"))}`, text, line, value };
+};
+
+/** The same section in another wording: Section 4.2 and § 4.2 point at one place; Article 4.2 does not. */
+const referenceKey = (node: StructureNode): string => {
+  const numbering = attr(node, "numbering") || attr(node, "unitWord");
+  const document = attr(node, "document");
+  return [numbering, attr(node, "target"), document === "" ? "" : `@${document}`].filter((part) => part !== "").join(" ");
+};
+
+const leafAtom = (node: StructureNode, kind: AtomKind, text: string, line: number): Atom => {
+  if (kind === "number") return quantityAtom(node, text, line);
+  return { kind, key: kind === "date" ? attr(node, "value") : referenceKey(node), text, line };
+};
+
+const LEAF_KINDS: Readonly<Partial<Record<string, AtomKind>>> = { quantity: "number", date: "date", reference: "reference" };
+
+/** The label's place on its line (第3条 after "## "), or none when the line does not spell it. */
+const labelSpan = (node: StructureNode, source: string): Span[] => {
+  const label = attr(node, "label");
+  const lineEnd = source.indexOf("\n", node.span.start);
+  const at = source.indexOf(label, node.span.start);
+  return label === "" || at === -1 || (lineEnd !== -1 && at > lineEnd) ? [] : [{ start: at, end: at + label.length }];
+};
+
+const numberedFacts = (node: StructureNode, input: TreeInput): TreeFacts => {
+  const heading = attr(node, "heading");
+  const text = [attr(node, "label"), heading].filter((part) => part !== "").join(" ");
+  return { atoms: [{ kind: "heading", key: `${node.kind} ${node.address}`, text, line: node.line }], taken: labelSpan(node, input.source) };
+};
+
+const nodeFacts = (node: StructureNode, input: TreeInput): TreeFacts => {
+  if (NUMBERED.has(node.kind)) return numberedFacts(node, input);
+  const kind = LEAF_KINDS[node.kind];
+  if (kind === undefined || coversOffset(input.blanked, node.span.start)) return { atoms: [], taken: [] };
+  if (kind === "number" && overlapsAny(input.times, node.span)) return { atoms: [], taken: [] };
+  const span = withUnitAfter(node, input.source);
+  const text = input.source.slice(span.start, span.end);
+  return { atoms: [leafAtom(node, kind, text, input.lineOf(span.start))], taken: [span] };
+};
+
+/** A quantity's span may stop before the unit written right after it (25 of 25%); the fact is shown with its unit. */
+const withUnitAfter = (node: StructureNode, source: string): Span => {
+  const unit = attr(node, "unit");
+  return unit !== "" && source.startsWith(unit, node.span.end) ? { start: node.span.start, end: node.span.end + unit.length } : node.span;
+};
+
+/** Numbers with their unit, dates, references to articles and sections, and the numbered articles themselves. */
+export const treeFacts = (input: TreeInput): TreeFacts => {
+  const facts = preOrder(input.tree).map((node) => nodeFacts(node, input));
+  return { atoms: facts.flatMap((fact) => fact.atoms), taken: facts.flatMap((fact) => fact.taken) };
+};

package/src/compare/written-names.ts

@@ -0,0 +1,26 @@
+import type { Atom } from "./atom.ts";
+
+const occurrences = (text: string, needle: string): number => {
+  let count = 0;
+  for (let at = text.indexOf(needle); at !== -1 && needle !== ""; at = text.indexOf(needle, at + needle.length)) count += 1;
+  return count;
+};
+
+const namesPerKey = (atoms: readonly Atom[]): Map<string, number> =>
+  atoms.reduce((counts, atom) => (atom.kind === "name" ? counts.set(atom.key, (counts.get(atom.key) ?? 0) + 1) : counts), new Map<string, number>());
+
+/**
+ * The names among changes that the other document does not write as often as this one names them. The tagger reads
+ * a word as a name by its context (赤松 after から, Scammers before could), so a rewrite can change the tagging without
+ * changing the name; the spelling decides. otherText is the other document's prose spelled as name keys are.
+ */
+export const unwrittenNames = (changes: readonly Atom[], own: readonly Atom[], otherText: string): Atom[] => {
+  const named = namesPerKey(own);
+  const left = new Map<string, number>();
+  return changes.filter((atom) => {
+    if (atom.kind !== "name") return true;
+    const remaining = left.get(atom.key) ?? Math.max(0, (named.get(atom.key) ?? 0) - occurrences(otherText, atom.key));
+    left.set(atom.key, Math.max(0, remaining - 1));
+    return remaining > 0;
+  });
+};

package/src/config/load.ts

@@ -37,6 +37,22 @@ export type Config = {
   /** パスごとの上書き。設定ファイルのある場所からの相対で照合する。 */
   readonly byPath: readonly PathRule[];
   readonly baseDir: string;
+  /** Options set on rules that take them: { rule id: { option: value } }, as written. rule-options.ts checks them against the rules. */
+  readonly options?: Readonly<Record<string, unknown>>;
+  /** options as written when it is not a map. Dropping it silently would leave a team thinking its options apply. */
+  readonly unreadableOptions?: string | undefined;
+  /** The house style chaff.yaml names (styles/*.yaml), as written. A value that is not a name is kept printed, to be reported. */
+  readonly style?: string | undefined;
+  /** The style once applied (config/style.ts): its id, the rules whose level it decided, and its options. */
+  readonly applied?: AppliedStyle | undefined;
+  /** custom_rules as written: the team's own rules. custom/parse.ts reads and checks them. */
+  readonly customRules?: unknown;
+};
+
+export type AppliedStyle = {
+  readonly style: string;
+  readonly levelsFrom: readonly string[];
+  readonly options: Readonly<Record<string, unknown>>;
 };
 
 /** 判定の質が誤検知に直結するので、既定は最上位のモデル。cost は絞り込みで削る。spec §14。 */
@@ -144,6 +160,7 @@ export const loadConfig = (path: string): Config => {
   const declared: unknown = raw["ai_backend"];
   const backend: BackendName = isBackend(declared) ? declared : DEFAULT_BACKEND;
   const names = namesOf(raw["names"]);
+  const options: unknown = raw["options"];
   return {
     genre: str(raw["genre"]),
     profile: str(raw["profile"]),
@@ -163,5 +180,9 @@ export const loadConfig = (path: string): Config => {
     unreadableNames: names.unreadable,
     byPath: byPathOf(raw["by_path"]),
     baseDir: dirname(path),
+    options: isRecord(options) ? options : {},
+    unreadableOptions: options === undefined || options === null || isRecord(options) ? undefined : printed(options),
+    style: raw["style"] === undefined || raw["style"] === null ? undefined : (str(raw["style"]) ?? printed(raw["style"])),
+    customRules: raw["custom_rules"],
   };
 };

package/src/config/option-problems.ts

@@ -0,0 +1,70 @@
+import { CONFIG_FILE, type Config } from "./load.ts";
+import type { RuleDefinition, RuleOption } from "../plugin.ts";
+import { optionProblems, type OptionLayer, type OptionProblem } from "../rule-options.ts";
+import { styleLevelSource, styleSource } from "./style.ts";
+import type { Texts, UiLanguage } from "../ui.ts";
+
+/** Where chaff.yaml's options come from, for settleOptions: the file itself. */
+export const configOptionLayer = (config: Pick<Config, "options">): OptionLayer => ({
+  from: CONFIG_FILE,
+  values: config.options ?? {},
+});
+
+/** Where a rule's settings come from, for explain: the option layers, and the style when it set the level. */
+export const settingSourcesOf = (
+  config: Pick<Config, "options" | "applied">,
+  ruleId: string,
+): { optionLayers: OptionLayer[]; levelFrom: string | undefined } => ({
+  optionLayers: optionLayersOf(config),
+  levelFrom: styleLevelSource(config, ruleId),
+});
+
+/** Every place options come from, strongest first: chaff.yaml, then its style. */
+export const optionLayersOf = (config: Pick<Config, "options" | "applied">): OptionLayer[] => [
+  configOptionLayer(config),
+  ...(config.applied === undefined ? [] : [{ from: styleSource(config.applied.style), values: config.applied.options }]),
+];
+
+type ProblemText = {
+  readonly notAMap: (where: string, value: string) => string;
+  readonly problem: (where: string, problem: OptionProblem) => string;
+};
+
+const TEXT: Texts<ProblemText> = {
+  ja: {
+    notAMap: (where, value) => `${where}: options の ${value} は読めません。ルールの名前の下に、オプションの名前と値を並べてください`,
+    problem: (where, problem) => {
+      if (problem.kind === "unknown-rule") return `${where}: options の ${problem.rule} というルールはありません（npx chaff rules --json で一覧が出ます）`;
+      if (problem.kind === "no-options") return `${where}: ${problem.rule} にはオプションがありません。options に書いても何も変わりません`;
+      if (problem.kind === "not-a-map") return `${where}: options の ${problem.rule} の下には、オプションの名前と値を並べてください`;
+      if (problem.kind === "unknown-option")
+        return `${where}: ${problem.rule} に ${problem.option} というオプションはありません（使えるのは ${problem.known.join(" / ")}）`;
+      return `${where}: ${problem.rule} の ${problem.option} の値 ${problem.value} は読めません（${problem.expected}）。既定のまま動きます`;
+    },
+  },
+  en: {
+    notAMap: (where, value) => `${where}: cannot read ${value} under options. Under each rule's name, list option names and values`,
+    problem: (where, problem) => {
+      if (problem.kind === "unknown-rule") return `${where}: there is no rule named ${problem.rule} under options (npx chaff rules --json lists them)`;
+      if (problem.kind === "no-options") return `${where}: ${problem.rule} takes no options, so writing some changes nothing`;
+      if (problem.kind === "not-a-map") return `${where}: under options, ${problem.rule} needs option names and values`;
+      if (problem.kind === "unknown-option") return `${where}: ${problem.rule} has no option ${problem.option} (it takes ${problem.known.join(" / ")})`;
+      return `${where}: cannot read ${problem.value} as ${problem.rule}'s ${problem.option} (${problem.expected}); it stays at its default`;
+    },
+  },
+};
+
+const optionsByRule = (rules: readonly RuleDefinition[]): Record<string, Readonly<Record<string, RuleOption>>> =>
+  Object.fromEntries(rules.map((rule) => [rule.id, rule.options ?? {}]));
+
+/** chaff.yaml's options that change nothing. Said on every run, like an unknown rule under rules: silence would look like it applied. */
+export const configOptionProblems = (
+  config: Pick<Config, "options" | "unreadableOptions" | "path">,
+  rules: readonly RuleDefinition[],
+  ui: UiLanguage,
+): string[] => {
+  const text = TEXT[ui];
+  const where = config.path ?? "chaff.yaml";
+  if (config.unreadableOptions !== undefined) return [text.notAMap(where, config.unreadableOptions)];
+  return optionProblems(configOptionLayer(config), optionsByRule(rules)).map((problem) => text.problem(where, problem));
+};

package/src/config/read.ts

@@ -0,0 +1,8 @@
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { CONFIG_FILE, EMPTY, loadConfig, type Config } from "./load.ts";
+import { withStyle } from "./style.ts";
+import { loadStyles } from "../style-load.ts";
+
+/** The chaff.yaml in dir with its style applied, or the defaults when there is none. */
+export const readConfigIn = (dir: string): Config => (existsSync(join(dir, CONFIG_FILE)) ? withStyle(loadConfig(join(dir, CONFIG_FILE)), loadStyles()) : EMPTY);

package/src/config/rule-problems.ts

@@ -1,21 +1,27 @@
 import type { Config } from "./load.ts";
+import type { RuleDefinition } from "../plugin.ts";
 import type { Texts, UiLanguage } from "../ui.ts";
 
 const TEXT: Texts<{
   readonly unknown: (where: string, id: string) => string;
   readonly unreadable: (where: string, id: string, value: string) => string;
   readonly numberOnSemantic: (where: string, id: string) => string;
+  readonly numberOnSeverity: (where: string, id: string) => string;
 }> = {
   ja: {
     unknown: (where, id) => `${where}: ${id} というルールはありません（npx chaff rules --json で一覧が出ます）`,
     unreadable: (where, id, value) => `${where}: ${id} の値 ${value} は読めません（strict / normal / relaxed / off か、正の数）`,
     numberOnSemantic: (where, id) =>
       `${where}: ${id} は意味を読む検査なので数値の上限はありません。normal として動きます（strict / normal / relaxed / off で書いてください）`,
+    numberOnSeverity: (where, id) =>
+      `${where}: ${id} には数の上限がありません。normal として動きます（段階は指摘の重さを変えます。relaxed で一段軽く、off で止まります）`,
   },
   en: {
     unknown: (where, id) => `${where}: there is no rule named ${id} (npx chaff rules --json lists them)`,
     unreadable: (where, id, value) => `${where}: cannot read ${value} as the level of ${id} (strict / normal / relaxed / off, or a positive number)`,
     numberOnSemantic: (where, id) => `${where}: ${id} reads meaning and has no numeric limit; it runs as normal (write strict / normal / relaxed / off)`,
+    numberOnSeverity: (where, id) =>
+      `${where}: ${id} has no numeric limit; it runs as normal (its levels set how a finding is marked: relaxed lowers it a step, off stops it)`,
   },
 };
 
@@ -25,7 +31,7 @@ const TEXT: Texts<{
  */
 export const ruleProblems = (
   config: Pick<Config, "rules" | "limits" | "unreadableRules" | "path">,
-  known: readonly { readonly id: string; readonly layer: string }[],
+  known: readonly Pick<RuleDefinition, "id" | "layer" | "level_sets">[],
   ui: UiLanguage = "ja",
 ): string[] => {
   const text = TEXT[ui];
@@ -39,5 +45,9 @@ export const ruleProblems = (
   const numberOnSemantic = Object.keys(config.limits)
     .filter((id) => semantic.has(id))
     .map((id) => text.numberOnSemantic(where, id));
-  return [...unknown, ...unreadable, ...numberOnSemantic];
+  const nothingToCount = new Set(known.filter((rule) => rule.layer !== "L4" && rule.level_sets === "severity").map((rule) => rule.id));
+  const numberOnSeverity = Object.keys(config.limits)
+    .filter((id) => nothingToCount.has(id))
+    .map((id) => text.numberOnSeverity(where, id));
+  return [...unknown, ...unreadable, ...numberOnSemantic, ...numberOnSeverity];
 };