chaffjs 0.17.0 → 0.19.0

package/src/announced-list.ts

@@ -0,0 +1,120 @@
+import type { Lexicon, LexiconEntry, Sentence, Token } from "./plugin.ts";
+import { entryRanges } from "./detectors/lexicon-match.ts";
+
+// 一覧を言う語（supported on、に対応）の隣に並べた名前を読み、後の文が、最初に挙げた一覧に無い名前を同じ語で言っていないかを見る。
+// 「対応 OS は Windows と macOS」と書いたあとの「Linux にも対応」。どちらが正しいかは決めず、一覧の外の名前を指す。
+
+export type ListMember = { readonly name: string; readonly offset: number };
+
+export type ListStatement = { readonly group: string; readonly offset: number; readonly members: readonly ListMember[] };
+
+export type OutsideMember = { readonly member: ListMember; readonly announced: ListStatement };
+
+const UPPER = /\p{Lu}/u;
+
+/**
+ * 名前の語。固有名詞のほか、大文字を含む名詞（macOS、Linux）。日本語の解析器は英字の名前を名詞とも固有名詞とも読むので、
+ * 品詞だけでは同じ一覧の名前が揃わない。
+ */
+const isNameToken = (token: Token): boolean => token.pos === "PROPN" || (token.pos === "NOUN" && UPPER.test(token.surface));
+
+const isJoiner = (token: Token, joiners: ReadonlySet<string>): boolean => joiners.has(token.surface.toLowerCase());
+
+/** 名前の語の並び（前へ読んだときは逆順）から、source の上の名前。 */
+const memberOf = (run: readonly Token[], source: string): ListMember | undefined => {
+  if (run.length === 0) return undefined;
+  const start = Math.min(...run.map((token) => token.span.start));
+  const end = Math.max(...run.map((token) => token.span.end));
+  return { name: source.slice(start, end).replaceAll(/\s+/gu, " "), offset: start };
+};
+
+/**
+ * 並んだ名前を、語の並びの順に読む。固有名詞が続けば一つの名前、つなぐ語（and、と、、）は名前の区切り。ほかの語に当たったら止まる。
+ * 名前で始まらなければ一覧ではない（supported on the web）。
+ */
+export const namesInOrder = (tokens: readonly Token[], joiners: ReadonlySet<string>, source: string): ListMember[] => {
+  const runs: Token[][] = [[]];
+  tokens.every((token) => {
+    const current = runs.at(-1) ?? [];
+    if (isNameToken(token)) current.push(token);
+    else if (isJoiner(token, joiners) && current.length > 0) runs.push([]);
+    else return false;
+    return true;
+  });
+  return runs.flatMap((run) => memberOf(run, source) ?? []);
+};
+
+/** 一覧の語の、一つの現れから読んだ名前。before の語は後ろの名前を、after の語は前の名前を読む。 */
+const membersAt = (
+  tokens: readonly Token[],
+  entry: LexiconEntry,
+  range: { start: number; end: number },
+  joiners: ReadonlySet<string>,
+  source: string,
+): ListMember[] =>
+  entry.position === "after"
+    ? namesInOrder(tokens.slice(0, range.start).toReversed(), joiners, source).toReversed()
+    : namesInOrder(tokens.slice(range.end), joiners, source);
+
+/** 一覧を読む言葉。frames は一覧を言う語、joiners は名前をつなぐ語、negations は打ち消しの語（小文字）。 */
+export type ListWords = { readonly frames: Lexicon; readonly joiners: ReadonlySet<string>; readonly negations: ReadonlySet<string> };
+
+/** 打ち消した文（neither is available on Docker Hub、Linux には対応していません）は、一覧に足す名前ではなく、外す名前を言う。 */
+const isNegated = (tokens: readonly Token[], negations: ReadonlySet<string>): boolean =>
+  tokens.some((token) => negations.has(token.surface.toLowerCase()) || negations.has((token.lemma ?? "").toLowerCase()));
+
+/** 文の中の、一覧を言う語と、その隣の名前。group の無い語は比べる相手が決まらないので読まない。打ち消した文も読まない。 */
+export const listStatementsIn = (sentence: Sentence, words: ListWords, source: string): ListStatement[] => {
+  const tokens = sentence.tokens ?? [];
+  const { frames, joiners } = words;
+  if (isNegated(tokens, words.negations)) return [];
+  return frames.flatMap((entry) => {
+    const group = entry.group;
+    if (group === undefined) return [];
+    return entryRanges(sentence, entry).flatMap((range) => {
+      const members = membersAt(tokens, entry, range, joiners, source);
+      const offset = tokens[range.start]?.span.start ?? sentence.span.start;
+      return members.length === 0 ? [] : [{ group, offset, members }];
+    });
+  });
+};
+
+/** 比べる形。大文字小文字・幅・空白は名前を変えない。 */
+const comparable = (name: string): string => name.normalize("NFKC").toLowerCase().replaceAll(/\s+/gu, "");
+
+/** 二つ以上の名前を挙げた最初の文。組ごとに一つ。 */
+const announcements = (statements: readonly ListStatement[]): ReadonlyMap<string, ListStatement> =>
+  statements.reduce((found, statement) => {
+    if (statement.members.length >= 2 && !found.has(statement.group)) found.set(statement.group, statement);
+    return found;
+  }, new Map<string, ListStatement>());
+
+/**
+ * 後の文が、一覧と一つも重ならない二つ以上の名前を挙げていれば、別のものの一覧（RIS は EndNote と RefWorks、BibTeX は BibDesk と LaTeX）。
+ * そこから先は、一つだけ名前を言う文がどちらの一覧の続きか決まらないので、その組は比べない。
+ */
+const isAnotherList = (statement: ListStatement, known: ReadonlySet<string>): boolean =>
+  statement.members.length >= 2 && !statement.members.some((member) => known.has(comparable(member.name)));
+
+/** 最初に挙げた一覧より後の文で、同じ組の語が言う、一覧に無い名前。名前ごとに最初の一つ。 */
+export const outsideMembers = (statements: readonly ListStatement[]): OutsideMember[] => {
+  const ordered = statements.toSorted((left, right) => left.offset - right.offset);
+  const announced = announcements(ordered);
+  const reported = new Set<string>();
+  const ambiguous = new Set<string>();
+  return ordered.flatMap((statement) => {
+    const list = announced.get(statement.group);
+    if (list === undefined || statement.offset <= list.offset || ambiguous.has(statement.group)) return [];
+    const known = new Set(list.members.map((member) => comparable(member.name)));
+    if (isAnotherList(statement, known)) {
+      ambiguous.add(statement.group);
+      return [];
+    }
+    return statement.members.flatMap((member) => {
+      const key = `${statement.group}\u0000${comparable(member.name)}`;
+      if (known.has(comparable(member.name)) || reported.has(key)) return [];
+      reported.add(key);
+      return [{ member, announced: list }];
+    });
+  });
+};

