chaffjs 0.18.0 → 0.20.0

package/src/compare/fact-key.ts

@@ -0,0 +1,31 @@
+import { spansWithin, withoutSpans } from "../soft-break.ts";
+import type { Span } from "../plugin.ts";
+
+/**
+ * The text of a span as one spelling: what a reader never sees removed (unseen is sorted and does not overlap: a line
+ * break that vanishes between two wide characters, the marks of bold), any other run of white space one space,
+ * full-width and half-width forms alike.
+ */
+export const factKey = (text: string, span: Span, unseen: readonly Span[]): string => {
+  const inside = spansWithin(unseen, span).map((part) => ({ start: part.start - span.start, end: part.end - span.start }));
+  return withoutSpans(text.slice(span.start, span.end), inside).normalize("NFKC").replace(/\s+/gu, " ");
+};
+
+/** A text without its unseen parts, and where each of its characters stands in the whole text. */
+export type SeenText = { readonly text: string; readonly offsets: readonly number[] };
+
+/** The text as a reader sees it, for finding words that a vanishing line break or bold marks split (日本\n銀行). */
+export const seenTextOf = (text: string, unseen: readonly Span[]): SeenText => {
+  const kept = [...unseen, { start: text.length, end: text.length }].map((part, index) => ({ start: unseen[index - 1]?.end ?? 0, end: part.start }));
+  return {
+    text: kept.map((part) => text.slice(part.start, part.end)).join(""),
+    offsets: kept.flatMap((part) => Array.from({ length: part.end - part.start }, (_, index) => part.start + index)),
+  };
+};
+
+/** A span found in the seen text, as a span of the whole text: from its first character to just after its last. */
+export const wholeSpanOf = <T extends Span>(seen: SeenText, found: T): T => ({
+  ...found,
+  start: seen.offsets[found.start] ?? found.start,
+  end: (seen.offsets[found.end - 1] ?? found.end - 1) + 1,
+});

package/src/compare/fact-text.ts

@@ -1,8 +1,9 @@
 import { bareUrls, type BareUrl } from "../bare-url.ts";
-import { linkChrome } from "../document.ts";
+import { emphasisSpans, linkChrome } from "../document.ts";
 import { opaqueSpans } from "../markdown-read.ts";
 import { spanOf, type MarkdownNode } from "../markdown-node.ts";
 import { maskSpans } from "../mask.ts";
+import { unmaskedSoftBreaks } from "../soft-break.ts";
 import { eachPreOrder } from "../tree-walk.ts";
 import type { Span } from "../plugin.ts";
 import { overlapsAny, spanIndex, type SpanIndex } from "./spans.ts";
@@ -22,6 +23,11 @@ export type FactText = {
   readonly bareUrls: readonly BareUrl[];
   /** Ordered-list markers (`1.`): they number the list, they do not state a number. */
   readonly listMarkers: readonly Span[];
+  /**
+   * What a reader of the rendered Markdown never sees, sorted: a line break between two wide characters (「系の\nシステム」)
+   * and the marks of bold. A plain-text document shows its line breaks, so it has none.
+   */
+  readonly unseen: readonly Span[];
 };
 
 /** Nodes whose whole span is not read as prose: a link reference definition's URL is read as a URL, an image is not text. */
@@ -55,6 +61,18 @@ const markdownParts = (root: MarkdownNode, source: string): MarkdownParts => {
   return parts;
 };
 
