chaffjs 0.16.0 → 0.18.0

package/src/cli-text.ts

@@ -21,7 +21,9 @@ const USAGE_JA = `chaff — 文章の読みにくいところを見つけます
   chaff genres                   ジャンル（文書の種類）の一覧と、それぞれ何向けか
   chaff tree <file> [--format sexp|json]  文書を番地の付いた木にする（条・項・定義・参照）
   chaff cite <原文> <引用.json>           回答の引用（番地と引用文）が原文にあるかを確かめる
-  chaff rules --json             いまの設定を JSON で出す（AI に渡す用）
+  chaff compare <前> <後>                書き換えで事実（数・日付・URL・コード・名前・引用…）が落ちても足されてもいないかを確かめる
+  chaff rules                    ルールの一覧を、グループごとに表で出す（いまの段階つき）
+  chaff rules --json             いまの設定とルールの説明を JSON で出す（AI に渡す用）
   chaff baseline <dir>           いまある指摘を棚上げする（既存の repo に入れるとき）
   chaff suppressions <dir>       stet で黙らせている指摘を数える
   chaff relax|strict|off <rule> [--why "理由"]
@@ -55,7 +57,9 @@ 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 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"]
@@ -137,7 +141,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} 件）`,
@@ -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")})`,

package/src/cli.ts