package/src/api.ts

@@ -0,0 +1,154 @@
+// The plugin API: everything a team's rule or a plugin package may rely on, and nothing else. A detector sees the
+// document only through these shapes, so chaff can change how it reads a document without breaking a plugin. Raise
+// API_VERSION when a change here would break a plugin written against the current one.
+
+/** The plugin API this chaff implements. A plugin says which one it was written for; chaff refuses any other. */
+export const API_VERSION = 1;
+
+/** A place in doc.source: UTF-16 offsets, end exclusive. */
+export type Span = { readonly start: number; readonly end: number };
+
+/** One word as the language adapter read it. pos is a Universal Dependencies UPOS tag (NOUN, VERB, ADP…). */
+export type Token = {
+  readonly span: Span;
+  readonly surface: string;
+  readonly pos: string;
+  readonly lemma?: string;
+  /** How the word is read (katakana for Japanese). Only adapters that can read it give it. */
+  readonly reading?: string;
+  /** Universal Dependencies FEATS the adapter folded in (Voice=Pass). */
+  readonly features?: Readonly<Record<string, string>>;
+};
+
+/** tokens is there only when the rule asked for parts of speech (requires: [pos]) and the adapter could give them. */
+export type Sentence = { readonly span: Span; readonly text: string; readonly tokens?: readonly Token[] };
+
+export type Paragraph = { readonly span: Span; readonly sentences: readonly Sentence[] };
+
+/** A heading and what follows it, up to the next heading. The text before the first heading is a section of depth 0. */
+export type Section = { readonly depth: number; readonly heading: string; readonly span: Span; readonly sentences: readonly Sentence[] };
+
+/** One bulleted or numbered list, with the length of each item in characters. */
+export type List = { readonly span: Span; readonly itemLengths: readonly number[] };
+
+/** One entry of a word list. instead_of is another way to write the same thing, for rules that check a document is consistent. */
+export type LexiconEntry = { readonly pattern: string; readonly instead_of?: string };
+
+export type Lexicon = readonly LexiconEntry[];
+
+export type MarkupHeading = { readonly depth: number; readonly text: string; readonly span: Span };
+
+/** alt is undefined for an HTML <img> with no alt attribute. */
+export type MarkupImage = { readonly alt: string | undefined; readonly span: Span };
+
+export type MarkupLink = { readonly destination: string; readonly span: Span };
+
+/** The document's markup. A plain-text document has markdown: false and no headings, images or links. */
+export type Markup = {
+  readonly markdown: boolean;
+  readonly headings: readonly MarkupHeading[];
+  readonly images: readonly MarkupImage[];
+  readonly links: readonly MarkupLink[];
+  /** The in-page names the writer gave ({#id} on a heading, HTML id and name), sorted. */
+  readonly ids: readonly string[];
+  /** What the reader sees as text: everything outside links. */
+  readonly texts: readonly Span[];
+};
+
+/** What a detector reads. Every span is a place in source. It is frozen: a detector cannot change what other rules see. */
+export type RuleDocument = {
+  readonly path: string;
+  readonly source: string;
+  /** The language the document is checked as: "ja", "en". */
+  readonly language: string;
+  /** What a length counts: characters (ja) or words (en). */
+  readonly lengthUnit: "char" | "word";
+  readonly sentences: readonly Sentence[];
+  readonly paragraphs: readonly Paragraph[];
+  readonly sections: readonly Section[];
+  readonly lists: readonly List[];
+  /** Each list item, wherever it is. */
+  readonly listItems: readonly Span[];
+  /** Each link, as written (`[text](url)`, `<https://…>`). */
+  readonly links: readonly Span[];
+  /** The word lists for the document's language: the adapter's, the team's and the plugins'. */
+  readonly lexicons: Readonly<Record<string, Lexicon>>;
+  readonly markup: Markup;
+};
+
+/** What a detector is given besides the document. lexicon is the rule's word_list for the document's language. */
+export type DetectorOptions = { readonly lexicon: Lexicon | undefined };
+
+/**
+ * One place a rule found. start (and end) are offsets in doc.source. values fill the rule's message: {matched} is
+ * source from start to end unless values gives it.
+ */
+export type Finding = {
+  readonly start: number;
+  readonly end?: number;
+  readonly values?: Readonly<Record<string, string | number>>;
+};
+
+/** A rule's check. It must be pure and deterministic: no files, network, clock or randomness, the same findings every time. */
+export type Detector = (doc: RuleDocument, options: DetectorOptions) => readonly Finding[];
+
+/** Words a reader sees: one string for every language, or one per language ({ ja, en }). */
+export type Text = string | Readonly<Record<string, string>>;
+
+export type Severity = "error" | "warning" | "info";
+
+/**
+ * A rule. In a type: module file only detect is read, and chaff.yaml gives the rest. In a plugin, id, name, why,
+ * how_to_fix and example are required, as they are for a rule in custom_rules.
+ */
+export type RuleSpec = {
+  readonly detect: Detector;
+  readonly id?: string;
+  readonly name?: Text;
+  readonly why?: Text;
+  readonly how_to_fix?: Text;
+  readonly example?: { readonly before: Text; readonly after: Text };
+  readonly message?: Text;
+  readonly level?: Severity;
+  /** The languages the rule checks. Without it, every language. */
+  readonly languages?: readonly string[];
+  /** A word list by name; the detector gets it as options.lexicon. A plugin's own lists are named without the plugin's prefix. */
+  readonly word_list?: string;
+  /** "pos" when the detector reads tokens. Without it, sentences have no tokens. */
+  readonly requires?: readonly "pos"[];
+};
+
+export type Rule = RuleSpec & { readonly apiVersion: number };
+
+/** A rule, stamped with the API version it was written for. */
+export const defineRule = (spec: RuleSpec): Rule => ({ ...spec, apiVersion: API_VERSION });
+
+/** A word list in each language it has words for: { ja: [...], en: [...] }. A string is an entry with only a pattern. */
+export type LexiconSpec = Readonly<Record<string, readonly (string | LexiconEntry)[]>>;
+
+/** A house style a plugin ships: rule levels and options, and the guideline it follows. */
+export type StyleSpec = {
+  readonly id: string;
+  readonly name: Text;
+  readonly summary: Text;
+  readonly source: { readonly title: Text; readonly url: string };
+  readonly rules?: Readonly<Record<string, "strict" | "normal" | "relaxed" | "off">>;
+  readonly options?: Readonly<Record<string, Readonly<Record<string, unknown>>>>;
+};
+
+/**
+ * A plugin package. name is the prefix of every id it ships (name/rule-id); for chaff-plugin-foo it is foo, for
+ * @scope/chaff-plugin-foo it is @scope/foo. A rule is a RuleSpec, or a custom_rules entry without code (type: words,
+ * pattern or tokens).
+ */
+export type PluginSpec = {
+  readonly name: string;
+  readonly rules?: readonly (Rule | RuleSpec | Readonly<Record<string, unknown>>)[];
+  readonly lexicons?: Readonly<Record<string, LexiconSpec>>;
+  readonly styles?: readonly StyleSpec[];
+};
+
+export type Plugin = PluginSpec & { readonly apiVersion: number };
+
+/** A plugin, stamped with the API version it was written for. */
+export const definePlugin = (spec: PluginSpec): Plugin => ({ ...spec, apiVersion: API_VERSION });

