chaffjs 0.18.0 → 0.20.0

package/src/facts/table-facts.ts

@@ -0,0 +1,71 @@
+import type { Span } from "../plugin.ts";
+import { linesOf, type Line } from "../structure/lines.ts";
+import { TABLE_RULE } from "../structure/runs.ts";
+import { CELL_SEPARATOR } from "../structure/bare-numbers.ts";
+import type { FactValue } from "./fact-values.ts";
+import type { Fact } from "./labelled-facts.ts";
+import { withoutEdgeMarks } from "./trim-marks.ts";
+
+/**
+ * 表の升の値。名前は行の見出し（最初の列）で、列が三つ以上なら列の見出しも付ける（「大人 料金」）。
+ * 升に値だけを書いたときだけ読む。「3,000円（税込）」のように条件を書いた升は読まない。
+ * 行の見出しが値を含むか字を含まない表（日付の列から始まる日程表）は、行に名前が無いので読まない。
+ */
+type Cell = Span & { readonly text: string };
+
+const LETTER = /\p{L}/u;
+const TWO_COLUMNS = 2;
+
+const cellsOf = (line: Line): Cell[] => {
+  const bounds = [-1, ...[...line.text.matchAll(CELL_SEPARATOR)].map((match) => match.index), line.text.length];
+  const cells = bounds.slice(1).map((end, index) => {
+    const from = (bounds[index] ?? 0) + 1;
+    return { start: line.start + from, end: line.start + end, text: line.text.slice(from, end) };
+  });
+  const trimmed = line.text.trim();
+  return cells.slice(trimmed.startsWith("|") ? 1 : 0, trimmed.endsWith("|") ? cells.length - 1 : cells.length);
+};
+
+const plain = withoutEdgeMarks;
+
+/** 区切り行（|---|）の前の行が見出し、後ろに続く | の行が本体。 */
+const tablesOf = (lines: readonly Line[]): { header: Line; rows: Line[] }[] =>
+  lines.flatMap((line, index) => {
+    const header = lines[index - 1];
+    if (!TABLE_RULE.test(line.text) || header === undefined || !header.text.includes("|")) return [];
+    const after = lines.slice(index + 1);
+    const end = after.findIndex((row) => !row.text.includes("|"));
+    return [{ header, rows: end === -1 ? after : after.slice(0, end) }];
+  });
+
+const inside = (cell: Span, value: FactValue): boolean => value.start >= cell.start && value.end <= cell.end;
+
+/** 升の値。升の字（強調を除く）がちょうど一つの値のときだけ。 */
+const cellValue = (cell: Cell, values: readonly FactValue[], source: string): FactValue | undefined => {
+  const within = values.filter((value) => inside(cell, value));
+  const only = within.length === 1 ? within[0] : undefined;
+  return only !== undefined && source.slice(only.start, only.end) === plain(cell.text) ? only : undefined;
+};
+
+const keyOf = (label: string): string => label.normalize("NFKC").toLowerCase().replace(/\s+/gu, " ");
+
+const rowFacts = (row: Line, headings: readonly string[], values: readonly FactValue[], source: string): Fact[] => {
+  const [first, ...rest] = cellsOf(row);
+  if (first === undefined) return [];
+  const rowLabel = plain(first.text);
+  if (!LETTER.test(rowLabel) || values.some((value) => inside(first, value))) return [];
+  return rest.flatMap((cell, index) => {
+    const value = cellValue(cell, values, source);
+    const column = headings[index + 1] ?? "";
+    if (value === undefined || (headings.length > TWO_COLUMNS && column === "")) return [];
+    const label = headings.length > TWO_COLUMNS ? `${rowLabel} ${column}` : rowLabel;
+    return [{ label, key: keyOf(label), value }];
+  });
+};
+
+/** 文書の表すべての升の値。 */
+export const tableFacts = (source: string, values: readonly FactValue[]): Fact[] =>
+  tablesOf(linesOf(source)).flatMap((table) => {
+    const headings = cellsOf(table.header).map((cell) => plain(cell.text));
+    return table.rows.flatMap((row) => rowFacts(row, headings, values, source));
+  });

package/src/facts/trim-marks.ts