@@ -1,15 +1,13 @@
-import { readFile } from "node:fs/promises";
-import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { mkdirSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { loadAdapter, packageFor } from "./adapter-load.ts";
-import { CONFIG_FILE, EMPTY, loadConfig, type Config } from "./config/load.ts";
+import { CONFIG_FILE, type Config } from "./config/load.ts";
 import { applyByPath } from "./config/by-path.ts";
 import { applyLevel } from "./config/write.ts";
 import { buildDocument, teamRules } from "./document.ts";
 import { guessLanguage } from "./detect.ts";
-import { plainSource } from "./plain-source.ts";
-import { collectTargets } from "./files.ts";
-import { BASELINE_FILE, fingerprint, readBaseline, splitByBaseline, writeBaseline } from "./baseline.ts";
+import { collectTargets, readDocumentFile } from "./files.ts";
+import { BASELINE_FILE, fingerprints, readBaseline, splitByBaseline, writeBaseline } from "./baseline.ts";
 import { applySuppressions } from "./stet.ts";
 import { renderSuppressions, type PerFile } from "./render/suppressions.ts";
 import { clock, describeChange, snapshotOf, watchPaths, type Snapshot } from "./watch.ts";
@@ -19,8 +17,8 @@ import { GENRES } from "./genre.ts";
 import { resolveGenre } from "./resolve-genre.ts";
 import { runInit } from "./init.ts";
 import { initGenre } from "./commands/init-ask.ts";
-import { targetsOf } from "./cli-args.ts";
-import { loadRules } from "./rule-load.ts";
+import { targetsOf, withExperimental } from "./cli-args.ts";
+import { rulesOf } from "./custom/load.ts";
 import { renderCompact } from "./render/compact.ts";
 import { renderExplain } from "./render/explain.ts";
 import { renderFriendly } from "./render/friendly.ts";
@@ -28,18 +26,21 @@ import { renderGenres } from "./render/genres.ts";
 import { loadGenres, presetLevels } from "./genre-load.ts";
 import { fileHeader } from "./file-header.ts";
 import { rulesJson } from "./render/rules-json.ts";
+import { rulesTable } from "./render/rules-table.ts";
 import { renderSarif } from "./render/sarif.ts";
 import { VERSION, VERSION_LINES } from "./version.ts";
 import { runTree, treeTargets, type TreeContext } from "./commands/tree.ts";
 import { citeTargets, runCite } from "./commands/cite.ts";
+import { compareTargets, runCompare } from "./commands/compare.ts";
 import { runSkill } from "./commands/skill.ts";
 import { runFeedback, settingsOf } from "./commands/feedback.ts";
 import { homedir } from "node:os";
-import { ruleProblems } from "./config/rule-problems.ts";
-import { nameProblems } from "./config/name-problems.ts";
+import { settingWarnings } from "./config/warnings.ts";
+import { readConfigIn } from "./config/read.ts";
+import { optionLayersOf, settingSourcesOf } from "./config/option-problems.ts";
 import { renderSummary, type FileOutcome } from "./render/summary.ts";
-import { neededBy, runRules } from "./run.ts";
-import type { Level, RuleDefinition } from "./plugin.ts";
+import { neededBy, runRulesWith } from "./run.ts";
+import type { Finding, Level, RuleDefinition } from "./plugin.ts";
 import { CLI_TEXT, type CliText, type GenreSource } from "./cli-text.ts";
 import { hostLanguage, sharedLanguage, uiLanguageOf, type UiLanguage } from "./ui.ts";
 import { profileFor } from "./profile/for-file.ts";
@@ -48,7 +49,7 @@ import { settingProblems } from "./setting-problems.ts";
 /** Text for output that is not about one document. */
 const hostText = (config: Config): CliText => CLI_TEXT[hostLanguage(config.language, process.env)];
 
-const readConfig = (): Config => (existsSync(join(process.cwd(), CONFIG_FILE)) ? loadConfig(join(process.cwd(), CONFIG_FILE)) : EMPTY);
+const readConfig = (): Config => readConfigIn(process.cwd());
 
 /** resolveGenre with this run's --genre, for the commands that take it as a dependency. */
 const genreFrom =
@@ -61,7 +62,7 @@ const findRule = (rules: readonly RuleDefinition[], id: string | undefined): Rul
 const changeSetting = (command: Level, ruleId: string | undefined, why: string | undefined): number => {
   const config = readConfig();
   const language = config.language ?? hostLanguage(undefined, process.env);
-  const rule = findRule(loadRules(language), ruleId);
+  const rule = findRule(rulesOf(language, config), ruleId);
   if (rule === undefined) {
     console.error(hostText(config).unknownRule(ruleId ?? hostText(config).unnamed));
     return 1;
@@ -84,20 +85,21 @@ type Inspected = {
   readonly genre: string;
   readonly outcome: FileOutcome;
   readonly perFile: PerFile;
-  readonly all: readonly string[];
+  /** stet で黙らせたものを除いた、baseline で棚上げする前の指摘。fingerprint は baseline を書くときだけ作る。 */
+  readonly kept: readonly Finding[];
 };
 
 const inspect = async (path: string, config: Config, argv: readonly string[]): Promise<Inspected> => {
-  const source = plainSource(await readFile(path, "utf8"));
+  const source = await readDocumentFile(path);
   const language = applyByPath(config.byPath, config.baseDir, path).language ?? config.language ?? guessLanguage(source).language;
   const adapter = await loadAdapter(language);
   const { genre, from, unread } = resolveGenre(path, source, config, flag(argv, "--genre"));
   if (unread !== undefined) console.error(`chaff: ${CLI_TEXT[uiLanguageOf(language)].unreadFrontMatterGenre(path, unread, GENRES)}`);
-  const rules = loadRules(language);
+  const rules = rulesOf(language, config);
   const experimental = config.experimental || argv.includes("--experimental");
   await adapter.prepare?.(neededBy(rules, config.rules, experimental, genre, language));
   const doc = buildDocument(path, source, adapter, teamRules(config), profileFor(config, path, source, language, genre));
-  const raw = runRules(doc, rules, config.rules, experimental, genre, config.limits);
+  const raw = runRulesWith(doc, rules, { settings: config.rules, experimental, genre, limits: config.limits, optionLayers: optionLayersOf(config) });
   // 応答は 3 つ。stet で黙らせたものは、ここで落とす。
   const applied = applySuppressions(
     source,
@@ -116,7 +118,7 @@ const inspect = async (path: string, config: Config, argv: readonly string[]): P
     genre,
     outcome: { path, findings: split.fresh, notRun: raw.skipped.length },
     perFile: { path, suppressed: applied.suppressed, reasonless: applied.unusedReasonless },
-    all: applied.kept.map((finding) => fingerprint(path, finding)),
+    kept: applied.kept,
   };
 };
 
@@ -137,10 +139,8 @@ const writeSarif = (results: readonly Inspected[], argv: readonly string[]): voi
 };
 
 /** 効いていない設定は、結果の前に一度だけ言う。標準エラーに出すので、JSON や SARIF の出力は汚さない。 */
-const warnRuleProblems = (config: Config, language: string): void => {
-  const ui = hostLanguage(config.language, process.env);
-  [...ruleProblems(config, loadRules(language), ui), ...nameProblems(config, ui)].forEach((problem) => console.error(`chaff: ${problem}`));
-};
+const warnRuleProblems = (config: Config, language: string): void =>
+  settingWarnings(config, rulesOf(language, config), hostLanguage(config.language, process.env)).forEach((problem) => console.error(`chaff: ${problem}`));
 
 /** Several files end with one summary: in their language when they share one, else the host's. */
 const summaryLanguage = (results: readonly Inspected[], config: Config): UiLanguage => {
@@ -214,7 +214,7 @@ const explain = (ruleId: string | undefined, genreFlag: string | undefined): num
   // The rule's limits differ by language (characters for Japanese, words for English): explain in the one being written.
   const language = config.language ?? hostLanguage(undefined, process.env);
   const text = CLI_TEXT[uiLanguageOf(language)];
-  const rules = loadRules(language);
+  const rules = rulesOf(language, config);
   const rule = findRule(rules, ruleId);
   if (rule === undefined) {
     const list = rules.map((entry) => `  ${entry.id}`).join("\n");
@@ -223,7 +223,7 @@ const explain = (ruleId: string | undefined, genreFlag: string | undefined): num
   }
   const preset = genre === undefined ? {} : presetLevels(genre);
   const current = config.rules[rule.id] ?? preset[rule.id] ?? (rule.status === "experimental" && !config.experimental ? "off" : "normal");
-  console.log(renderExplain(rule, current, language, text.unit(rule.id, language), genre));
+  console.log(renderExplain(rule, current, language, text.unit(rule.id, language), genre, settingSourcesOf(config, rule.id)));
   return 0;
 };
 
@@ -235,7 +235,7 @@ const runBaseline = async (targets: readonly string[], argv: readonly string[]):
     return 1;
   }
   const results = await Promise.all(paths.map((path) => inspect(path, config, [...argv, "--show-baseline"])));
-  const entries = results.flatMap((result) => result.all);
+  const entries = results.flatMap((result) => fingerprints(result.outcome.path, result.kept));
   const file = join(process.cwd(), BASELINE_FILE);
   writeBaseline(file, entries);
   console.log(hostText(config).baselineDone(paths.length, entries.length, BASELINE_FILE).join("\n"));
@@ -246,12 +246,8 @@ const runSuppressions = async (targets: readonly string[], argv: readonly string
   const paths = collectTargets(targets.length > 0 ? targets : ["."]);
   const config = readConfig();
   const results = await Promise.all(paths.map((path) => inspect(path, config, [...argv, "--show-baseline"])));
-  console.log(
-    renderSuppressions(
-      results.map((result) => result.perFile),
-      hostLanguage(config.language, process.env),
-    ),
-  );
+  const perFile = results.map((result) => result.perFile);
+  console.log(renderSuppressions(perFile, hostLanguage(config.language, process.env)));
   return 0;
 };
 
@@ -260,11 +256,14 @@ type Handler = (argv: readonly string[]) => number | Promise<number>;
 /** `--` で始まらない引数。対象のパス。 */
 const positional = (argv: readonly string[]): string[] => targetsOf(argv.slice(1));
 
-const showRules = (genreFlag: string | undefined): number => {
-  const config = readConfig();
+/** `rules --json` for an AI to read; `rules` alone, a table for a person. */
+const showRules = (argv: readonly string[]): number => {
+  const config = withExperimental(readConfig(), argv);
   const language = config.language ?? hostLanguage(undefined, process.env);
   warnRuleProblems(config, language);
-  console.log(rulesJson(loadRules(language), config, language, genreFlag ?? config.genre ?? "blog/tech"));
+  const genre = flag(argv, "--genre") ?? config.genre ?? "blog/tech";
+  const rules = rulesOf(language, config);
+  console.log(argv.includes("--json") ? rulesJson(rules, config, language, genre, optionLayersOf(config)) : rulesTable(rules, config, language, genre));
   return 0;
 };
 
@@ -294,11 +293,12 @@ const HANDLERS: Readonly<Record<string, Handler>> = {
     return "error" in chosen ? 1 : 0;
   },
   genres: showGenres,
-  rules: (argv) => showRules(flag(argv, "--genre")),
+  rules: showRules,
   explain: (argv) => explain(argv[1], flag(argv, "--genre")),
   eval: (argv) => runEval(positional(argv), argv, { ...measureContext(argv), flag }),
   tree: (argv) => runTree(treeTargets(argv), argv, treeContext()),
   cite: (argv) => runCite(citeTargets(argv), argv, treeContext()),
+  compare: (argv) => runCompare(compareTargets(argv), argv, treeContext()),
   test: (argv) => runTest(positional(argv), argv, { ...measureContext(argv), inspect }),
   baseline: (argv) => runBaseline(positional(argv), argv),
   suppressions: (argv) => runSuppressions(positional(argv), argv),
@@ -338,7 +338,7 @@ export const main = async (argv: readonly string[]): Promise<number> => {
   }
   // 知らないジャンルではどの rule も当たらず、知らない文書の種類では種類の知識が外れる。どちらも素通りに見えるので、何かする前に止める。
   const config = readConfig();
-  const problems = settingProblems(first, flag(argv, "--genre"), config, hostText(config));
+  const problems = settingProblems(first, flag(argv, "--genre"), config, hostText(config), hostLanguage(config.language, process.env));
   problems.forEach((problem) => console.error(problem));
   if (problems.length > 0) return 1;
   const handler = HANDLERS[first];

package/src/closing-numbers.ts

@@ -0,0 +1,72 @@
+import { calendarRuns, digitRuns, type CalendarUnits } from "./calendar-number.ts";
+import type { ProseDocument, Section, Sentence, Span } from "./plugin.ts";
+
+/** 文書の一続きの文字列と、その中の文。base は text の先頭の位置で、文の span は文書全体の座標。 */
+export type Passage = { readonly text: string; readonly base: number; readonly sentences: readonly Sentence[] };
+
+/** 結びの節と、それより前の文書全体（見出し・表・コードも）。 */
+export const closingAndEarlier = (doc: ProseDocument, last: Section): { closing: Passage; earlier: Passage } => ({
+  closing: { text: doc.source.slice(last.span.start, last.span.end), base: last.span.start, sentences: last.sentences },
+  earlier: { text: doc.source.slice(0, last.span.start), base: 0, sentences: doc.sentences.filter((sentence) => sentence.span.end <= last.span.start) },
+});
+
+const DIGIT = /\d/u;
+
+/** 最後の数字まで。文末の「412.」の点や、範囲の「3-」のハイフンは数の一部ではない。前のハイフンは符号（-1%）なので残す。 */
+const valueOf = (text: string, run: Span): string => {
+  const raw = text.slice(run.start, run.end);
+  const lastDigit = [...raw].findLastIndex((char) => DIGIT.test(char));
+  return raw.slice(0, lastDigit + 1);
+};
+
+/** passage の中で、品詞の付いた文の字。見出しや表の字は文ではないので付かない。 */
+const taggedChars = (passage: Passage): Uint8Array => {
+  const tagged = new Uint8Array(passage.text.length);
+  passage.sentences
+    .filter((sentence) => sentence.tokens !== undefined)
+    .forEach((sentence) => tagged.fill(1, Math.max(0, sentence.span.start - passage.base), Math.max(0, sentence.span.end - passage.base)));
+  return tagged;
+};
+
+/** 文の中の日付・時刻の数の単位を、passage の中の位置で。文ごとに読むので、長い文書でも語を探す範囲は文の中だけ。 */
+const calendarUnitsAt = (passage: Passage, units: CalendarUnits): ReadonlyMap<number, string> =>
+  new Map(
+    passage.sentences.flatMap((sentence) =>
+      calendarRuns(sentence.text, sentence.tokens, sentence.span.start, units).map(({ run, unit }): [number, string] => [
+        sentence.span.start - passage.base + run.start,
+        unit,
+      ]),
+    ),
+  );
+
+/** 品詞の無いところの数の、すぐ後ろ（空白 1 つまで）に字面で続く日付・時刻の単位のうち、いちばん長いもの。無ければ空。 */
+const unitAsWritten = (text: string, run: Span, units: CalendarUnits): string => {
+  const at = text[run.end] === " " ? run.end + 1 : run.end;
+  const following = [...units.chained, ...units.positional, ...units.year].filter((unit) => text.startsWith(unit, at));
+  return following.reduce((longest, unit) => (unit.length > longest.length ? unit : longest), "");
+};
+
+/**
+ * passage の中の数の、比べるときの名前を左から。日付・時刻の数は単位ごと（9月）、それ以外は数そのもの（412）。
+ * 文の中は品詞で見分ける（calendar-number.ts）。見出しや表は品詞が無いので、数の後ろの字で見分ける（題の「9月の報告」）。
+ */
+const numberKeys = (passage: Passage, units: CalendarUnits): string[] => {
+  const unitAt = calendarUnitsAt(passage, units);
+  const tagged = taggedChars(passage);
+  return digitRuns(passage.text).map((run) => {
+    const value = valueOf(passage.text, run);
+    const firstDigit = run.start + passage.text.slice(run.start, run.end).search(DIGIT);
+    const unit = tagged[firstDigit] === 1 ? (unitAt.get(run.start) ?? "") : unitAsWritten(passage.text, run, units);
+    return `${value}${unit}`;
+  });
+};
+
+/**
+ * 結びの数のうち、それより前（見出し・表も）に書いていないもの（重ならないように、書いた順）。
+ * 前に同じ名前で書いた数（題の「9月」と結びの「9月」、本文の「412 件」と結びの「412 件」）は新しくない。
+ * 日付・時刻と数量は別のもので、本文の「9 件」があっても結びの「9月末」は新しく、題の「9月」があっても結びの「9 件」は新しい。
+ */
+export const newNumbers = (closing: Passage, earlier: Passage, units: CalendarUnits): string[] => {
+  const stated = new Set(numberKeys(earlier, units));
+  return [...new Set(numberKeys(closing, units).filter((key) => !stated.has(key)))];
+};

package/src/commands/compare.ts

@@ -0,0 +1,80 @@
+import { loadAdapter } from "../adapter-load.ts";
+import { buildDocument, teamRules } from "../document.ts";
+import { readMarkdown } from "../markdown-read.ts";
+import { profileFor } from "../profile/for-file.ts";
+import { resolveGenre } from "../resolve-genre.ts";
+import { isMarkdownPath } from "../structure/markdown-path.ts";
+import { uiLanguageOf } from "../ui.ts";
+import { ATOM_KINDS, isAtomKind, type AtomKind } from "../compare/atom.ts";
+import { extractFacts } from "../compare/extract.ts";
+import { outcomeOf, type Allowed, type Compared } from "../compare/outcome.ts";
+import { renderCompact, renderFriendly, renderJson } from "../compare/render.ts";
+import { COMPARE_TEXT } from "../compare/text.ts";
+import { readSource, treeLanguage, 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", "--allow-dropped", "--allow-added"]);
+
+export const compareTargets = (argv: readonly string[]): string[] =>
+  argv.slice(1).filter((arg, index, all) => !arg.startsWith("--") && !VALUED.has(all[index - 1] ?? ""));
+
+/** Every value given to a repeatable option, split at commas: `--allow-dropped url,code --allow-dropped quote`. */
+const optionValues = (argv: readonly string[], name: string): string[] =>
+  argv.flatMap((arg, index) => (arg === name ? (argv[index + 1] ?? "").split(",") : [])).filter((value) => value !== "");
+
+type ParsedAllowed = { readonly allowed: Allowed } | { readonly unknown: string };
+
+/** The kinds allowed to be dropped and added, or the first word that is not a kind. */
+const parseAllowed = (argv: readonly string[]): ParsedAllowed => {
+  const dropped = optionValues(argv, "--allow-dropped");
+  const added = optionValues(argv, "--allow-added");
+  const unknown = [...dropped, ...added].find((kind) => !isAtomKind(kind));
+  if (unknown !== undefined) return { unknown };
+  const kinds = (values: readonly string[]): Set<AtomKind> => new Set(values.filter(isAtomKind));
+  return { allowed: { dropped: kinds(dropped), added: kinds(added) } };
+};
+
+type Read = Compared & { readonly language: string };
+
+/** One document's facts, read as lint reads it: its language, the team's names, and the parts of speech. */
+const readFacts = async (path: string, argv: readonly string[], context: TreeContext): Promise<Read | 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: true });
+  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));
+  const root = isMarkdownPath(path) ? readMarkdown(doc.source).root : undefined;
+  const extraction = extractFacts({ doc, root, structure: adapter.structure, names: context.config.names ?? [] });
+  return { path, extraction, language };
+};
+
+const renderFor = (argv: readonly string[]): typeof renderFriendly => {
+  if (argv.includes("--json")) return (outcome) => renderJson(outcome);
+  return argv.includes("--compact") ? renderCompact : renderFriendly;
+};
+
+/**
+ * Whether a rewrite kept every fact: numbers, dates, URLs, code, names, quotations, headings, references and footnotes.
+ * Compares; never rewrites. Ends with 1 when a fact was dropped or added, so a rewrite can be checked like a test.
+ */
+export const runCompare = async (targets: readonly string[], argv: readonly string[], context: TreeContext): Promise<number> => {
+  const host = COMPARE_TEXT[context.ui ?? "ja"];
+  const [beforePath, afterPath] = targets;
+  if (beforePath === undefined || afterPath === undefined || targets.length !== 2) {
+    console.error(host.usage);
+    return 1;
+  }
+  const parsed = parseAllowed(argv);
+  if ("unknown" in parsed) {
+    console.error(host.unknownKind(parsed.unknown, ATOM_KINDS.join(", ")));
+    return 1;
+  }
+  const before = await readFacts(beforePath, argv, context);
+  const after = before === undefined ? undefined : await readFacts(afterPath, argv, context);
+  if (before === undefined || after === undefined) return 1;
+  const outcome = outcomeOf(before, after, parsed.allowed);
+  console.log(renderFor(argv)(outcome, COMPARE_TEXT[uiLanguageOf(before.language)]));
+  return outcome.ok ? 0 : 1;
+};

