chaffjs 0.18.0 → 0.19.0

package/src/commands/fix-plan.ts

@@ -0,0 +1,53 @@
+import { existsSync } from "node:fs";
+import { outlineOf } from "../outline/shape.ts";
+import { buildFixPlan } from "../fix-plan/plan.ts";
+import { renderFixPlanJson, renderFixPlanMarkdown } from "../fix-plan/render.ts";
+import { FIX_PLAN_TEXT } from "../fix-plan/text.ts";
+import type { Checked } from "./feedback.ts";
+import { readDocument } from "./read-document.ts";
+import type { TreeContext } from "./tree.ts";
+
+/** Options whose value is the next argument. That value is not a file. */
+const VALUED: ReadonlySet<string> = new Set(["--language", "--genre"]);
+
+export const fixPlanTargets = (argv: readonly string[]): string[] =>
+  argv.slice(1).filter((arg, index, all) => !arg.startsWith("--") && !VALUED.has(all[index - 1] ?? ""));
+
+export type FixPlanContext = TreeContext & {
+  /** The file's findings as lint finds them, shelved ones included. */
+  readonly check: (path: string) => Promise<Omit<Checked, "conditions">>;
+};
+
+/**
+ * An instruction document for whoever rewrites the file: the findings grouped by rule, each rule's rewrite direction,
+ * the document-level signals, a recommended mode and the checks to run after. Deterministic; sends nothing anywhere.
+ */
+export const runFixPlan = async (targets: readonly string[], argv: readonly string[], context: FixPlanContext): Promise<number> => {
+  const [path] = targets;
+  if (path === undefined || targets.length > 1) {
+    console.error(FIX_PLAN_TEXT[context.ui ?? "ja"].usage);
+    return 1;
+  }
+  if (!existsSync(path)) {
+    console.error(FIX_PLAN_TEXT[context.ui ?? "ja"].notFound(path));
+    return 1;
+  }
+  const checked = await context.check(path);
+  // The outline is read in the language lint chose, so the plan's findings and its outline describe one reading.
+  const prose = await readDocument(path, ["fix-plan", "--language", checked.language, ...argv.slice(1)], context, false);
+  if (prose === undefined) return 1;
+  const plan = buildFixPlan({
+    path,
+    language: checked.language,
+    genre: checked.genre,
+    experimental: context.config.experimental || argv.includes("--experimental"),
+    genreFlag: context.flag(argv, "--genre"),
+    findings: checked.findings,
+    rules: checked.rules,
+    skipped: checked.skipped,
+    outline: outlineOf(prose.doc),
+    phrases: prose.doc.lexicons["ai-tell"] ?? [],
+  });
+  console.log(argv.includes("--json") ? renderFixPlanJson(plan) : renderFixPlanMarkdown(plan));
+  return 0;
+};

package/src/commands/outline.ts

@@ -0,0 +1,49 @@
+import { uiLanguageOf } from "../ui.ts";
+import { outlineOf } from "../outline/shape.ts";
+import { renderOutlineCompact, renderOutlineFriendly, renderOutlineJson, type DocumentOutline } from "../outline/render.ts";
+import { OUTLINE_TEXT } from "../outline/text.ts";
+import { readDocument } from "./read-document.ts";
+import type { TreeContext } from "./tree.ts";
+
+/** Options whose value is the next argument. That value is not a file. */
+const VALUED: ReadonlySet<string> = new Set(["--language", "--genre"]);
+
+export const outlineTargets = (argv: readonly string[]): string[] =>
+  argv.slice(1).filter((arg, index, all) => !arg.startsWith("--") && !VALUED.has(all[index - 1] ?? ""));
+
+const MOST_FILES = 2;
+
+const readOutline = async (path: string, argv: readonly string[], context: TreeContext): Promise<DocumentOutline | undefined> => {
+  const prose = await readDocument(path, argv, context, false);
+  return prose === undefined ? undefined : { path, language: prose.language, outline: outlineOf(prose.doc) };
+};
+
+/** The files in the order given, or undefined once one cannot be read (its error is already printed). */
+const readAll = async (paths: readonly string[], argv: readonly string[], context: TreeContext): Promise<DocumentOutline[] | undefined> =>
+  paths.reduce<Promise<DocumentOutline[] | undefined>>(async (previous, path) => {
+    const earlier = await previous;
+    if (earlier === undefined) return undefined;
+    const next = await readOutline(path, argv, context);
+    return next === undefined ? undefined : [...earlier, next];
+  }, Promise.resolve([]));
+
+const renderFor = (argv: readonly string[], documents: readonly DocumentOutline[]): string => {
+  const text = OUTLINE_TEXT[uiLanguageOf(documents[0]?.language)];
+  if (argv.includes("--json")) return renderOutlineJson(documents);
+  return argv.includes("--compact") ? renderOutlineCompact(documents, text) : renderOutlineFriendly(documents, text);
+};
+
+/**
+ * A document's outline and shape (headings, average section length, text in lists, bold), or two documents' side by
+ * side: a restructure measured by machine. Measures; never judges, so it always ends with 0 once the files are read.
+ */
+export const runOutline = async (targets: readonly string[], argv: readonly string[], context: TreeContext): Promise<number> => {
+  if (targets.length === 0 || targets.length > MOST_FILES) {
+    console.error(OUTLINE_TEXT[context.ui ?? "ja"].usage);
+    return 1;
+  }
+  const documents = await readAll(targets, argv, context);
+  if (documents === undefined) return 1;
+  console.log(renderFor(argv, documents));
+  return 0;
+};