+/**
+ * Line breaks are read the way the rules read them: one next to blanked code or a link's marks is kept. Bold marks are
+ * read through, as a reader does not see them: 「系の\n**システム**」 joins too. The break and the marks may touch, so the
+ * spans are merged.
+ */
+const unseenOf = (source: string, text: string, root: MarkdownNode | undefined): readonly Span[] => {
+  if (root === undefined) return [];
+  const emphasis = emphasisSpans(root, source);
+  const breaks = unmaskedSoftBreaks(maskSpans(source, emphasis), maskSpans(text, emphasis));
+  return spanIndex([...breaks, ...emphasis]);
+};
+
 /** root is the Markdown tree, or undefined for a plain-text document, where nothing is code and URLs are bare. */
 export const factTextOf = (source: string, root: MarkdownNode | undefined): FactText => {
   const code = root === undefined ? [] : opaqueSpans(root);
@@ -64,5 +82,6 @@ export const factTextOf = (source: string, root: MarkdownNode | undefined): Fact
   // An autolink's text is its URL: it is read once, as the link.
   const bare = bareUrls(codeless).filter((url) => !overlapsAny(insideLinks, url));
   const blanked = [...code, ...parts.chrome, ...bare];
-  return { text: maskSpans(source, blanked), codeless, blanked: spanIndex(blanked), bareUrls: bare, listMarkers: parts.listMarkers };
+  const text = maskSpans(source, blanked);
+  return { text, codeless, blanked: spanIndex(blanked), bareUrls: bare, listMarkers: parts.listMarkers, unseen: unseenOf(source, text, root) };
 };

package/src/compare/facts-render.ts

@@ -0,0 +1,63 @@
+import { ATOM_KINDS, type Atom, type AtomKind, type Extraction, type Unread } from "./atom.ts";
+import { countsOf } from "./outcome.ts";
+import { atomJson, shown } from "./render.ts";
+import type { FactsText } from "./facts-text.ts";
+
+/** One document's facts as `chaff facts` lists them. */
+export type FactList = { readonly path: string; readonly language: string; readonly extraction: Extraction };
+
+/** Kind by kind in compare's order, and within a kind in the order the document states them. */
+export const inChecklistOrder = (atoms: readonly Atom[]): Atom[] =>
+  atoms.toSorted((left, right) => ATOM_KINDS.indexOf(left.kind) - ATOM_KINDS.indexOf(right.kind) || left.line - right.line);
+
+/** Every kind with its count, zeros too: an empty kind reads as "none stated", never as "not looked at". */
+const perKind = (atoms: readonly Atom[], text: FactsText): string => {
+  const counts = countsOf(atoms);
+  return ATOM_KINDS.map((kind) => text.kindCount(text.kinds[kind], counts[kind])).join(text.separator);
+};
+
+const title = (list: FactList, text: FactsText): string => text.title(list.path, list.extraction.atoms.length, perKind(list.extraction.atoms, text));
+
+const checklistLine = (atom: Atom, path: string): string => `  - [ ] ${shown(atom.text)}  (${path}:${String(atom.line)})`;
+
+const kindBlock = (ordered: readonly Atom[], kind: AtomKind, path: string, text: FactsText): string[] => {
+  const ofKind = ordered.filter((atom) => atom.kind === kind);
+  return ofKind.length === 0 ? [] : ["", text.kindHeading(text.kinds[kind], ofKind.length), ...ofKind.map((atom) => checklistLine(atom, path))];
+};
+
+const unreadBlock = (unread: readonly Unread[], text: FactsText): string[] =>
+  unread.length === 0 ? [] : ["", text.unreadHeading, ...unread.map((entry) => `  ${text.unread(entry.kind, entry.reason)}`)];
+
+/** For a person or an AI about to rewrite: a checklist per kind, with the line each fact is on. */
+export const renderFactsFriendly = (list: FactList, text: FactsText): string => {
+  const ordered = inChecklistOrder(list.extraction.atoms);
+  return [
+    title(list, text),
+    ...ATOM_KINDS.flatMap((kind) => kindBlock(ordered, kind, list.path, text)),
+    ...unreadBlock(list.extraction.unread, text),
+    "",
+    text.next(list.path),
+  ].join("\n");
+};
+
+/** For grep: one fact per line with the kind in English, then what was not read, then the counts. */
+export const renderFactsCompact = (list: FactList, text: FactsText): string =>
+  [
+    ...inChecklistOrder(list.extraction.atoms).map((atom) => `${list.path}:${String(atom.line)}: ${atom.kind} ${shown(atom.text)}`),
+    ...list.extraction.unread.map((entry) => `${list.path}: unread ${entry.kind} (${entry.reason})`),
+    title(list, text),
+  ].join("\n");
+
+/** For an AI to keep as its inventory: every fact with its kind, key, text and line, and the counts per kind. */
+export const renderFactsJson = (list: FactList): string =>
+  JSON.stringify(
+    {
+      path: list.path,
+      language: list.language,
+      counts: countsOf(list.extraction.atoms),
+      unread: list.extraction.unread,
+      facts: inChecklistOrder(list.extraction.atoms).map(atomJson),
+    },
+    null,
+    2,
+  );