package/src/bare-url.ts

@@ -0,0 +1,35 @@
+import type { Span } from "./plugin.ts";
+
+/**
+ * `https://…` をそのまま書いた URL。GFM の autolink 拡張を入れていないので mdast では
+ * ただのテキストになり、本文として残る。残すと、見出しと URL の中の識別子が一致して
+ * 「見出しの繰り返し」と読まれる。表示される文字も本文ではない。
+ * 空白が来るまでを取るので、URL の直後に続けた日本語（「https://example.jp/をご覧ください」の「をご覧ください」）も入る。
+ */
+export const BARE_URL = /https?:\/\/[^\s)<>"'\]]+/gu;
+
+/** 文の終わりの句読点。URL の最後の字としてはまず書かれず、URL の後ろの文の字。 */
+const PUNCTUATION: ReadonlySet<string> = new Set([".", ",", ";", ":", "!", "?"]);
+
+/**
+ * そのまま書いた URL に続けた文の始まり: ひらがなと全角の句読点・括弧（「…/をご覧ください」「…/。」）。
+ * 漢字やカタカナは道の名前（/東京、/カタログ）にもなるので切らない。
+ */
+const SENTENCE_AFTER = /[\p{Script=Hiragana}\u3000-\u303f\uff01-\uff0f\uff1a-\uff20]/u;
+
+/** URL として読む長さ。続けた文の手前で切り、後ろの句読点を外す。正規表現の `[…]+$` は句読点の長い並びで後戻りが二乗になる。 */
+const urlLength = (written: string): number => {
+  const cut = SENTENCE_AFTER.exec(written)?.index ?? written.length;
+  let end = cut;
+  while (end > 0 && PUNCTUATION.has(written.charAt(end - 1))) end -= 1;
+  return end;
+};
+
+export type BareUrl = Span & { readonly url: string };
+
+/** text の中の、そのまま書いた URL。続けて書いた日本語と文末の句読点は外す。位置は text の先頭を 0 とする。 */
+export const bareUrls = (text: string): BareUrl[] =>
+  [...text.matchAll(BARE_URL)].map((match) => {
+    const url = match[0].slice(0, urlLength(match[0]));
+    return { start: match.index, end: match.index + url.length, url };
+  });