@@ -0,0 +1,18 @@
+/** 名前や値の端の、強調の印と空白。全角の空白も入れる。 */
+export const EDGE_MARKS: ReadonlySet<string> = new Set(["*", "_", " ", "\t", "　"]);
+
+/** 後ろの端から、chars の字を落とす。正規表現の [..]*$ は長い行で後戻りが重くなるので、端から数える。 */
+export const trimEndOf = (text: string, chars: ReadonlySet<string>): string => {
+  let end = text.length;
+  while (end > 0 && chars.has(text.charAt(end - 1))) end -= 1;
+  return text.slice(0, end);
+};
+
+const trimStartOf = (text: string, chars: ReadonlySet<string>): string => {
+  let start = 0;
+  while (start < text.length && chars.has(text.charAt(start))) start += 1;
+  return text.slice(start);
+};
+
+/** 両端から、強調の印と空白を落とす。 */
+export const withoutEdgeMarks = (text: string): string => trimStartOf(trimEndOf(text, EDGE_MARKS), EDGE_MARKS);

package/src/facts/unit-conflicts.ts

@@ -0,0 +1,45 @@
+import type { ScopedFact } from "./fact-scope.ts";
+import { sameMeasure, type Measured } from "./measures.ts";
+
+/**
+ * 同じ名前の量を、違う単位で書いて、換算すると合わない（「距離：5 km」と「距離：3000 m」）。比べるのは同じ範囲の、同じ種類の量で、
+ * 単位が違うものだけ。同じ単位どうしの食い違いは fact-conflict が見る。丸めた書き方（1 mile と 1.6 km）は、差が TOLERANCE 以内なら合う。
+ */
+export type UnitConflict = { readonly fact: ScopedFact; readonly measured: Measured; readonly other: Measured };
+
+const TOLERANCE = 0.02;
+
+const groupKey = (fact: ScopedFact): string => `${fact.scope}\u0000${fact.key}`;
+
+type Read = { readonly fact: ScopedFact; readonly measured: Measured };
+
+/**
+ * 一つの種類（長さなら長さ）の量のうち、前にある単位の違う量のどれとも換算して合わないもの。どれか一つと合えば、食い違いは同じ単位
+ * どうし（3 km と 5 km）の側にあり、fact-conflict が見る。
+ */
+const conflictsInDimension = (reads: readonly Read[]): UnitConflict[] =>
+  reads.flatMap(({ fact, measured }, index) => {
+    const others = reads.slice(0, index).filter((earlier) => earlier.measured.unit !== measured.unit);
+    const [first] = others;
+    if (first === undefined || others.some((earlier) => sameMeasure(earlier.measured, measured, TOLERANCE))) return [];
+    return [{ fact, measured, other: first.measured }];
+  });
+
+const conflictsIn = (reads: readonly Read[]): UnitConflict[] => {
+  if (reads.some(({ fact }) => fact.record)) return [];
+  const dimensions = [...new Set(reads.map(({ measured }) => measured.dimension))];
+  return dimensions.flatMap((dimension) => conflictsInDimension(reads.filter(({ measured }) => measured.dimension === dimension)));
+};
+
+/** 範囲と名前ごとに、最初の量と単位の違う量を換算して比べる。 */
+export const unitConflicts = (facts: readonly ScopedFact[], measuredOf: (fact: ScopedFact) => Measured | undefined): UnitConflict[] => {
+  const groups = new Map<string, Read[]>();
+  facts.forEach((fact) => {
+    const measured = measuredOf(fact);
+    if (measured === undefined) return;
+    const group = groups.get(groupKey(fact));
+    if (group === undefined) groups.set(groupKey(fact), [{ fact, measured }]);
+    else group.push({ fact, measured });
+  });
+  return [...groups.values()].flatMap(conflictsIn);
+};

package/src/feedback/draft.ts