package/src/compare/facts-text.ts

@@ -0,0 +1,41 @@
+import type { Texts } from "../ui.ts";
+import { counted } from "../render/plural.ts";
+import { COMPARE_TEXT, type CompareText } from "./text.ts";
+
+/** What `chaff facts` says. The names of the kinds and the reasons a kind was not read are compare's own. */
+export type FactsText = Pick<CompareText, "kinds" | "unread" | "unreadHeading" | "separator"> & {
+  readonly usage: string;
+  /** The first line: the file, how many facts, and the count per kind. */
+  readonly title: (path: string, total: number, perKind: string) => string;
+  readonly kindHeading: (kindName: string, count: number) => string;
+  /** How a kind is counted in the first line (数 12 / numbers 12). */
+  readonly kindCount: (kindName: string, count: number) => string;
+  /** The last line: the command that checks a rewrite against this list. */
+  readonly next: (path: string) => string;
+};
+
+const shared = (text: CompareText): Pick<CompareText, "kinds" | "unread" | "unreadHeading" | "separator"> => ({
+  kinds: text.kinds,
+  unread: text.unread,
+  unreadHeading: text.unreadHeading,
+  separator: text.separator,
+});
+
+export const FACTS_TEXT: Texts<FactsText> = {
+  ja: {
+    ...shared(COMPARE_TEXT.ja),
+    usage: "使い方: chaff facts <file> [--compact | --json] [--language ja|en|…] [--genre <ジャンル>]",
+    title: (path, total, perKind) => `${path} の事実 ${String(total)} 件（${perKind}）`,
+    kindHeading: (kindName, count) => `${kindName} ${String(count)} 件`,
+    kindCount: (kindName, count) => `${kindName} ${String(count)}`,
+    next: (path) => `書き直したら npx chaffjs compare ${path} <書き直した後> で、この一覧が残っているかを確かめます`,
+  },
+  en: {
+    ...shared(COMPARE_TEXT.en),
+    usage: "usage: chaff facts <file> [--compact | --json] [--language ja|en|…] [--genre <genre>]",
+    title: (path, total, perKind) => `${path}: ${counted(total, "fact")} (${perKind})`,
+    kindHeading: (kindName, count) => `${kindName}: ${String(count)}`,
+    kindCount: (kindName, count) => `${kindName} ${String(count)}`,
+    next: (path) => `After rewriting, npx chaffjs compare ${path} <rewritten> checks that every fact on this list is still there`,
+  },
+};

package/src/compare/match.ts

@@ -11,7 +11,7 @@ export type Comparison = {
   readonly reformed: readonly Reformed[];
 };
 