package/src/commands/read-document.ts

@@ -0,0 +1,24 @@
+import { loadAdapter } from "../adapter-load.ts";
+import { buildDocument, teamRules } from "../document.ts";
+import { profileFor } from "../profile/for-file.ts";
+import { resolveGenre } from "../resolve-genre.ts";
+import type { ProseDocument, StructurePatterns } from "../plugin.ts";
+import { readSource, treeLanguage, type TreeContext } from "./tree.ts";
+
+/** One document as lint reads it, and its language package's structure reader. */
+export type ReadDocument = { readonly doc: ProseDocument; readonly language: string; readonly structure: StructurePatterns | undefined };
+
+/**
+ * Reads one file as lint does: its language, genre, document profile and the team's rules. `pos` loads the
+ * part-of-speech tagger, which costs time, so only a command that reads names asks for it.
+ */
+export const readDocument = async (path: string, argv: readonly string[], context: TreeContext, pos: boolean): Promise<ReadDocument | undefined> => {
+  const source = await readSource(path, context);
+  if (source === undefined) return undefined;
+  const language = treeLanguage(path, source, argv, context);
+  const adapter = await loadAdapter(language);
+  await adapter.prepare?.({ pos });
+  const genre = resolveGenre(path, source, context.config, context.flag(argv, "--genre")).genre;
+  const doc = buildDocument(path, source, adapter, teamRules(context.config), profileFor(context.config, path, source, language, genre));
+  return { doc, language, structure: adapter.structure };
+};

package/src/commands/suppressions.ts

@@ -0,0 +1,19 @@
+import { collectTargets } from "../files.ts";
+import { renderSuppressions, type PerFile } from "../render/suppressions.ts";
+import type { UiLanguage } from "../ui.ts";
+
+/** `chaff suppressions`: what the stets in these files (this folder by default) silence, and the stets whose rule did not run. */
+export const runSuppressions = async (
+  targets: readonly string[],
+  inspect: (path: string) => Promise<{ readonly perFile: PerFile }>,
+  ui: UiLanguage,
+): Promise<number> => {
+  const inspected = await Promise.all(collectTargets(targets.length > 0 ? targets : ["."]).map(inspect));
+  console.log(
+    renderSuppressions(
+      inspected.map((file) => file.perFile),
+      ui,
+    ),
+  );
+  return 0;
+};

package/src/commands/test.ts

@@ -91,7 +91,7 @@ const semanticDocument = async (path: string, config: Config, resolveGenre: Test
   const { genre } = resolveGenre(path, source, config);
   const rules = loadRules(language);
   await adapter.prepare?.(semanticNeeds(rules, config.rules, genre));
-  const doc = buildDocument(path, source, adapter, teamRules(config), profileFor(config, path, source, language, genre));
+  const doc = buildDocument(path, source, adapter, teamRules(config, language), profileFor(config, path, source, language, genre));
   return { doc, rules, language, genre };
 };
 

package/src/compare/clock-time.ts