@@ -12,6 +12,8 @@ export type FeedbackInput = {
   readonly fileName: string;
   readonly language: string;
   readonly genre: string;
+  /** How the check was run (--experimental, --genre …), so the reader can run the same check. */
+  readonly conditions: readonly string[];
   readonly findings: readonly ReportedFinding[];
   /** The line the person reported: the finding's line, or for a miss the line they named. */
   readonly line: number;
@@ -26,6 +28,7 @@ const TEXT: Texts<{
   readonly titleMissed: (fileName: string, line: number) => string;
   readonly what: Readonly<Record<FeedbackKind, string>>;
   readonly environment: string;
+  readonly ranWith: string;
   readonly findings: string;
   readonly excerpt: string;
   readonly config: string;
@@ -38,6 +41,7 @@ const TEXT: Texts<{
     titleMissed: (fileName, line) => `見逃し: ${fileName} の ${String(line)} 行目`,
     what: { "false-positive": "この指摘は誤りだと思います。", missed: "ここで chaff は何か言うべきだと思います。" },
     environment: "環境",
+    ranWith: "実行の条件",
     findings: "指摘",
     excerpt: "文書の該当箇所（この部分だけを載せています）",
     config: "chaff.yaml",
@@ -53,6 +57,7 @@ const TEXT: Texts<{
     titleMissed: (fileName, line) => `Missed: ${fileName} line ${String(line)}`,
     what: { "false-positive": "I think this finding is wrong.", missed: "I think chaff should say something here." },
     environment: "Environment",
+    ranWith: "Run with",
     findings: "Findings",
     excerpt: "The part of the document (only these lines are included)",
     config: "chaff.yaml",
@@ -85,6 +90,7 @@ export const feedbackDraft = (input: FeedbackInput, ui: UiLanguage): FeedbackDra
     `- chaffjs ${input.version}`,
     `- ${input.runtime}`,
     `- ${input.fileName} · ${input.language} · ${input.genre}`,
+    ...(input.conditions.length === 0 ? [] : [`- ${text.ranWith}: ${input.conditions.join(" ")}`]),
     ...(input.findings.length === 0
       ? []
       : ["", `## ${text.findings}`, "", ...input.findings.map((finding) => `- \`${finding.rule}\` (${String(finding.line)}): ${finding.message}`)]),

package/src/figure-references.ts

@@ -1,5 +1,6 @@
 import { escapeRegExp } from "./orthography.ts";
-import type { Span } from "./plugin.ts";
+import { lowerBound } from "./detectors/token-column.ts";
+import type { DocumentNamer, Span } from "./plugin.ts";
 
 /**
  * 本文で番号を指した図・表・付録（図3、Table 2、Appendix B）と、それを行の頭に書いた所（キャプション、見出し）。
@@ -22,22 +23,27 @@ export type LabelWords = {
 
 export type DanglingFigure = { readonly offset: number; readonly label: string };
 
-type Mention = { readonly start: number; readonly end: number; readonly written: string; readonly key: string; readonly kind: string };
+export type Mention = { readonly start: number; readonly end: number; readonly written: string; readonly key: string; readonly kind: string };
 
 /** 語の前の字が漢字・カタカナ・英数字なら、長い語の一部（地図3、一覧表2、法別表第二、SubFigure）。 */
 const INSIDE_WORD = "(?<![\\p{Script=Han}\\p{Script=Katakana}\\p{N}A-Za-z])";
 /** 番号。数字（3、3.2、第3）、「第」の後の漢数字（別表第一）、大文字一つかローマ数字（Appendix B、Annex II）。 */
-const NUMBER = "[ \\t\\u00a0]?(?:第?(\\p{Nd}+(?:[.\\-－]\\p{Nd}+)*)|第([一二三四五六七八九十百]+)|([IVX]{2,5}|[A-ZＡ-Ｚ])(?![A-Za-z]))";
+export const FIGURE_NUMBER = "[ \\t\\u00a0]?(?:第?(\\p{Nd}+(?:[.\\-－]\\p{Nd}+)*)|第([一二三四五六七八九十百]+)|([IVX]{2,5}|[A-ZＡ-Ｚ])(?![A-Za-z]))";
 
 const forms = (word: string): string[] => [...new Set([word, word.toUpperCase()])];
 
-const mentionPattern = (labels: readonly LabelWord[]): RegExp => {
-  const words = labels
+const labelAlternation = (labels: readonly LabelWord[]): string =>
+  labels
     .flatMap((label) => forms(label.word))
     .toSorted((a, b) => b.length - a.length)
-    .map(escapeRegExp);
-  return new RegExp(`${INSIDE_WORD}(${words.join("|")})${NUMBER}`, "gu");
-};
+    .map(escapeRegExp)
+    .join("|");
+
+const mentionPattern = (labels: readonly LabelWord[]): RegExp => new RegExp(`${INSIDE_WORD}(${labelAlternation(labels)})${FIGURE_NUMBER}`, "gu");
+
+/** 番号の付いた図か、番号の無い図（「…の別表に」）。番号が無ければ後ろが長い語の続きでない（表示、別表第一の「第」は番号）。 */
+const labelPattern = (labels: readonly LabelWord[]): RegExp =>
+  new RegExp(`${INSIDE_WORD}(${labelAlternation(labels)})(?:${FIGURE_NUMBER}|(?![\\p{Script=Han}\\p{Script=Katakana}A-Za-z]))`, "gu");
 
 const kindOf = (written: string, labels: readonly LabelWord[]): string => labels.find((label) => forms(label.word).includes(written))?.kind ?? written;
 
@@ -95,18 +101,92 @@ const pointsHere = (text: string, mention: Mention, words: LabelWords): boolean
   return !elsewhere && !words.counters.some((word) => after.startsWith(word));
 };
 
+/** 行の頭に書いた番号（キャプションや見出し）。図の置き場所。 */
+const labelledIn = (source: string, labels: readonly LabelWord[]): Mention[] => mentionsIn(source, labels).filter((mention) => isLabelled(source, mention));
+
+/** 文書が行の頭に番号を書いている種類（図、Table）。番号で名指しできる種類。 */
+export const labelledKindsIn = (source: string, words: LabelWords): ReadonlySet<string> =>
+  new Set(labelledIn(source, words.labels).map((mention) => mention.kind));
+
+/** 文書の名前を読む言語の知識と、その名前が届く範囲（文）。 */
+export type Citations = { readonly namedDocument: DocumentNamer; readonly sentences: readonly Span[] };
+
+type NamedLabel = { readonly start: number; readonly kind: string; readonly self: boolean };
+
+/** 文書の名前のすぐ後ろに書いた図の語（「…(平成二十年厚生労働省告示第五十九号)別表第一」「…号)の別表」「この規則の別表第三」）。 */
+const namedLabelsIn = (prose: string, labels: readonly LabelWord[], namedDocument: DocumentNamer): NamedLabel[] =>
+  [...prose.matchAll(labelPattern(labels))].flatMap((match) => {
+    const named = namedDocument(prose, match.index);
+    return named === undefined ? [] : [{ start: match.index, kind: kindOf(match[1] ?? "", labels), self: named.self }];
+  });
+
+/** offset を含む文の頭。文の外（見出し）なら offset。文は文書の順に並んでいる。 */
+const sentenceStartAt = (sentences: readonly Span[], starts: readonly number[], offset: number): number => {
+  const sentence = sentences[lowerBound(starts, offset + 1) - 1];
+  return sentence !== undefined && offset < sentence.end ? sentence.start : offset;
+};
+
+/**
+ * 他の文書の図か。同じ文の中で、その番号の位置までに名前を添えて書いた同じ種類の図のうち、いちばん近いものが他の文書のもの。
+ * 「(…告示第五十九号)別表第一…及び別表第二」「…別表第一から別表第三まで」の後ろの番号も、その告示の別表。
+ * 「…手数料規則の別表第二により、この規則の別表第三による」の別表第三は、この文書のものと名指している。
+ * 文と名前の位置は二分探索で引く。参照先の無い番号が何万あっても、文書の長さの二乗にしない。
+ */
+const citedElsewhere = (named: readonly NamedLabel[], sentences: readonly Span[]): ((mention: Mention) => boolean) => {
+  const starts = sentences.map((sentence) => sentence.start);
+  const byKind = new Map(
+    [...new Set(named.map((label) => label.kind))].map((kind) => {
+      const labels = named.filter((label) => label.kind === kind);
+      return [kind, { labels, starts: labels.map((label) => label.start) }];
+    }),
+  );
+  return (mention) => {
+    const ofKind = byKind.get(mention.kind);
+    const nearest = ofKind?.labels[lowerBound(ofKind.starts, mention.start + 1) - 1];
+    return nearest !== undefined && !nearest.self && nearest.start >= sentenceStartAt(sentences, starts, mention.start);
+  };
+};
+
 /**
  * 参照先の無い番号。source は行の頭を読み、prose（コードを覆った本文）は参照を読む。位置は同じ。
  * 番号は、キャプションが 1 と書けば 1a や 1(b) の参照も 1 に当たる（番号の後ろの字は読まない）。
  * リンクの字（[Figure 2](figures.md)）は、そのリンクが行き先を持つので参照として見ない。
  */
-export const danglingFigures = (source: string, prose: string, words: LabelWords, links: readonly Span[] = []): DanglingFigure[] => {
+export const danglingFigures = (
+  source: string,
+  prose: string,
+  words: LabelWords,
+  links: readonly Span[] = [],
+  citations: Citations | undefined = undefined,
+): DanglingFigure[] => {
   if (words.labels.length === 0) return [];
-  const labelled = mentionsIn(source, words.labels).filter((mention) => isLabelled(source, mention));
+  const labelled = labelledIn(source, words.labels);
   const labelledKeys = new Set(labelled.map((mention) => mention.key));
   const labelledKinds = new Set(labelled.map((mention) => mention.kind));
-  return mentionsIn(prose, words.labels)
+  const dangling = mentionsIn(prose, words.labels)
     .filter((mention) => labelledKinds.has(mention.kind) && !labelledKeys.has(mention.key))
-    .filter((mention) => pointsHere(prose, mention, words) && !links.some((link) => link.start <= mention.start && mention.end <= link.end))
-    .map((mention) => ({ offset: mention.start, label: mention.written }));
+    .filter((mention) => pointsHere(prose, mention, words) && !links.some((link) => link.start <= mention.start && mention.end <= link.end));
+  // 他の文書の名前は、参照先の無い番号があるときだけ読む。図の語のたびに名前を後ろ向きに読む代金を、ふつうの文書に払わせない。
+  const named = dangling.length === 0 || citations === undefined ? [] : namedLabelsIn(prose, words.labels, citations.namedDocument);
+  const elsewhere = named.length === 0 || citations === undefined ? () => false : citedElsewhere(named, citations.sentences);
+  return dangling.filter((mention) => !elsewhere(mention)).map((mention) => ({ offset: mention.start, label: mention.written }));
+};
+
+/**
+ * The document's captions (a number at the start of a line) and its references in the text (every other mention that
+ * points at this document, outside a link), each in document order. Only the kinds the document labels somewhere.
+ */
+export const figureMentions = (
+  source: string,
+  prose: string,
+  words: LabelWords,
+  links: readonly Span[] = [],
+): { readonly captions: readonly Mention[]; readonly references: readonly Mention[] } => {
+  if (words.labels.length === 0) return { captions: [], references: [] };
+  const captions = labelledIn(source, words.labels);
+  const kinds = new Set(captions.map((mention) => mention.kind));
+  const references = mentionsIn(prose, words.labels)
+    .filter((mention) => kinds.has(mention.kind) && !isLabelled(source, mention))
+    .filter((mention) => pointsHere(prose, mention, words) && !links.some((link) => link.start <= mention.start && mention.end <= link.end));
+  return { captions, references };
 };

package/src/files.ts

@@ -1,12 +1,13 @@
 import { globSync, statSync } from "node:fs";
 import { readFile } from "node:fs/promises";
-import { join, relative, sep } from "node:path";
+import { join, matchesGlob, relative, sep } from "node:path";
 import { plainSource } from "./plain-source.ts";
 
 /** 検査する文書を読む。言語・ジャンル・stet も文書モデルと同じ本文（BOM と CRLF / CR をそろえたもの）で読むため、ここでそろえる。 */
 export const readDocumentFile = async (path: string): Promise<string> => plainSource(await readFile(path, "utf8"));
 
-const MARKDOWN = [".md", ".markdown", ".mdx"];
+/** What a directory walk finds without include: Markdown. */
+export const MARKDOWN = [".md", ".markdown", ".mdx"];
 
 /** 走査から外す。ここを通すと node_modules の README を延々と検査することになる。 */
 const SKIP: ReadonlySet<string> = new Set(["node_modules", "dist", "build", "coverage", ".git", ".chaff-cache"]);
@@ -15,12 +16,17 @@ const isMarkdown = (path: string): boolean => MARKDOWN.some((ext) => path.toLowe
 
 const isSkipped = (path: string): boolean => path.split(sep).some((part) => SKIP.has(part));
 
-const expand = (target: string): string[] => {
-  const stat = statSync(target, { throwIfNoEntry: false });
-  if (stat === undefined) return globSync(target).filter(isMarkdown);
-  if (stat.isFile()) return [target];
-  return globSync(join(target, "**", "*.{md,markdown,mdx}"));
-};
+/** include: file-name globs (*.yaml) a walk takes besides Markdown. A glob with a slash is matched below each folder walked. */
+const isIncluded = (path: string, include: readonly string[]): boolean => include.some((pattern) => matchesGlob(path, join("**", pattern)));
+
+const expand =
+  (include: readonly string[]) =>
+  (target: string): string[] => {
+    const stat = statSync(target, { throwIfNoEntry: false });
+    if (stat === undefined) return globSync(target).filter((path) => isMarkdown(path) || isIncluded(path, include));
+    if (stat.isFile()) return [target];
+    return [join(target, "**", "*.{md,markdown,mdx}"), ...include.map((pattern) => join(target, "**", pattern))].flatMap((pattern) => globSync(pattern));
+  };
 
 /**
  * 与えられたファイル・ディレクトリ・glob を、検査する Markdown の一覧にする。
@@ -33,7 +39,7 @@ const expand = (target: string): string[] => {
  */
 const byPath = (left: string, right: string): number => left.localeCompare(right, "en");
 
-export const collectTargets = (targets: readonly string[]): string[] => {
-  const found = targets.flatMap(expand).filter((path) => !isSkipped(path));
+export const collectTargets = (targets: readonly string[], include: readonly string[] = []): string[] => {
+  const found = targets.flatMap(expand(include)).filter((path) => !isSkipped(path));
   return [...new Set(found)].toSorted((left, right) => byPath(relative(".", left), relative(".", right)));
 };

package/src/finding-order.ts

@@ -0,0 +1,3 @@
+/** 指摘を文書の中の位置の順に並べる。同じ行では桁の順。rule ごとの並びを残さない。 */
+export const byPosition = (left: { readonly line: number; readonly column: number }, right: { readonly line: number; readonly column: number }): number =>
+  left.line - right.line || left.column - right.column;

package/src/fix-plan/mode.ts

@@ -0,0 +1,40 @@
+/**
+ * Which of the three ways to rewrite (the guide's Light, Bold and Full) chaff recommends, from what it found alone.
+ * A request that says "from scratch" also means Full; chaff cannot read the request, so the plan says so in words.
+ */
+export type FixMode = "none" | "light" | "bold" | "full";
+
+/** Why the mode was chosen, so the plan can say it. */
+export type ModeReason = "nothing-found" | "composite" | "structure" | "genre" | "signals" | "spots";
+
+export type ModeChoice = { readonly mode: FixMode; readonly reason: ModeReason };
+
+export type ModeInput = {
+  readonly genre: string;
+  /** The rules with at least one finding. */
+  readonly firedRules: ReadonlySet<string>;
+  /** The rules that measure the whole document: ai-generated-composite's inputs and bold-density. */
+  readonly signalRules: ReadonlySet<string>;
+  /** The structure score (measures past 90% of human articles) and the count at which the outline itself is the problem. */
+  readonly structure?: { readonly score: number; readonly limit: number };
+};
+
+export const COMPOSITE_RULE = "ai-generated-composite";
+
+/** Two document-wide signals mean the prose of the sections is the problem, not a spot or two. */
+const MIN_SIGNALS_FOR_BOLD = 2;
+
+/** A blog post or an essay is rewritten from its structure up: what the writer wants changed there is the structure. */
+const isFreeFormGenre = (genre: string): boolean => genre.startsWith("blog/") || genre === "literature/essay";
+
+/** An outline far from human articles is rewritten from the outline, in any genre and whether or not a rule fired. */
+const hasStructureToFix = (input: ModeInput): boolean => input.structure !== undefined && input.structure.score >= input.structure.limit;
+
+export const recommendMode = (input: ModeInput): ModeChoice => {
+  if (input.firedRules.has(COMPOSITE_RULE)) return { mode: "full", reason: "composite" };
+  if (hasStructureToFix(input)) return { mode: "full", reason: "structure" };
+  if (input.firedRules.size === 0) return { mode: "none", reason: "nothing-found" };
+  if (isFreeFormGenre(input.genre)) return { mode: "full", reason: "genre" };
+  const signals = [...input.firedRules].filter((rule) => input.signalRules.has(rule)).length;
+  return signals >= MIN_SIGNALS_FOR_BOLD ? { mode: "bold", reason: "signals" } : { mode: "light", reason: "spots" };
+};

package/src/fix-plan/plan.ts

@@ -0,0 +1,202 @@
+import type { Finding, LengthUnit, Lexicon, RuleDefinition } from "../plugin.ts";
+import type { RewritePair } from "../rule-guide.ts";
+import type { Skipped } from "../run.ts";
+import type { Outline, Shape } from "../outline/shape.ts";
+import { localized, messageOf } from "../render/text.ts";
+import { splitWords } from "../detectors/word-list.ts";
+import { COMPOSITE_RULE, recommendMode, type ModeChoice } from "./mode.ts";
+import type { StructureScore } from "../structure-shape/score.ts";
+import { structureTargetsOf, type StructureTarget } from "./structure-targets.ts";
+
+/** One flagged spot, where it is and what chaff said about it. */
+export type PlanSpot = { readonly line: number; readonly column: number; readonly quote: string; readonly message: string };
+
+/** A phrase's own hint from the lexicon ("時間を溶かす" → "時間がかかった（何に、どれだけ）"). */
+export type PhraseHint = { readonly phrase: string; readonly rewrite: string };
+
+/** Everything a rewriter needs for one rule: its direction and the spots it flagged. */
+export type RulePlan = {
+  readonly rule: string;
+  readonly name: string;
+  /** The rule's rewrite direction, or its how_to_fix when it has no rewrite block. */
+  readonly direction: string;
+  readonly keep: readonly string[];
+  readonly avoid: readonly string[];
+  /** The first of the rule's pairs, to copy the shape from. */
+  readonly pair: RewritePair | undefined;
+  readonly hints: readonly PhraseHint[];
+  readonly spots: readonly PlanSpot[];
+};
+
+/** A rule that measures the whole document, with what it said. */
+type DocumentSignal = { readonly rule: string; readonly message: string };
+
+export type FixPlan = {
+  readonly path: string;
+  /** Where the plan suggests saving the rewrite, so the check commands can be pasted as they are. */
+  readonly rewrittenPath: string;
+  readonly language: string;
+  readonly genre: string;
+  readonly experimental: boolean;
+  readonly mode: ModeChoice;
+  readonly signals: readonly DocumentSignal[];
+  readonly outline: { readonly unit: LengthUnit; readonly shape: Shape };
+  /** The structure score, the count at which the plan rewrites from the outline, and how many measures were compared. */
+  readonly structure: { readonly score: number; readonly limit: number; readonly compared: number };
+  /** The structure measures past 90% of human articles, each with the human numbers to bring it back to. */
+  readonly targets: readonly StructureTarget[];
+  readonly rules: readonly RulePlan[];
+  /** The rewrite and signal rules that did not run, and why: silence from them is not "checked and fine". */
+  readonly notRun: readonly Skipped[];
+  readonly checks: readonly string[];
+};
+
+export type PlanInput = {
+  readonly path: string;
+  readonly language: string;
+  readonly genre: string;
+  readonly experimental: boolean;
+  /** --genre as given on the command line, repeated in the check commands. */
+  readonly genreFlag: string | undefined;
+  readonly findings: readonly Finding[];
+  readonly rules: readonly RuleDefinition[];
+  readonly skipped: readonly Skipped[];
+  readonly outline: Outline;
+  /** The document's structure measures against human articles (chaff outline's structure block). */
+  readonly structure: StructureScore;
+  /** The ai-tell lexicon of the document's language, whose entries may carry their own hint. */
+  readonly phrases: Lexicon;
+};
+
+const BOLD_DENSITY_RULE = "bold-density";
+const STRUCTURE_RULE = "ai-structure";
+/** ai-structure's count at its normal level, when its rule file does not say. */
+const DEFAULT_STRUCTURE_LIMIT = 3;
+const AI_TELL_RULE = "ai-tell";
+
+/** ai-generated-composite's inputs and bold-density: the rules the guide reads as document-level signals. */
+const signalRulesOf = (rules: readonly RuleDefinition[]): ReadonlySet<string> =>
+  new Set([...(rules.find((rule) => rule.id === COMPOSITE_RULE)?.from ?? []), BOLD_DENSITY_RULE]);
+
+/** article.md → article.rewritten.md, beside the original. */
+export const rewrittenPathOf = (path: string): string => {
+  const dot = path.lastIndexOf(".");
+  const slash = path.lastIndexOf("/");
+  return dot > slash + 1 ? `${path.slice(0, dot)}.rewritten${path.slice(dot)}` : `${path}.rewritten`;
+};
+
+const SHELL_SAFE = /^[\w./-]+$/u;
+
+/** A single quote inside single quotes: close, an escaped quote, reopen. */
+const QUOTE_IN_QUOTES = "'\\''";
+
+/** A path as a shell reads it: quoted unless every character is plain. */
+export const shellPath = (path: string): string => (SHELL_SAFE.test(path) ? path : `'${path.replaceAll("'", QUOTE_IN_QUOTES)}'`);
+
+/** The ai-tell phrases the finding names that carry a hint of their own. */
+export const phraseHintsOf = (finding: Finding, phrases: Lexicon, language: string): PhraseHint[] => {
+  const named = new Set(splitWords(String(finding.values["word"] ?? ""), language));
+  return phrases.flatMap((entry) =>
+    entry.rewrite !== undefined && named.has(entry.pattern.toLowerCase()) ? [{ phrase: entry.pattern, rewrite: entry.rewrite }] : [],
+  );
+};
+
+const spotOf = (finding: Finding, rule: RuleDefinition, language: string): PlanSpot => ({
+  line: finding.line,
+  column: finding.column,
+  quote: finding.quote,
+  message: messageOf(rule, finding, language),
+});
+
+const rulePlanOf = (rule: RuleDefinition, findings: readonly Finding[], input: PlanInput): RulePlan => {
+  const rewrite = rule.guide?.rewrite[input.language];
+  const hints = rule.id === AI_TELL_RULE ? findings.flatMap((finding) => phraseHintsOf(finding, input.phrases, input.language)) : [];
+  return {
+    rule: rule.id,
+    name: localized(rule.name, input.language),
+    direction: rewrite?.direction ?? localized(rule.how_to_fix, input.language),
+    keep: rewrite?.keep ?? [],
+    avoid: rewrite?.avoid ?? [],
+    pair: rewrite?.pairs[0],
+    hints,
+    spots: findings.map((finding) => spotOf(finding, rule, input.language)),
+  };
+};
+
+/** The rules in the order their first finding appears; the composite has no spot of its own and is a signal only. */
+const rulePlansOf = (input: PlanInput): RulePlan[] => {
+  const order = [...new Set(input.findings.map((finding) => finding.rule))].filter((id) => id !== COMPOSITE_RULE);
+  return order.flatMap((id) => {
+    const rule = input.rules.find((entry) => entry.id === id);
+    return rule === undefined
+      ? []
+      : [
+          rulePlanOf(
+            rule,
+            input.findings.filter((finding) => finding.rule === id),
+            input,
+          ),
+        ];
+  });
+};
+
+/** The composite first, then each signal rule once, with what its first finding said. */
+const signalsOf = (input: PlanInput, signalRules: ReadonlySet<string>): DocumentSignal[] =>
+  [COMPOSITE_RULE, ...signalRules].flatMap((id) => {
+    const finding = input.findings.find((entry) => entry.rule === id);
+    const rule = input.rules.find((entry) => entry.id === id);
+    return finding === undefined || rule === undefined ? [] : [{ rule: id, message: messageOf(rule, finding, input.language) }];
+  });
+
+const hasRewrite = (rule: RuleDefinition): boolean => Object.keys(rule.guide?.rewrite ?? {}).length > 0;
+
+/** A rule written for other languages is not one that failed to run on this document. */
+const checksLanguage = (rule: RuleDefinition, language: string): boolean => rule.languages === undefined || rule.languages.includes(language);
+
+const notRunOf = (input: PlanInput, signalRules: ReadonlySet<string>): Skipped[] => {
+  const forThisLanguage = input.rules.filter((rule) => checksLanguage(rule, input.language));
+  const watched = new Set(forThisLanguage.filter((rule) => hasRewrite(rule) || rule.id === COMPOSITE_RULE || signalRules.has(rule.id)).map((rule) => rule.id));
+  return input.skipped.filter((skipped) => watched.has(skipped.rule));
+};
+
+/** The commands to run on the rewrite. A full rewrite cuts repeats and rebuilds headings, which compare is told. */
+const checksOf = (input: PlanInput, choice: ModeChoice): string[] => {
+  const original = shellPath(input.path);
+  const rewritten = shellPath(rewrittenPathOf(input.path));
+  const lintFlags = [...(input.experimental ? ["--experimental"] : []), ...(input.genreFlag === undefined ? [] : ["--genre", input.genreFlag])];
+  const compareFlags = choice.mode === "full" ? ["--distinct", "--allow-dropped heading", "--allow-added heading"] : [];
+  return [
+    ["npx chaffjs", rewritten, ...lintFlags].join(" "),
+    ["npx chaffjs compare", original, rewritten, ...compareFlags].join(" "),
+    ["npx chaffjs outline", original, rewritten].join(" "),
+  ];
+};
+
+/** The count ai-structure fires at by default: the same line decides when the plan rewrites from the outline. */
+const structureLimitOf = (rules: readonly RuleDefinition[]): number =>
+  rules.find((rule) => rule.id === STRUCTURE_RULE)?.levels.normal ?? DEFAULT_STRUCTURE_LIMIT;
+
+const documentLength = (outline: Outline): number => outline.entries.reduce((sum, entry) => sum + entry.length, 0);
+
+/** The plan for one document: deterministic, from chaff's findings, the rule files and the human baseline alone. */
+export const buildFixPlan = (input: PlanInput): FixPlan => {
+  const signalRules = signalRulesOf(input.rules);
+  const structure = { score: input.structure.score, limit: structureLimitOf(input.rules), compared: input.structure.compared };
+  const firedRules = new Set(input.findings.map((finding) => finding.rule));
+  const mode = recommendMode({ genre: input.genre, firedRules, signalRules, structure });
+  return {
+    path: input.path,
+    rewrittenPath: rewrittenPathOf(input.path),
+    language: input.language,
+    genre: input.genre,
+    experimental: input.experimental,
+    mode,
+    signals: signalsOf(input, signalRules),
+    outline: { unit: input.outline.unit, shape: input.outline.shape },
+    structure,
+    targets: structureTargetsOf(input.structure, documentLength(input.outline)),
+    rules: rulePlansOf(input),
+    notRun: notRunOf(input, signalRules),
+    checks: checksOf(input, mode),
+  };
+};