package/src/baseline.ts

@@ -13,6 +13,21 @@ export const fingerprint = (path: string, finding: Finding): string => {
   return createHash("sha256").update(body).digest("hex").slice(0, 16);
 };
 
+/**
+ * findings の fingerprint を順に。一つの文から出た指摘は同じ文を引くので、文と rule の組ごとに一度だけ計算する。
+ * 長い文に指摘が多いと、指摘ごとに文を読み直すのでは指摘数と文の長さの積になる。
+ */
+export const fingerprints = (path: string, findings: readonly Finding[]): string[] => {
+  const known = new Map<string, Map<string, string>>();
+  return findings.map((finding) => {
+    const byRule = known.get(finding.quote) ?? new Map<string, string>();
+    known.set(finding.quote, byRule);
+    const found = byRule.get(finding.rule) ?? fingerprint(path, finding);
+    byRule.set(finding.rule, found);
+    return found;
+  });
+};
+
 export type Baseline = { readonly version: 1; readonly created: string; readonly entries: readonly string[] };
 
 const isBaseline = (value: unknown): value is Baseline =>
@@ -40,7 +55,8 @@ export type Split = { readonly fresh: readonly Finding[]; readonly shelved: numb
 export const splitByBaseline = (path: string, findings: readonly Finding[], baseline: Baseline | undefined): Split => {
   if (baseline === undefined) return { fresh: findings, shelved: 0 };
   const known = new Set(baseline.entries);
-  const fresh = findings.filter((finding) => !known.has(fingerprint(path, finding)));
+  const prints = fingerprints(path, findings);
+  const fresh = findings.filter((_, index) => !known.has(prints[index] ?? ""));
   return { fresh, shelved: findings.length - fresh.length };
 };
 

package/src/body-section.ts

@@ -0,0 +1,7 @@
+import type { Section } from "./plugin.ts";
+
+/**
+ * 本題の始まり: 最初の中見出し（深さ 2 以上）の節。表題（深さ 1）の直後から数えると、表題しか無い文書で全文が前置きになる。
+ * 無ければ、本題の前を測る rule は動けない（rule の requires の headings）。
+ */
+export const bodySectionOf = (sections: readonly Section[]): Section | undefined => sections.find((section) => section.depth >= 2);

package/src/calendar-number.ts

@@ -8,9 +8,15 @@ import type { ProseDocument, Span, Token } from "./plugin.ts";
  * 単位は語彙表から渡す。chained は日付・時刻の単位を大きい順に（年月日時分秒）。大きい単位の後ろに小さい単位を続けて書けば
  * 一つの日付・時刻になる。「2008年 2年連続」のように同じ単位や大きい単位が続けば、別のものの始まり。
  * positional は数の後ろに置くだけで位置を言う単位（月、時）。year は 4 桁の数の後ろで暦の年を言う単位（年、年度）。
+ * era は元号（令和）。元号のすぐ後ろ（空白 1 つまで）の数は、単位が何でも暦の上の位置を言う（令和8年、桁が少なくても年数ではない）。
  * 「5日」「5分」「3年」のように、単位だけでは長さと見分けのつかないものは、位置を言う単位と続けて書いたときだけ日付・時刻と読む。
  */
-export type CalendarUnits = { readonly chained: readonly string[]; readonly positional: ReadonlySet<string>; readonly year: ReadonlySet<string> };
+export type CalendarUnits = {
+  readonly chained: readonly string[];
+  readonly positional: ReadonlySet<string>;
+  readonly year: ReadonlySet<string>;
+  readonly era: readonly string[];
+};
 
 /** 日付・時刻の数の並び。first は日付の頭の数、inner は前の単位に続く数（2026年9月の 9）。unit は数の後ろの単位（月）。 */
 export type CalendarRun = { readonly run: Span; readonly place: "first" | "inner"; readonly unit: string };
@@ -38,15 +44,22 @@ const pastSpace = (text: string, at: number): number => (text[at] === " " ? at +
 
 const isUnit = (surface: string, units: CalendarUnits): boolean => units.chained.includes(surface) || units.positional.has(surface) || units.year.has(surface);
 
-const isAnchor = (digits: string, surface: string, units: CalendarUnits): boolean =>
-  units.positional.has(surface) || (units.year.has(surface) && CALENDAR_YEAR.test(digits));
+/** 数 run のすぐ前（空白 1 つまで）が元号か。 */
+const followsEra = (text: string, run: Span, units: CalendarUnits): boolean => {
+  const before = text.slice(0, run.start);
+  const written = before.endsWith(" ") ? before.slice(0, -1) : before;
+  return units.era.some((era) => written.endsWith(era));
+};
+
+const isAnchor = (text: string, run: Span, surface: string, units: CalendarUnits): boolean =>
+  units.positional.has(surface) || (units.year.has(surface) && CALENDAR_YEAR.test(text.slice(run.start, run.end))) || followsEra(text, run, units);
 
 /** 数のすぐ後ろ（空白 1 つまで）の語が日付・時刻の単位なら、その組。語の切れ目が合わなければ組にしない。 */
 const partOf = (text: string, run: Span, tokens: readonly Token[], base: number, units: CalendarUnits): Part | undefined => {
   const unit = tokens.find((token) => token.span.start === base + pastSpace(text, run.end));
   if (unit === undefined || !isUnit(unit.surface, units)) return undefined;
   const rank = units.chained.indexOf(unit.surface);
-  return { run, unit: unit.surface, unitEnd: unit.span.end - base, rank, anchored: isAnchor(text.slice(run.start, run.end), unit.surface, units) };
+  return { run, unit: unit.surface, unitEnd: unit.span.end - base, rank, anchored: isAnchor(text, run, unit.surface, units) };
 };
 
 /** 前の組の単位のすぐ後ろ（空白 1 つまで）から始まり、単位が前より小さい組か。 */
@@ -81,4 +94,5 @@ export const calendarUnitsOf = (doc: ProseDocument): CalendarUnits => ({
   chained: patternList(doc, "date-time-unit"),
   positional: new Set(patternList(doc, "calendar-unit")),
   year: new Set(patternList(doc, "calendar-year-unit")),
+  era: patternList(doc, "calendar-era"),
 });

package/src/cli-args.ts

@@ -7,3 +7,9 @@ const VALUE_FLAGS: ReadonlySet<string> = new Set(["--sarif", "--genre", "--rule"
 /** The arguments that name what to check: everything that is neither an option nor an option's value. */
 export const targetsOf = (args: readonly string[]): string[] =>
   args.filter((arg, index) => !arg.startsWith("--") && !(index > 0 && VALUE_FLAGS.has(args[index - 1] ?? "")));
+
+/** The settings with --experimental applied: the command line turns experimental rules on as chaff.yaml can. */
+export const withExperimental = <T extends { readonly experimental: boolean }>(config: T, args: readonly string[]): T => ({
+  ...config,
+  experimental: config.experimental || args.includes("--experimental"),
+});

package/src/cli-text.ts

@@ -21,7 +21,12 @@ const USAGE_JA = `chaff — 文章の読みにくいところを見つけます
   chaff genres                   ジャンル（文書の種類）の一覧と、それぞれ何向けか
   chaff tree <file> [--format sexp|json]  文書を番地の付いた木にする（条・項・定義・参照）
   chaff cite <原文> <引用.json>           回答の引用（番地と引用文）が原文にあるかを確かめる
-  chaff rules --json             いまの設定を JSON で出す（AI に渡す用）
+  chaff compare <前> <後>                書き換えで事実（数・日付・URL・コード・名前・引用…）が落ちても足されてもいないかを確かめる
+  chaff facts <file>                     compare が照合する事実を、書き直す前の控えとして一覧にする
+  chaff outline <file> [<後>]            見出しの構成と形（見出しの数・節の平均の長さ・箇条書きの割合・太字）を測る。2 つなら前と後を並べる
+  chaff fix-plan <file> [--json]         指摘をルールごとにまとめ、直す方向と確かめのコマンドを、書き直す人や AI 向けの計画にする（何も送らない）
+  chaff rules                    ルールの一覧を、グループごとに表で出す（いまの段階つき）
+  chaff rules --json             いまの設定とルールの説明を JSON で出す（AI に渡す用）
   chaff baseline <dir>           いまある指摘を棚上げする（既存の repo に入れるとき）
   chaff suppressions <dir>       stet で黙らせている指摘を数える
   chaff relax|strict|off <rule> [--why "理由"]
@@ -55,7 +60,12 @@ const USAGE_EN = `chaff — finds what makes writing hard to read. It never rewr
   chaff genres                   list the genres (kinds of document) and what each is for
   chaff tree <file> [--format sexp|json]  the document as a tree of addresses (sections, clauses, definitions, references)
   chaff cite <source> <quotes.json>       check that quoted passages (address and text) are in the source
-  chaff rules --json             the current settings as JSON (to give to an AI)
+  chaff compare <before> <after>          check that a rewrite dropped no fact and added none (numbers, dates, URLs, code, names, quotations…)
+  chaff facts <file>                      list the facts compare checks, as an inventory to keep before a rewrite
+  chaff outline <file> [<after>]          measure the outline and its shape (headings, average section length, text in lists, bold); two files side by side
+  chaff fix-plan <file> [--json]          a plan for whoever rewrites the file, a person or an AI: findings by rule, how to rewrite each, the checks to run after (sends nothing)
+  chaff rules                    the rules as a table, by group, with the level each runs at now
+  chaff rules --json             the current settings and what each rule is, as JSON (to give to an AI)
   chaff baseline <dir>           shelve today's findings (when adding chaff to an existing repository)
   chaff suppressions <dir>       count the findings silenced with stet
   chaff relax|strict|off <rule> [--why "reason"]
@@ -100,7 +110,6 @@ export type CliText = {
   readonly watching: (files: number, findings: number) => string;
   readonly watchHint: string;
   readonly baselineDone: (files: number, entries: number, file: string) => readonly string[];
-  readonly unit: (ruleId: string, language: string) => string;
 };
 
 export const CLI_TEXT: Texts<CliText> = {
@@ -137,7 +146,7 @@ export const CLI_TEXT: Texts<CliText> = {
     unknownProfile: (profile, where, known) =>
       `文書の種類 "${profile}" はありません（${where}）。使えるのは ${known.join("、")} と、種類を使わない none です。`,
     profileWhere: (where, files) => (where === "config" ? "chaff.yaml の profile" : `chaff.yaml の by_path、files: ${files.join(", ")}`),
-    unknownRule: (id) => `${id} というルールはありません。npx chaff rules --json で一覧が出ます。`,
+    unknownRule: (id) => `${id} というルールはありません。npx chaff rules で一覧が出ます。`,
     unknownRuleWithList: (id, list) => `${id} というルールはありません。\n一覧:\n${list}`,
     unnamed: "(名前なし)",
     sarifWritten: (path, count) => `\n  SARIF を書きました: ${path}（${count} 件）`,
@@ -155,11 +164,6 @@ export const CLI_TEXT: Texts<CliText> = {
       `  ${file} を commit してください。`,
       "",
     ],
-    unit: (ruleId, language) => {
-      if (ruleId === "bold-density") return "1000 字あたりの箇所数";
-      if (ruleId !== "max-sentence-length") return "回";
-      return language === "ja" ? "文字" : "語";
-    },
   },
   en: {
     usage: USAGE_EN,
@@ -191,7 +195,7 @@ export const CLI_TEXT: Texts<CliText> = {
     unknownProfile: (profile, where, known) =>
       `There is no document profile "${profile}" (${where}). The profiles are ${known.join(", ")}; none uses no profile.`,
     profileWhere: (where, files) => (where === "config" ? "profile in chaff.yaml" : `by_path in chaff.yaml, files: ${files.join(", ")}`),
-    unknownRule: (id) => `There is no rule named ${id}. npx chaff rules --json lists them.`,
+    unknownRule: (id) => `There is no rule named ${id}. npx chaff rules lists them.`,
     unknownRuleWithList: (id, list) => `There is no rule named ${id}.\nRules:\n${list}`,
     unnamed: "(no name)",
     sarifWritten: (path, count) => `\n  Wrote SARIF: ${path} (${counted(count, "finding")})`,
@@ -209,10 +213,5 @@ export const CLI_TEXT: Texts<CliText> = {
       `  Commit ${file}.`,
       "",
     ],
-    unit: (ruleId, language) => {
-      if (ruleId === "bold-density") return "places per 1000 characters";
-      if (ruleId !== "max-sentence-length") return "times";
-      return language === "ja" ? "characters" : "words";
-    },
   },
 };