-const identity = (atom: Atom): string => `${atom.kind}\u0000${atom.key}`;
+export const identity = (atom: Atom): string => `${atom.kind}\u0000${atom.key}`;
 
 const groupBy = <T>(items: readonly T[], keyOf: (item: T) => string): Map<string, T[]> => {
   const groups = new Map<string, T[]>();

package/src/compare/outcome.ts

@@ -1,6 +1,7 @@
 import { type Atom, type AtomKind, type Extraction, type Unread } from "./atom.ts";
 import { compareAtoms, type Reformed } from "./match.ts";
 import { unwrittenNames } from "./written-names.ts";
+import { unstatedChanges } from "./distinct.ts";
 
 /** One document as compared: where it is, how many facts of each kind it states, and what could not be read. */
 export type Side = {
@@ -27,6 +28,9 @@ export type Allowed = { readonly dropped: ReadonlySet<AtomKind>; readonly added:
 
 const NOTHING_ALLOWED: Allowed = { dropped: new Set(), added: new Set() };
 
+/** How facts are counted: as-stated compares how many times each is stated, distinct only whether it is stated (--distinct). */
+export type Counting = "as-stated" | "distinct";
+
 const NO_FACTS: Readonly<Record<AtomKind, number>> = {
   number: 0,
   date: 0,
@@ -40,7 +44,7 @@ const NO_FACTS: Readonly<Record<AtomKind, number>> = {
   footnote: 0,
 };
 
-const countsOf = (atoms: readonly Atom[]): Record<AtomKind, number> => {
+export const countsOf = (atoms: readonly Atom[]): Record<AtomKind, number> => {
   const counts = { ...NO_FACTS };
   atoms.forEach((atom) => {
     counts[atom.kind] += 1;
@@ -54,11 +58,17 @@ const marked = (atoms: readonly Atom[], allowed: ReadonlySet<AtomKind>): Change[
 
 export type Compared = { readonly path: string; readonly extraction: Extraction };
 
+/** The changes of one side that the other side does not state: as many times (as-stated), or at all (distinct). */
+const changesOf = (changes: readonly Atom[], own: Extraction, other: Extraction, counting: Counting): Atom[] => {
+  const unwritten = unwrittenNames(changes, own.atoms, other.nameText);
+  return counting === "distinct" ? unstatedChanges(unwritten, other.atoms, other.nameText) : unwritten;
+};
+
 /** What `chaff compare` reports: the comparison of two documents' facts, with the allowed kinds set aside. */
-export const outcomeOf = (before: Compared, after: Compared, allowed: Allowed = NOTHING_ALLOWED): Outcome => {
+export const outcomeOf = (before: Compared, after: Compared, allowed: Allowed = NOTHING_ALLOWED, counting: Counting = "as-stated"): Outcome => {
   const comparison = compareAtoms(before.extraction.atoms, after.extraction.atoms);
-  const dropped = marked(unwrittenNames(comparison.dropped, before.extraction.atoms, after.extraction.nameText), allowed.dropped);
-  const added = marked(unwrittenNames(comparison.added, after.extraction.atoms, before.extraction.nameText), allowed.added);
+  const dropped = marked(changesOf(comparison.dropped, before.extraction, after.extraction, counting), allowed.dropped);
+  const added = marked(changesOf(comparison.added, after.extraction, before.extraction, counting), allowed.added);
   return {
     before: sideOf(before.path, before.extraction),
     after: sideOf(after.path, after.extraction),

package/src/compare/proper-nouns.ts

@@ -1,6 +1,7 @@
 import type { ProseDocument, Span, Token } from "../plugin.ts";
 import type { Atom } from "./atom.ts";
 import { overlapsAny, type SpanIndex } from "./spans.ts";
+import { factKey } from "./fact-key.ts";
 
 const PROPER_NOUN = "PROPN";
 
@@ -40,11 +41,10 @@ export type NounInput = {
   /** Facts other readers took and what is not prose: a proper noun inside one is read as that, not again here. */
   readonly taken: SpanIndex;
   readonly lineOf: (offset: number) => number;
+  /** What a reader never sees (FactText.unseen): a line break inside a name does not make another name. */
+  readonly unseen: readonly Span[];
 };
 
-/** A name as one spelling: full-width letters and line breaks inside a name do not make another name. */
-export const nameKey = (written: string): string => written.normalize("NFKC").replace(/\s+/gu, " ");
-
 /** Whether the language package tagged parts of speech: without them, a document with sentences has no proper nouns to read. */
 export const readsProperNouns = (doc: ProseDocument): boolean => doc.sentences.length === 0 || doc.sentences.some((sentence) => sentence.tokens !== undefined);
 
@@ -54,12 +54,16 @@ export const readsProperNouns = (doc: ProseDocument): boolean => doc.sentences.l
  */
 export const properNouns = (input: NounInput): Atom[] => {
   const { source } = input.doc;
-  const lowerCase = lowerCaseWords(source);
-  return input.doc.sentences.flatMap((sentence) =>
-    runsOf(sentence.tokens ?? [], source).flatMap((run): Atom[] => {
-      const text = source.slice(run.start, run.end);
-      if (overlapsAny(input.taken, run) || isCommonWord(run, text, lowerCase)) return [];
-      return [{ kind: "name", key: nameKey(text), text, line: input.lineOf(run.start) }];
-    }),
+  return nameSpans(input.doc).flatMap((run): Atom[] => {
+    if (overlapsAny(input.taken, run)) return [];
+    return [{ kind: "name", key: factKey(source, run, input.unseen), text: source.slice(run.start, run.end), line: input.lineOf(run.start) }];
+  });
+};
+
+/** Where the tagger's proper nouns are written, each run of them one name, without the common words that began a sentence. */
+export const nameSpans = (doc: ProseDocument): Span[] => {
+  const lowerCase = lowerCaseWords(doc.source);
+  return doc.sentences.flatMap((sentence) =>
+    runsOf(sentence.tokens ?? [], doc.source).filter((run) => !isCommonWord(run, doc.source.slice(run.start, run.end), lowerCase)),
   );
 };

package/src/compare/render.ts

@@ -7,7 +7,7 @@ import type { CompareText } from "./text.ts";
 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 => {
+export const shown = (text: string): string => {
   const oneLine = text.replace(/\s+/gu, " ").trim();
   return oneLine.length > SHOWN_WIDTH ? `${oneLine.slice(0, SHOWN_WIDTH)}…` : oneLine;
 };
@@ -84,7 +84,7 @@ export const renderCompact = (outcome: Outcome, text: CompareText): string => {
   ].join("\n");
 };
 
-const atomJson = (atom: Atom): Readonly<Record<string, string | number>> => ({ kind: atom.kind, key: atom.key, text: atom.text, line: atom.line });
+export 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 =>

package/src/compare/text-atoms.ts

@@ -2,6 +2,7 @@ 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";
+import { factKey } from "./fact-key.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 };
@@ -63,14 +64,14 @@ const paragraphsOf = (text: string): Span[] => {
   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[] =>
+/**
+ * Quoted strings: 「」『』, “” and "". The key is what is inside, as one spelling: line breaks, runs of spaces and bold
+ * marks are how it is written, not what it says. unseen: what a reader never sees (FactText.unseen).
+ */
+export const quotations = (input: TextInput, unseen: readonly Span[]): 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 key = factKey(input.text, { start: paragraph.start + inner.start, end: paragraph.start + inner.end }, unseen).trim();
       const span = { start: paragraph.start + inner.start - 1, end: paragraph.start + inner.end + 1 };
       return key === "" ? [] : atomsOf([{ ...span, key }], "quote", input);
     }),

package/src/compare/text.ts

@@ -82,7 +82,8 @@ const UNREAD_EN: Readonly<Record<UnreadReason, (kind: AtomKind) => string>> = {
 
 export const COMPARE_TEXT: Texts<CompareText> = {
   ja: {
-    usage: "使い方: chaff compare <書き換える前> <書き換えた後> [--compact | --json] [--allow-dropped <種類>] [--allow-added <種類>] [--language ja|en|…]",
+    usage:
+      "使い方: chaff compare <書き換える前> <書き換えた後> [--compact | --json] [--allow-dropped <種類>] [--allow-added <種類>] [--distinct] [--language ja|en|…]",
     unknownKind: (kind, kinds) => `知らない種類です: ${kind}（使えるのは ${kinds}）`,
     kinds: KINDS_JA,
     kind: KINDS_JA,
@@ -100,7 +101,7 @@ export const COMPARE_TEXT: Texts<CompareText> = {
     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|…]",
+    usage: "usage: chaff compare <before> <after> [--compact | --json] [--allow-dropped <kind>] [--allow-added <kind>] [--distinct] [--language ja|en|…]",
     unknownKind: (kind, kinds) => `Unknown kind: ${kind} (the kinds are ${kinds})`,
     kinds: KINDS_EN,
     kind: KIND_EN,

package/src/config/load.ts

@@ -1,11 +1,12 @@
-import { readFileSync } from "node:fs";
 import { dirname } from "node:path";
-import { parse } from "yaml";
+import { readYamlFile } from "./yaml-file.ts";
 import { isLevel } from "../levels.ts";
 import { defaultModel } from "../judge.ts";
 import { isBackend, type BackendName } from "../backends/types.ts";
 import type { Level } from "../plugin.ts";
 import type { PathRule } from "./by-path.ts";
+import type { Extensions } from "../extension/load.ts";
+import type { StyleLimits } from "../style-parse.ts";
 
 export const CONFIG_FILE = "chaff.yaml";
 
@@ -34,6 +35,8 @@ export type Config = {
   readonly names: readonly string[];
   /** names に書かれていたが名前として読めなかった値。黙って捨てると、並べたつもりの名前が効いていないことに気づけない。 */
   readonly unreadableNames: readonly string[];
+  /** File-name globs (*.yaml) a directory walk checks besides Markdown. --include adds to them. */
+  readonly include?: readonly string[];
   /** パスごとの上書き。設定ファイルのある場所からの相対で照合する。 */
   readonly byPath: readonly PathRule[];
   readonly baseDir: string;
@@ -47,12 +50,20 @@ export type Config = {
   readonly applied?: AppliedStyle | undefined;
   /** custom_rules as written: the team's own rules. custom/parse.ts reads and checks them. */
   readonly customRules?: unknown;
+  /** grade as written: the rubric `chaff grade` reads (grade/rubric.ts). */
+  readonly grade?: unknown;
+  /** plugins as written: package names and paths. extension/plugin-load.ts reads and checks them. */
+  readonly plugins?: unknown;
+  /** The code chaff.yaml names, once loaded (extension/load.ts). Reading chaff.yaml does not load it. */
+  readonly extensions?: Extensions;
 };
 
 export type AppliedStyle = {
   readonly style: string;
   readonly levelsFrom: readonly string[];
   readonly options: Readonly<Record<string, unknown>>;
+  /** The style's numbers, by rule and language, for the rules whose level it decided. */
+  readonly limits: StyleLimits;
 };
 
 /** 判定の質が誤検知に直結するので、既定は最上位のモデル。cost は絞り込みで削る。spec §14。 */
@@ -155,7 +166,7 @@ const byPathOf = (raw: unknown): PathRule[] => (Array.isArray(raw) ? raw.map(toP
 
 /** 設定ファイルが無くても動く。あっても、既定から変えたものだけが書かれている。spec §18。 */
 export const loadConfig = (path: string): Config => {
-  const raw: unknown = parse(readFileSync(path, "utf8"));
+  const raw: unknown = readYamlFile(path);
   if (!isRecord(raw)) return { ...EMPTY, path };
   const declared: unknown = raw["ai_backend"];
   const backend: BackendName = isBackend(declared) ? declared : DEFAULT_BACKEND;
@@ -178,11 +189,14 @@ export const loadConfig = (path: string): Config => {
     requiredSections: wordsOf(raw["required_sections"]),
     names: names.names,
     unreadableNames: names.unreadable,
+    include: globsOf(raw["include"]),
     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"],
+    grade: raw["grade"],
+    plugins: raw["plugins"],
   };
 };

package/src/config/option-problems.ts

@@ -1,7 +1,7 @@
 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 { limitsFor, styleLevelSource, styleSource } from "./style.ts";
 import type { Texts, UiLanguage } from "../ui.ts";
 
 /** Where chaff.yaml's options come from, for settleOptions: the file itself. */
@@ -10,13 +10,15 @@ export const configOptionLayer = (config: Pick<Config, "options">): OptionLayer
   values: config.options ?? {},
 });
 
-/** Where a rule's settings come from, for explain: the option layers, and the style when it set the level. */
+/** Where a rule's settings come from, for explain: the option layers, the style when it set the level, and a number set for it. */
 export const settingSourcesOf = (
-  config: Pick<Config, "options" | "applied">,
+  config: Pick<Config, "options" | "applied" | "limits">,
   ruleId: string,
-): { optionLayers: OptionLayer[]; levelFrom: string | undefined } => ({
+  language: string,
+): { optionLayers: OptionLayer[]; levelFrom: string | undefined; limit: number | undefined } => ({
   optionLayers: optionLayersOf(config),
   levelFrom: styleLevelSource(config, ruleId),
+  limit: limitsFor(config, language)[ruleId],
 });
 
 /** Every place options come from, strongest first: chaff.yaml, then its style. */

package/src/config/style.ts

@@ -18,13 +18,26 @@ export const withStyle = (config: Config, styles: readonly StyleDefinition[]): C
   const style = styles.find((entry) => entry.id === config.style);
   if (style === undefined) return config;
   const fromStyle = Object.keys(style.rules).filter((id) => config.rules[id] === undefined && config.limits[id] === undefined);
+  const limits = Object.fromEntries(Object.entries(style.limits).filter(([id]) => fromStyle.includes(id)));
   return {
     ...config,
     rules: { ...style.rules, ...config.rules },
-    applied: { style: style.id, levelsFrom: fromStyle, options: style.options },
+    applied: { style: style.id, levelsFrom: fromStyle, options: style.options, limits },
   };
 };
 
+/**
+ * The numeric limits a run of a document in this language uses: chaff.yaml's own, and under them the style's for this
+ * language. A style that gives a number only for Japanese leaves an English document at the level's number.
+ */
+export const limitsFor = (config: Pick<Config, "limits" | "applied">, language: string): Readonly<Record<string, number>> => {
+  const fromStyle = Object.entries(config.applied?.limits ?? {}).flatMap(([id, byLanguage]): [string, number][] => {
+    const limit = byLanguage[language];
+    return limit === undefined ? [] : [[id, limit]];
+  });
+  return { ...Object.fromEntries(fromStyle), ...config.limits };
+};
+
 const TEXT: Texts<{ readonly unknown: (where: string, style: string, known: string) => string }> = {
   ja: {
     unknown: (where, style, known) => `${where}: style: ${style} というスタイルはありません。使えるのは ${known} です`,

package/src/config/yaml-file.ts

@@ -0,0 +1,65 @@
+import { readFileSync } from "node:fs";
+import { parse, YAMLParseError } from "yaml";
+import { relative } from "node:path";
+import type { Texts, UiLanguage } from "../ui.ts";
+
+/** Where a settings file stops being YAML: 1-based line and column, and the parser's own sentence without its position. */
+export type YamlSyntax = { readonly line: number; readonly column: number; readonly detail: string };
+
+/** The parser appends " at line 3, column 1:" and, on the lines below, a picture of the line; chaff says the position itself. */
+const POSITION_TAIL = / at line \d+, column \d+:?$/u;
+
+/** A YAML syntax error as a position and a sentence, or undefined for anything else (a missing file is not a syntax error). */
+export const yamlSyntaxOf = (error: unknown): YamlSyntax | undefined => {
+  if (!(error instanceof YAMLParseError)) return undefined;
+  const start = error.linePos?.[0];
+  return {
+    line: start?.line ?? 1,
+    column: start?.col ?? 1,
+    detail: (error.message.split("\n")[0] ?? "").replace(POSITION_TAIL, "").trim(),
+  };
+};
+
+/** A settings file the person wrote that is not YAML. The command line says where and stops; no stack trace. */
+export class YamlFileError extends Error {
+  readonly path: string;
+  readonly syntax: YamlSyntax;
+
+  constructor(path: string, syntax: YamlSyntax, cause: unknown) {
+    super(`${path}:${syntax.line}:${syntax.column}: ${syntax.detail}`, { cause });
+    this.name = "YamlFileError";
+    this.path = path;
+    this.syntax = syntax;
+  }
+}
+
+/** A settings file read as YAML. A syntax error becomes a YamlFileError naming the file; other failures pass through. */
+export const readYamlFile = (path: string): unknown => {
+  const text = readFileSync(path, "utf8");
+  try {
+    return parse(text);
+  } catch (error) {
+    const syntax = yamlSyntaxOf(error);
+    if (syntax === undefined) throw error;
+    throw new YamlFileError(path, syntax, error);
+  }
+};
+
+const TEXT: Texts<(path: string, syntax: YamlSyntax) => string> = {
+  ja: (path, { line, column, detail }) => `chaff: ${path} の ${line} 行目 ${column} 桁目が YAML として読めません: ${detail}`,
+  en: (path, { line, column, detail }) => `chaff: ${path}, line ${line}, column ${column}, is not valid YAML: ${detail}`,
+};
+
+/** The sentence the command line prints for a settings file that is not YAML. path: as the person would type it. */
+export const yamlFileProblem = (path: string, syntax: YamlSyntax, ui: UiLanguage): string => TEXT[ui](path, syntax);
+
+/** Runs a command, and turns a settings file that is not YAML into its sentence and exit code 1. cwd: what the path is printed relative to. */
+export const stoppingOnYamlFileError = async (run: () => Promise<number>, cwd: string, ui: UiLanguage): Promise<number> => {
+  try {
+    return await run();
+  } catch (error) {
+    if (!(error instanceof YamlFileError)) throw error;
+    console.error(yamlFileProblem(relative(cwd, error.path) || error.path, error.syntax, ui));
+    return 1;
+  }
+};

package/src/correction-edit.ts

@@ -0,0 +1,43 @@
+// 誤った形と正しい形の組から、書いた語のどこをどう直すかを決める。純粋な関数だけを置く。
+
+/** wrong の上の [start, end) を replacement にすると right になる。前後の同じ字は含めない。 */
+export type Edit = { readonly start: number; readonly end: number; readonly replacement: string };
+
+const commonPrefix = (left: string, right: string): number => {
+  const limit = Math.min(left.length, right.length);
+  const differs = [...Array(limit).keys()].find((at) => left[at] !== right[at]);
+  return differs ?? limit;
+};
+
+/** 二つの形の違う所。前の同じ字を先に除き、残りから後ろの同じ字を除く（「ですす」と「です」は、後ろの「す」を足した所）。 */
+export const editBetween = (wrong: string, right: string): Edit => {
+  const start = commonPrefix(wrong, right);
+  const tail = commonPrefix(Array.from(wrong.slice(start)).reverse().join(""), Array.from(right.slice(start)).reverse().join(""));
+  return { start, end: wrong.length - tail, replacement: right.slice(start, right.length - tail) };
+};
+
+/** 指す字と、そこに入る正しい形。指す字は、書いた字の頭から。 */
+export type Correction = { readonly matched: string; readonly suggestion: string };
+
+const capitalised = (word: string): string => `${word.charAt(0).toUpperCase()}${word.slice(1)}`;
+
+const isAllCapitals = (word: string): boolean => /\p{Lu}.*\p{Lu}/u.test(word) && !/\p{Ll}/u.test(word);
+
+/** 書いた語の大文字に合わせる（文頭の "Teh" には "The"、"TEH" には "THE"）。 */
+const casedLike = (written: string, suggestion: string): string => {
+  if (isAllCapitals(written)) return suggestion.toUpperCase();
+  return /^\p{Lu}/u.test(written) && /^\p{Ll}/u.test(suggestion) ? capitalised(suggestion) : suggestion;
+};
+
+/**
+ * 書いた字（written）に、語彙表の組の違い（edit）を当てる。boundaries は written の中の語の終わりの位置で、written.length を含む。
+ * 指すのは written の頭から、違う所を含む語の終わりまで。後ろに続く前後の語は言わない（「以外と簡単」は「以外」を「意外」に、
+ * 活用した「始めて会った」は「始めて」を「初めて」に）。written の頭が誤った形の違う所まで同じでなければ（活用で字が変わった）undefined。
+ */
+export const correctionIn = (written: string, wrong: string, edit: Edit, boundaries: readonly number[]): Correction | undefined => {
+  if (written.slice(0, edit.end).toLowerCase() !== wrong.slice(0, edit.end).toLowerCase()) return undefined;
+  const end = Math.min(written.length, ...boundaries.filter((at) => at >= edit.end));
+  const matched = written.slice(0, end);
+  const suggestion = `${matched.slice(0, edit.start)}${edit.replacement}${matched.slice(edit.end)}`;
+  return { matched, suggestion: casedLike(matched, suggestion) };
+};