@@ -16,8 +16,11 @@ const COLON_TIME = new RegExp(
 /** 3 p.m., 11am. */
 const MERIDIEM_TIME = new RegExp(`(?<![0-9０-９:：])(${DIGIT}{1,2})\\s?([ap])\\.?m\\.?(?![a-z])`, "giu");
 
-/** 午後3時30分, 10時半, 9時. */
-const JAPANESE_TIME = new RegExp(`(午前|午後)?(${DIGIT}{1,2})時(?:(${DIGIT}{1,2})分|(半))?`, "gu");
+/**
+ * 午後3時30分, 10時半, 9時. 時間 is a length of time (8時間), not a time of day, and the hour is not the end of a longer
+ * number (1.2時間, 123時).
+ */
+const JAPANESE_TIME = new RegExp(`(午前|午後)?(?<![0-9０-９.．])(${DIGIT}{1,2})時(?!間)(?:(${DIGIT}{1,2})分|(半))?`, "gu");
 
 const LAST_HOUR = 24;
 const MINUTES_PER_HOUR = 60;

package/src/compare/distinct.ts

@@ -0,0 +1,13 @@
+import type { Atom } from "./atom.ts";
+import { identity } from "./match.ts";
+
+/**
+ * The changes left when facts are compared as sets (--distinct): a fact the other document states at least once is
+ * kept, however many times either states it. A summary that repeated the body can be cut without its repeats reading
+ * as dropped. A name counts as stated when its spelling is in the other document's text (otherNameText), as when
+ * names are counted.
+ */
+export const unstatedChanges = (changes: readonly Atom[], other: readonly Atom[], otherNameText: string): Atom[] => {
+  const stated = new Set(other.map(identity));
+  return changes.filter((atom) => !stated.has(identity(atom)) && !(atom.kind === "name" && otherNameText.includes(atom.key)));
+};

package/src/compare/extract.ts

@@ -5,7 +5,8 @@ import type { Atom, Extraction, Unread } from "./atom.ts";
 import { clockTimes } from "./clock-time.ts";
 import { factTextOf, type FactText } from "./fact-text.ts";
 import { codeAtoms, headingAtoms, urlAtoms } from "./markup-atoms.ts";
-import { nameKey, properNouns, readsProperNouns } from "./proper-nouns.ts";
+import { properNouns, readsProperNouns } from "./proper-nouns.ts";
+import { factKey, seenTextOf, wholeSpanOf } from "./fact-key.ts";
 import { spanIndex } from "./spans.ts";
 import { atomsOf, bareNumbers, footnotes, numericDates, quotations, teamNames, type TextInput } from "./text-atoms.ts";
 import { treeFacts, type TreeFacts } from "./tree-atoms.ts";
@@ -39,16 +40,17 @@ const proseFacts = (input: ExtractInput, readers: Readers, tree: TreeFacts, time
   const { facts, text, lineOf } = readers;
   const marks = footnotes(facts.codeless);
   const dates = numericDates(facts.text, spanIndex([...tree.taken, ...times]));
-  const names = teamNames(facts.text, input.names);
+  const seen = seenTextOf(facts.text, facts.unseen);
+  const names = teamNames(seen.text, input.names).map((found) => wholeSpanOf(seen, found));
   const taken = [...tree.taken, ...times, ...marks, ...dates];
   return [
     ...atomsOf(dates, "date", text),
     ...atomsOf(marks, "footnote", text),
     ...atomsOf(names, "name", text),
     ...bareNumbers(text, spanIndex([...taken, ...facts.listMarkers])),
-    ...quotations(text),
+    ...quotations(text, facts.unseen),
     // "April" in a date and "Section" in a reference are read with them, not again as names.
-    ...properNouns({ doc: input.doc, taken: spanIndex([...taken, ...names, ...facts.blanked]), lineOf }),
+    ...properNouns({ doc: input.doc, taken: spanIndex([...taken, ...names, ...facts.blanked]), lineOf, unseen: facts.unseen }),
   ];
 };
 
@@ -74,5 +76,5 @@ export const extractFacts = (input: ExtractInput): Extraction => {
     ...(input.root === undefined ? [] : codeAtoms(input.root, lineOf)),
     ...headingAtoms(input.doc.markup, lineOf),
   ];
-  return { atoms, unread: unreadOf(input), nameText: nameKey(facts.text) };
+  return { atoms, unread: unreadOf(input), nameText: factKey(facts.text, { start: 0, end: source.length }, facts.unseen) };
 };

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);
 
@@ -59,7 +59,7 @@ export const properNouns = (input: NounInput): Atom[] => {
     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 [{ kind: "name", key: factKey(source, run, input.unseen), text, line: input.lineOf(run.start) }];
     }),
   );
 };

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

@@ -6,6 +6,8 @@ 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";
 
@@ -47,12 +49,18 @@ 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;
+  /** 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。 */
@@ -184,5 +192,6 @@ export const loadConfig = (path: string): Config => {
     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"],
+    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. */