package/src/commands/eval.ts

@@ -1,14 +1,14 @@
-import { plainSource } from "../plain-source.ts";
-import { readFile } from "node:fs/promises";
 import { loadAdapter } from "../adapter-load.ts";
 import { applyByPath } from "../config/by-path.ts";
 import { buildDocument, teamRules } from "../document.ts";
 import { guessLanguage } from "../detect.ts";
-import { collectTargets } from "../files.ts";
-import { loadRules } from "../rule-load.ts";
+import { collectTargets, readDocumentFile } from "../files.ts";
+import { rulesOf } from "../custom/load.ts";
 import { evaluate } from "../eval.ts";
 import { renderEval } from "../render/eval.ts";
-import { neededBy } from "../run.ts";
+import { neededBy, tokenFeaturesOf, wantsTags } from "../run.ts";
+import type { AdapterNeeds, RuleDefinition } from "../plugin.ts";
+import { optionLayersOf } from "../config/option-problems.ts";
 import type { Config } from "../config/load.ts";
 import { profileFor } from "../profile/for-file.ts";
 import { CLI_TEXT } from "../cli-text.ts";
@@ -28,6 +28,16 @@ const TEXT: Texts<{
   },
 };
 
+/**
+ * What the adapter must prepare. eval measures a rule whatever its level, so a rule named with --rule gets the tags and the
+ * token features it reads even when lint would not run it; without --rule, the tags are what lint would prepare.
+ */
+const evalNeeds = (rules: readonly RuleDefinition[], only: string | undefined, config: Config, genre: string, language: string): AdapterNeeds => {
+  const measured = rules.filter((rule) => only === undefined || rule.id === only);
+  const lint = neededBy(rules, config.rules, config.experimental, genre, language);
+  return { pos: lint.pos || (only !== undefined && measured.some(wantsTags)), features: tokenFeaturesOf(measured) };
+};
+
 export type Context = {
   readonly config: Config;
   readonly resolveGenre: (path: string, source: string, config: Config) => { genre: string; from: string };
@@ -51,11 +61,11 @@ export const runEval = async (targets: readonly string[], argv: readonly string[
   const only = flag(argv, "--rule");
   const docs = await Promise.all(
     paths.map(async (path) => {
-      const source = plainSource(await readFile(path, "utf8"));
+      const source = await readDocumentFile(path);
       const language = applyByPath(config.byPath, config.baseDir, path).language ?? config.language ?? guessLanguage(source).language;
       const adapter = await loadAdapter(language);
       const { genre } = resolveGenre(path, source, config);
-      await adapter.prepare?.(neededBy(loadRules(language), config.rules, config.experimental, genre, language));
+      await adapter.prepare?.(evalNeeds(rulesOf(language, config), only, config, genre, language));
       return { doc: buildDocument(path, source, adapter, teamRules(config), profileFor(config, path, source, language, genre)), language, genre };
     }),
   );
@@ -67,7 +77,7 @@ export const runEval = async (targets: readonly string[], argv: readonly string[
     console.error(TEXT[ui].mixed([...mixed].join(", ")));
     return 1;
   }
-  const rules = loadRules(language).filter((rule) => only === undefined || rule.id === only);
+  const rules = rulesOf(language, config).filter((rule) => only === undefined || rule.id === only);
   if (rules.length === 0) {
     console.error(TEXT[ui].unknownRule(only ?? CLI_TEXT[ui].unnamed));
     return 1;
@@ -80,6 +90,7 @@ export const runEval = async (targets: readonly string[], argv: readonly string[
         genre,
         language,
         config.limits,
+        optionLayersOf(config),
       ),
       docs.length,
       paths.length,

package/src/commands/feedback.ts

@@ -1,4 +1,4 @@
-import { plainSource } from "../plain-source.ts";
+import { readDocumentFile } from "../files.ts";
 import { existsSync, readFileSync, writeFileSync } from "node:fs";
 import { basename, join } from "node:path";
 import type { Finding, RuleDefinition } from "../plugin.ts";
@@ -86,15 +86,21 @@ const chosen = (findings: readonly Finding[], rule: string | undefined, line: nu
 const describe = (findings: readonly Finding[], none: string): string =>
   findings.length === 0 ? none : findings.map((finding) => `  ${String(finding.line)}  ${finding.rule}`).join("\n");
 
-/** Pure: the reported rules' own lines of chaff.yaml's rules (a numeric limit wins over a level), or undefined when none is set. */
-export const settingsOf = (config: Pick<Config, "rules" | "limits">, ruleIds: readonly string[]): string | undefined => {
+/**
+ * Pure: the reported rules' own lines of chaff.yaml's rules (a numeric limit wins over a level), under the style chaff.yaml
+ * names, or undefined when none is set. A level the style decided is the style's, so only the style line reproduces it.
+ */
+export const settingsOf = (config: Pick<Config, "rules" | "limits" | "applied">, ruleIds: readonly string[]): string | undefined => {
+  const fromStyle = new Set(config.applied?.levelsFrom ?? []);
   const lines = [...new Set(ruleIds)].flatMap((id) => {
     const limit = config.limits[id];
     const level = config.rules[id];
     if (limit !== undefined) return [`  ${id}: ${String(limit)}`];
-    return level === undefined ? [] : [`  ${id}: ${level}`];
+    return level === undefined || fromStyle.has(id) ? [] : [`  ${id}: ${level}`];
   });
-  return lines.length === 0 ? undefined : ["rules:", ...lines].join("\n");
+  const style = config.applied === undefined ? [] : [`style: ${config.applied.style}`];
+  const rules = lines.length === 0 ? [] : ["rules:", ...lines];
+  return style.length + rules.length === 0 ? undefined : [...style, ...rules].join("\n");
 };
 
 /** Pure: a title on one line, no longer than GitHub shows. */
@@ -179,7 +185,7 @@ export const runFeedback = async (targets: readonly string[], argv: readonly str
     console.error(text.notFound(request.path));
     return 1;
   }
-  const source = plainSource(readFileSync(request.path, "utf8"));
+  const source = await readDocumentFile(request.path);
   const checked = await context.check(request.path);
   const picked = pick(request, checked, source.split("\n").length, context.ui);
   if ("error" in picked) {

package/src/commands/test.ts

@@ -1,20 +1,18 @@
-import { plainSource } from "../plain-source.ts";
-import { readFile } from "node:fs/promises";
 import { join } from "node:path";
 import { loadAdapter } from "../adapter-load.ts";
 import { applyByPath } from "../config/by-path.ts";
 import { buildDocument, teamRules } from "../document.ts";
 import { guessLanguage } from "../detect.ts";
-import { collectTargets } from "../files.ts";
+import { collectTargets, readDocumentFile } from "../files.ts";
 import { loadRules } from "../rule-load.ts";
 import { counted } from "../render/plural.ts";
 import { CHECKS_FILE, loadChecks, type UserCheck } from "../checks.ts";
 import { CACHE_DIR, credentialHint, describeFailure, hasCredentials, type JudgeOptions } from "../judge.ts";
 import { ENV_FILE, loadEnvFile } from "../env.ts";
-import { planSemantic, runSemantic } from "../run-semantic.ts";
+import { planSemantic, runSemantic, semanticNeeds } from "../run-semantic.ts";
 import { machineBanner, renderPlan, renderSemantic } from "../render/semantic.ts";
 import type { Config } from "../config/load.ts";
-import type { Finding, RuleDefinition } from "../plugin.ts";
+import type { Finding, ProseDocument, RuleDefinition } from "../plugin.ts";
 import type { BackendName, Failure } from "../backends/types.ts";
 import { profileFor } from "../profile/for-file.ts";
 import { CLI_TEXT } from "../cli-text.ts";
@@ -83,6 +81,20 @@ export type TestContext = {
   readonly clients?: Pick<JudgeOptions, "anthropicClient" | "openaiClient">;
 };
 
+type SemanticDocument = { readonly doc: ProseDocument; readonly rules: RuleDefinition[]; readonly language: string; readonly genre: string };
+
+/** 意味を読む検査に渡す文書。絞り込みが品詞を使うなら、解析器を読み込んでから作る。dry-run も本番も同じ文書を見る。 */
+const semanticDocument = async (path: string, config: Config, resolveGenre: TestContext["resolveGenre"]): Promise<SemanticDocument> => {
+  const source = await readDocumentFile(path);
+  const language = applyByPath(config.byPath, config.baseDir, path).language ?? config.language ?? guessLanguage(source).language;
+  const adapter = await loadAdapter(language);
+  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));
+  return { doc, rules, language, genre };
+};
+
 type Judged = { path: string; outcome: Awaited<ReturnType<typeof runSemantic>>; rules: RuleDefinition[]; language: string };
 
 const judgeAll = async (
@@ -94,12 +106,7 @@ const judgeAll = async (
 ): Promise<Judged[]> =>
   Promise.all(
     paths.map(async (path) => {
-      const source = plainSource(await readFile(path, "utf8"));
-      const language = applyByPath(config.byPath, config.baseDir, path).language ?? config.language ?? guessLanguage(source).language;
-      const adapter = await loadAdapter(language);
-      const { genre } = resolveGenre(path, source, config);
-      const doc = buildDocument(path, source, adapter, teamRules(config), profileFor(config, path, source, language, genre));
-      const rules = loadRules(language);
+      const { doc, rules, language, genre } = await semanticDocument(path, config, resolveGenre);
       return { path, outcome: await runSemantic(doc, rules, checks, config.rules, genre, options), rules, language };
     }),
   );
@@ -114,12 +121,8 @@ const dryRun = async (
 ): Promise<void> => {
   const plans = await Promise.all(
     paths.map(async (path) => {
-      const source = plainSource(await readFile(path, "utf8"));
-      const language = applyByPath(config.byPath, config.baseDir, path).language ?? config.language ?? guessLanguage(source).language;
-      const adapter = await loadAdapter(language);
-      const { genre } = resolveGenre(path, source, config);
-      const doc = buildDocument(path, source, adapter, teamRules(config), profileFor(config, path, source, language, genre));
-      return { path, jobs: planSemantic(doc, loadRules(language), checks, config.rules, genre), sentences: doc.sentences.length, language };
+      const { doc, rules, language, genre } = await semanticDocument(path, config, resolveGenre);
+      return { path, jobs: planSemantic(doc, rules, checks, config.rules, genre), sentences: doc.sentences.length, language };
     }),
   );
   plans.forEach(({ path, jobs, sentences, language }) => console.log(renderPlan(path, jobs, sentences, language).join("\n")));