chaffjs 0.15.0 → 0.17.0

package/src/cli.ts

@@ -16,14 +16,17 @@ import { clock, describeChange, snapshotOf, watchPaths, type Snapshot } from "./
 import { runEval } from "./commands/eval.ts";
 import { runTest } from "./commands/test.ts";
 import { GENRES } from "./genre.ts";
-import { unknownGenres, writtenGenres } from "./genre-check.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 { renderCompact } from "./render/compact.ts";
 import { renderExplain } from "./render/explain.ts";
 import { renderFriendly } from "./render/friendly.ts";
+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 { renderSarif } from "./render/sarif.ts";
 import { VERSION, VERSION_LINES } from "./version.ts";
@@ -33,26 +36,20 @@ 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 { renderSummary, type FileOutcome } from "./render/summary.ts";
 import { neededBy, runRules } from "./run.ts";
 import type { Level, RuleDefinition } from "./plugin.ts";
 import { CLI_TEXT, type CliText, type GenreSource } from "./cli-text.ts";
-import { hostLanguage, uiLanguageOf, type UiLanguage } from "./ui.ts";
+import { hostLanguage, sharedLanguage, uiLanguageOf, type UiLanguage } from "./ui.ts";
 import { profileFor } from "./profile/for-file.ts";
+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 genreProblems = (command: string, argv: readonly string[]): string[] => {
-  const config = readConfig();
-  const text = hostText(config);
-  return unknownGenres(writtenGenres(command, flag(argv, "--genre"), config), GENRES).map((entry) =>
-    text.unknownGenre(entry.genre, text.genreWhere(entry.where, entry.files), GENRES),
-  );
-};
-
 /** resolveGenre with this run's --genre, for the commands that take it as a dependency. */
 const genreFrom =
   (argv: readonly string[]) =>
@@ -90,12 +87,6 @@ type Inspected = {
   readonly all: readonly string[];
 };
 
-/** The first line for a file, in the file's language. */
-const headerFor = (path: string, genre: string, from: GenreSource, language: string, shelved: number, hushed: number): string => {
-  const text = CLI_TEXT[uiLanguageOf(language)];
-  return text.header(path, genre, text.languageName(language), text.genreSource[from], shelved, hushed);
-};
-
 const inspect = async (path: string, config: Config, argv: readonly string[]): Promise<Inspected> => {
   const source = plainSource(await readFile(path, "utf8"));
   const language = applyByPath(config.byPath, config.baseDir, path).language ?? config.language ?? guessLanguage(source).language;
@@ -105,7 +96,7 @@ const inspect = async (path: string, config: Config, argv: readonly string[]): P
   const rules = loadRules(language);
   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));
+  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);
   // 応答は 3 つ。stet で黙らせたものは、ここで落とす。
   const applied = applySuppressions(
@@ -116,8 +107,8 @@ const inspect = async (path: string, config: Config, argv: readonly string[]): P
   const baseline = argv.includes("--show-baseline") ? undefined : readBaseline(join(process.cwd(), BASELINE_FILE));
   const split = splitByBaseline(path, applied.kept, baseline);
   const result = { ...raw, findings: split.fresh };
-  const header = headerFor(path, genre, from, language, split.shelved, applied.suppressed.length);
-  const text = argv.includes("--compact") ? renderCompact(header, result, rules, language) : renderFriendly(header, result, rules, language);
+  const { header, notes } = fileHeader(path, source, language, { genre, from, unread }, { shelved: split.shelved, hushed: applied.suppressed.length });
+  const text = argv.includes("--compact") ? renderCompact(header, result, rules, language) : renderFriendly(header, result, rules, language, notes);
   return {
     text,
     rules,
@@ -147,14 +138,14 @@ const writeSarif = (results: readonly Inspected[], argv: readonly string[]): voi
 
 /** 効いていない設定は、結果の前に一度だけ言う。標準エラーに出すので、JSON や SARIF の出力は汚さない。 */
 const warnRuleProblems = (config: Config, language: string): void => {
-  ruleProblems(config, loadRules(language), hostLanguage(config.language, process.env)).forEach((problem) => console.error(`chaff: ${problem}`));
+  const ui = hostLanguage(config.language, process.env);
+  [...ruleProblems(config, loadRules(language), ui), ...nameProblems(config, ui)].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 => {
-  const languages = new Set(results.map((result) => uiLanguageOf(result.language)));
-  const [only] = [...languages];
-  return languages.size === 1 && only !== undefined ? only : hostLanguage(config.language, process.env);
+  const languages = results.map((result) => result.language);
+  return sharedLanguage(languages, hostLanguage(config.language, process.env));
 };
 
 const lint = async (targets: readonly string[], argv: readonly string[]): Promise<number> => {
@@ -216,8 +207,10 @@ const runWatch = async (targets: readonly string[], argv: readonly string[]): Pr
   return new Promise(() => undefined);
 };
 
-const explain = (ruleId: string | undefined): number => {
+/** genreFlag: --genre, which wins over chaff.yaml's genre here as it does in a run. */
+const explain = (ruleId: string | undefined, genreFlag: string | undefined): number => {
   const config = readConfig();
+  const genre = genreFlag ?? config.genre;
   // 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)];
@@ -228,8 +221,9 @@ const explain = (ruleId: string | undefined): number => {
     console.error(text.unknownRuleWithList(ruleId ?? text.unnamed, list));
     return 1;
   }
-  const current = config.rules[rule.id] ?? (rule.status === "experimental" && !config.experimental ? "off" : "normal");
-  console.log(renderExplain(rule, current, language, text.unit(rule.id, language), config.genre));
+  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));
   return 0;
 };
 
@@ -266,16 +260,16 @@ type Handler = (argv: readonly string[]) => number | Promise<number>;
 /** `--` で始まらない引数。対象のパス。 */
 const positional = (argv: readonly string[]): string[] => targetsOf(argv.slice(1));
 
-const showRules = (): number => {
+const showRules = (genreFlag: string | undefined): number => {
   const config = readConfig();
   const language = config.language ?? hostLanguage(undefined, process.env);
   warnRuleProblems(config, language);
-  console.log(rulesJson(loadRules(language), config, language, config.genre ?? "blog/tech"));
+  console.log(rulesJson(loadRules(language), config, language, genreFlag ?? config.genre ?? "blog/tech"));
   return 0;
 };
 
 const showGenres = (): number => {
-  console.log(hostText(readConfig()).genres(GENRES));
+  console.log(renderGenres(loadGenres(), hostLanguage(readConfig().language, process.env)));
   return 0;
 };
 
@@ -284,22 +278,28 @@ const treeContext = (): TreeContext => {
   return { config, flag, ui: hostLanguage(config.language, process.env) };
 };
 
+/** What eval and test share: the settings, this run's genre, and the language for what is not about one document. */
+const measureContext = (argv: readonly string[]): { config: Config; resolveGenre: ReturnType<typeof genreFrom>; ui: UiLanguage } => {
+  const config = readConfig();
+  return { config, resolveGenre: genreFrom(argv), ui: hostLanguage(config.language, process.env) };
+};
+
 /** 分岐を数珠つなぎにせず表にする。足すときに main を太らせない。 */
 const HANDLERS: Readonly<Record<string, Handler>> = {
-  init: (argv) => {
-    runInit(process.cwd(), flag(argv, "--genre") ?? "blog/tech", hostLanguage(readConfig().language, process.env)).forEach((line) => console.log(line));
-    return 0;
+  init: async (argv) => {
+    const ui = hostLanguage(readConfig().language, process.env);
+    const chosen = await initGenre(flag(argv, "--genre"), ui, process.cwd());
+    if ("error" in chosen) console.error(chosen.error);
+    else runInit(process.cwd(), chosen.genre, ui).forEach((line) => console.log(line));
+    return "error" in chosen ? 1 : 0;
   },
   genres: showGenres,
-  rules: showRules,
-  explain: (argv) => explain(argv[1]),
-  eval: (argv) => {
-    const config = readConfig();
-    return runEval(positional(argv), argv, { config, resolveGenre: genreFrom(argv), flag, ui: hostLanguage(config.language, process.env) });
-  },
+  rules: (argv) => showRules(flag(argv, "--genre")),
+  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()),
-  test: (argv) => runTest(positional(argv), argv, { config: readConfig(), resolveGenre: genreFrom(argv), inspect }),
+  test: (argv) => runTest(positional(argv), argv, { ...measureContext(argv), inspect }),
   baseline: (argv) => runBaseline(positional(argv), argv),
   suppressions: (argv) => runSuppressions(positional(argv), argv),
   relax: (argv) => changeSetting("relaxed", argv[1], flag(argv, "--why")),
@@ -336,8 +336,9 @@ export const main = async (argv: readonly string[]): Promise<number> => {
     console.log(VERSION_LINES.join("\n"));
     return 0;
   }
-  // 知らないジャンルでは、どの rule も当たらず、動かなかった rule も並ばない。「指摘なし」が素通りに見えるので、何かする前に止める。
-  const problems = genreProblems(first, argv);
+  // 知らないジャンルではどの rule も当たらず、知らない文書の種類では種類の知識が外れる。どちらも素通りに見えるので、何かする前に止める。
+  const config = readConfig();
+  const problems = settingProblems(first, flag(argv, "--genre"), config, hostText(config));
   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/cite.ts

@@ -2,12 +2,12 @@ import { checkCitations, type Citation, type CitationResult } from "../structure
 import { readSource, readTree, type TreeContext } from "./tree.ts";
 import type { Texts, UiLanguage } from "../ui.ts";
 
-const FORMATS = ["text", "json"];
+const FORMATS: ReadonlySet<string> = new Set(["text", "json"]);
 const QUOTE_WIDTH = 40;
-const VALUED = ["--format", "--language"];
+const VALUED: ReadonlySet<string> = new Set(["--format", "--language", "--genre"]);
 
 export const citeTargets = (argv: readonly string[]): string[] =>
-  argv.slice(1).filter((arg, index, all) => !arg.startsWith("--") && !VALUED.includes(all[index - 1] ?? ""));
+  argv.slice(1).filter((arg, index, all) => !arg.startsWith("--") && !VALUED.has(all[index - 1] ?? ""));
 
 const isRecord = (value: unknown): value is Record<string, unknown> => typeof value === "object" && value !== null && !Array.isArray(value);
 
@@ -88,7 +88,7 @@ const describe = (result: CitationResult, text: CiteText): string => {
 export const runCite = async (targets: readonly string[], argv: readonly string[], context: TreeContext): Promise<number> => {
   const [sourcePath, citationsPath] = targets;
   const format = context.flag(argv, "--format") ?? "text";
-  if (sourcePath === undefined || citationsPath === undefined || targets.length !== 2 || !FORMATS.includes(format)) {
+  if (sourcePath === undefined || citationsPath === undefined || targets.length !== 2 || !FORMATS.has(format)) {
     console.error(TEXT[context.ui ?? "ja"].usage);
     return 1;
   }

package/src/commands/eval.ts

@@ -56,7 +56,7 @@ export const runEval = async (targets: readonly string[], argv: readonly string[
       const adapter = await loadAdapter(language);
       const { genre } = resolveGenre(path, source, config);
       await adapter.prepare?.(neededBy(loadRules(language), config.rules, config.experimental, genre, language));
-      return { doc: buildDocument(path, source, adapter, teamRules(config), profileFor(config, path, source, language)), language, genre };
+      return { doc: buildDocument(path, source, adapter, teamRules(config), profileFor(config, path, source, language, genre)), language, genre };
     }),
   );
   const language = docs[0]?.language ?? "ja";

package/src/commands/init-ask.ts

@@ -0,0 +1,53 @@
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { createInterface, type Interface } from "node:readline";
+import { CONFIG_FILE } from "../config/load.ts";
+import { loadGenres } from "../genre-load.ts";
+import { choicePrompt, DEFAULT_GENRE, genreChoices, genreFromAnswer, noAnswer, notAGenre } from "../init-choice.ts";
+import type { UiLanguage } from "../ui.ts";
+
+type Terminal = { readonly isTTY?: boolean | undefined };
+
+/** Where init asks: the terminal, or streams a test gives it. */
+export type Prompter = { readonly input: NodeJS.ReadableStream & Terminal; readonly output: NodeJS.WritableStream & Terminal };
+
+/** Ask only at a terminal, and only when init will write chaff.yaml: a script or CI gets the default without waiting. */
+export const shouldAsk = (stdin: Terminal, stdout: Terminal, configExists: boolean): boolean => stdin.isTTY === true && stdout.isTTY === true && !configExists;
+
+/** The first line typed, or undefined when the input ends with none (Ctrl-D): waiting for a question's answer would never end then. */
+const answerOf = (reader: Interface, prompt: string): Promise<string | undefined> => {
+  const answer = new Promise<string | undefined>((resolve) => {
+    reader.once("line", resolve);
+    reader.once("close", () => resolve(undefined));
+  });
+  reader.setPrompt(prompt);
+  reader.prompt();
+  return answer;
+};
+
+const ask = async (ui: UiLanguage, io: Prompter): Promise<{ readonly genre: string | undefined; readonly answer: string | undefined }> => {
+  const data = loadGenres();
+  io.output.write(`${genreChoices(data, ui).join("\n")}\n`);
+  const reader = createInterface({ input: io.input, output: io.output });
+  try {
+    const answer = await answerOf(reader, choicePrompt(ui));
+    const ids = data.genres.map((genre) => genre.id);
+    return { genre: answer === undefined ? undefined : genreFromAnswer(answer, ids), answer };
+  } finally {
+    reader.close();
+  }
+};
+
+/** The genre init writes: --genre, else the one picked at the prompt, else the default. An answer that is no genre is an error. */
+export const initGenre = async (
+  flagged: string | undefined,
+  ui: UiLanguage,
+  dir: string,
+  io: Prompter = { input: process.stdin, output: process.stdout },
+): Promise<{ readonly genre: string } | { readonly error: string }> => {
+  if (flagged !== undefined) return { genre: flagged };
+  if (!shouldAsk(io.input, io.output, existsSync(join(dir, CONFIG_FILE)))) return { genre: DEFAULT_GENRE };
+  const picked = await ask(ui, io);
+  if (picked.answer === undefined) return { error: noAnswer(ui) };
+  return picked.genre === undefined ? { error: notAGenre(picked.answer.trim(), ui) } : { genre: picked.genre };
+};

package/src/commands/test.ts

@@ -7,20 +7,94 @@ import { buildDocument, teamRules } from "../document.ts";
 import { guessLanguage } from "../detect.ts";
 import { collectTargets } 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 } from "../judge.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 { MACHINE_BANNER, renderPlan, renderSemantic } from "../render/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 { Failure } from "../backends/types.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";
+import { sharedLanguage, type Texts, type UiLanguage } from "../ui.ts";
+
+const TEXT: Texts<{
+  readonly total: (total: number) => string;
+  readonly sentTo: (backend: string, model: string, found: boolean) => string;
+  readonly envRead: (path: string) => string;
+  readonly envWhere: (found: string | undefined) => string;
+  readonly notRun: (why: string, what: string, where: string) => readonly string[];
+  readonly noCredentials: (backend: BackendName) => string;
+  readonly refused: (backend: BackendName, status: string) => string;
+  readonly checkKey: string;
+  readonly quota: (backend: BackendName, status: string) => string;
+  readonly returned: (backend: BackendName, status: string) => string;
+  readonly noCause: string;
+  readonly tally: (machine: number, ai: number) => string;
+  readonly untouched: string;
+}> = {
+  ja: {
+    total: (total) => `  合計 ${total} 箇所を送ります。--dry-run なので API は呼んでいません。`,
+    sentTo: (backend, model, found) => `  送り先: ${backend} / ${model}（認証${found ? "あり" : "なし"}）`,
+    envRead: (path) => `  ${path} を読みました。`,
+    envWhere: (found) => (found === undefined ? `${ENV_FILE} に書いても読みます（いまは ${ENV_FILE} がありません）` : `${found} は読みました`),
+    notRun: (why, what, where) => [`  意味を読む検査は動かしていません。${why}`, `  ${what}`, `  ${where}。`, "  機械による判定はすべて動いています。"],
+    noCredentials: (backend) => `${backend} の認証情報がありません。`,
+    refused: (backend, status) => `${backend} が鍵を受け付けませんでした（${status}）。`,
+    checkKey: "鍵が正しいか、その provider のものかを確かめてください。",
+    quota: (backend, status) => `${backend} の残高か上限に達しました（${status}）。`,
+    returned: (backend, status) => `${backend} が ${status} を返しました。`,
+    noCause: "原因は返ってきませんでした",
+    tally: (machine, ai) => `  機械 ${machine} 件 / AI ${ai} 件`,
+    untouched: "  文章は書き換えていません。直すのは書いた人です。",
+  },
+  en: {
+    total: (total) => `  ${counted(total, "passage")} in all would be sent. With --dry-run the API was not called.`,
+    sentTo: (backend, model, found) => `  Sent to: ${backend} / ${model} (${found ? "credentials found" : "no credentials"})`,
+    envRead: (path) => `  Read ${path}.`,
+    envWhere: (found) => (found === undefined ? `A key written in ${ENV_FILE} is read too (there is no ${ENV_FILE} now)` : `${found} was read`),
+    notRun: (why, what, where) => [`  The checks that read meaning did not run. ${why}`, `  ${what}`, `  ${where}.`, "  Every machine check ran."],
+    noCredentials: (backend) => `There are no credentials for ${backend}.`,
+    refused: (backend, status) => `${backend} did not accept the key (${status}).`,
+    checkKey: "Check that the key is right and that it is for that provider.",
+    quota: (backend, status) => `${backend} has run out of balance or hit a limit (${status}).`,
+    returned: (backend, status) => `${backend} returned ${status}.`,
+    noCause: "No reason was given.",
+    tally: (machine, ai) => `  ${machine} by machine / ${ai} by AI`,
+    untouched: "  The text was not changed. Fixing it is the writer's job.",
+  },
+};
+
+const DIVIDER = "─".repeat(60);
 
 export type TestContext = {
   readonly config: Config;
   readonly resolveGenre: (path: string, source: string, config: Config) => { genre: string; from: string };
-  readonly inspect: (path: string, config: Config, argv: readonly string[]) => Promise<{ text: string; outcome: { findings: readonly Finding[] } }>;
+  readonly inspect: (
+    path: string,
+    config: Config,
+    argv: readonly string[],
+  ) => Promise<{ text: string; language: string; outcome: { findings: readonly Finding[] } }>;
+  /** The language of what is not about the documents: chaff.yaml's language, else the locale. */
+  readonly ui: UiLanguage;
+  /** The judges to call instead of the providers' own clients. Tests pass stand-ins; the command line never does. */
+  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 = 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 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 };
@@ -34,12 +108,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 doc = buildDocument(path, source, adapter, teamRules(config), profileFor(config, path, source, language));
-      const { genre } = resolveGenre(path, source, config);
-      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 };
     }),
   );
@@ -50,43 +119,47 @@ const dryRun = async (
   config: Config,
   checks: readonly UserCheck[],
   resolveGenre: TestContext["resolveGenre"],
-  envFile: string | undefined,
+  closing: { readonly envFile: string | undefined; readonly language: UiLanguage },
 ): 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 doc = buildDocument(path, source, adapter, teamRules(config), profileFor(config, path, source, language));
-      const { genre } = resolveGenre(path, source, config);
-      return { path, jobs: planSemantic(doc, loadRules(language), checks, config.rules, genre), sentences: doc.sentences.length };
+      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 }) => console.log(renderPlan(path, jobs, sentences).join("\n")));
+  plans.forEach(({ path, jobs, sentences, language }) => console.log(renderPlan(path, jobs, sentences, language).join("\n")));
   const total = plans.reduce((sum, plan) => sum + plan.jobs.reduce((count, job) => count + job.candidates.length, 0), 0);
-  const from = envFile === undefined ? "" : `  ${envFile} を読みました。`;
-  const where = `${config.aiBackend} / ${config.aiModel}（認証${hasCredentials(config.aiBackend) ? "あり" : "なし"}）`;
-  console.log(
-    [
-      "",
-      "─".repeat(60),
-      "",
-      `  合計 ${total} 箇所を送ります。--dry-run なので API は呼んでいません。`,
-      `  送り先: ${where}`,
-      ...(from === "" ? [] : [from]),
-      "",
-    ].join("\n"),
-  );
+  const text = TEXT[closing.language];
+  const from = closing.envFile === undefined ? [] : [text.envRead(closing.envFile)];
+  console.log(["", DIVIDER, "", text.total(total), text.sentTo(config.aiBackend, config.aiModel, hasCredentials(config.aiBackend)), ...from, ""].join("\n"));
 };
 
+/**
+ * API が返した失敗を人の言葉にする。生のスタックトレースを人に見せない。
+ * 鍵はあるのに弾かれたときに「ありません」と言うと、設定済みの鍵をもう一度設定しに行かせる。
+ * 残高切れも同じで、「鍵を確かめてください」と言われても鍵は正しい。
+ */
+const whyFailed = (failure: Failure, backend: BackendName, language: UiLanguage): { why: string; what: string } => {
+  const text = TEXT[language];
+  const status = String(failure.status ?? "?");
+  if (failure.kind === "auth") return { why: text.refused(backend, status), what: text.checkKey };
+  const what = failure.message ?? text.noCause;
+  return failure.kind === "quota" ? { why: text.quota(backend, status), what } : { why: text.returned(backend, status), what };
+};
+
+/** Why the checks that read meaning did not run, and where a key would be read from. */
+const notRunNotice = (why: string, what: string, envFile: string | undefined, language: UiLanguage): string =>
+  ["", ...TEXT[language].notRun(why, what, TEXT[language].envWhere(envFile)), ""].join("\n");
+
 /**
  * 機械と AI を見出しで分けて出す。読む人が「これは揺れる判定か」を知らないと、
  * AI の誤検知に振り回される。workflow spec §7、samples/README の軸 2。
+ * 見出しと指摘は文書の言語、締めは文書がそろっていればその言語、混ざっていれば ui の言語。
  */
 export const runTest = async (targets: readonly string[], argv: readonly string[], context: TestContext): Promise<number> => {
   const paths = collectTargets(targets.length > 0 ? targets : ["."]);
   if (paths.length === 0) {
-    console.error(`Markdown が 1 つも見つかりませんでした: ${targets.join(", ")}`);
+    console.error(CLI_TEXT[context.ui].noMarkdown(targets.join(", ")));
     return 1;
   }
   const { config, resolveGenre, inspect } = context;
@@ -95,31 +168,20 @@ export const runTest = async (targets: readonly string[], argv: readonly string[
   const checks = loadChecks(join(process.cwd(), CHECKS_FILE));
   const results = await Promise.all(paths.map((path) => inspect(path, config, argv)));
   results.forEach((result) => {
-    console.log(result.text.replace(/\n/u, `\n${MACHINE_BANNER.join("\n")}`));
+    console.log(result.text.replace(/\n/u, `\n${machineBanner(result.language).join("\n")}`));
   });
+  const closing = sharedLanguage(
+    results.map((result) => result.language),
+    context.ui,
+  );
   const machineOnly = results.some((result) => result.outcome.findings.some((finding) => finding.severity === "error")) ? 1 : 0;
-  const where = envFile === undefined ? `${ENV_FILE} に書いても読みます（いまは ${ENV_FILE} がありません）` : `${envFile} は読みました`;
-  const notRun = (why: string, what: string): string =>
-    ["", `  意味を読む検査は動かしていません。${why}`, `  ${what}`, `  ${where}。`, "  機械による判定はすべて動いています。", ""].join("\n");
-  const noCredentials = notRun(`${config.aiBackend} の認証情報がありません。`, credentialHint(config.aiBackend));
-  /**
-   * API が返した失敗を人の言葉にする。生のスタックトレースを人に見せない。
-   * 鍵はあるのに弾かれたときに「ありません」と言うと、設定済みの鍵をもう一度設定しに行かせる。
-   * 残高切れも同じで、「鍵を確かめてください」と言われても鍵は正しい。
-   */
-  const failed = (failure: Failure): string => {
-    if (failure.kind === "auth")
-      return notRun(`${config.aiBackend} が鍵を受け付けませんでした（${failure.status ?? "?"}）。`, "鍵が正しいか、その provider のものかを確かめてください。");
-    if (failure.kind === "quota") return notRun(`${config.aiBackend} の残高か上限に達しました（${failure.status ?? "?"}）。`, failure.message);
-    return notRun(`${config.aiBackend} が ${failure.status ?? "?"} を返しました。`, failure.message);
-  };
   if (argv.includes("--dry-run")) {
-    await dryRun(paths, config, checks, resolveGenre, envFile);
+    await dryRun(paths, config, checks, resolveGenre, { envFile, language: closing });
     return machineOnly;
   }
   // 呼んでから落ちるのを待たない。認証が無いときの SDK の例外は型で判別できない。
   if (!hasCredentials(config.aiBackend)) {
-    console.log(noCredentials);
+    console.log(notRunNotice(TEXT[closing].noCredentials(config.aiBackend), credentialHint(config.aiBackend, closing), envFile, closing));
     return machineOnly;
   }
   const options = {
@@ -127,12 +189,14 @@ export const runTest = async (targets: readonly string[], argv: readonly string[
     backend: config.aiBackend,
     cacheDir: join(process.cwd(), CACHE_DIR),
     confidenceThreshold: config.confidenceThreshold,
+    ...context.clients,
   };
   const semantic = await judgeAll(paths, config, checks, options, resolveGenre).catch((error: unknown) => {
     // API が返した失敗だけを受け止める。ネットワーク断やコードの誤りは握りつぶさない。
     const failure = describeFailure(config.aiBackend, error);
     if (failure === undefined) throw error;
-    console.log(failed(failure));
+    const { why, what } = whyFailed(failure, config.aiBackend, closing);
+    console.log(notRunNotice(why, what, envFile, closing));
     return undefined;
   });
   if (semantic === undefined) return machineOnly;
@@ -142,8 +206,6 @@ export const runTest = async (targets: readonly string[], argv: readonly string[
   });
   const machine = results.flatMap((result) => result.outcome.findings);
   const ai = semantic.flatMap((entry) => entry.outcome.findings);
-  console.log(
-    ["", "─".repeat(60), "", `  機械 ${machine.length} 件 / AI ${ai.length} 件`, "  文章は書き換えていません。直すのは書いた人です。", ""].join("\n"),
-  );
+  console.log(["", DIVIDER, "", TEXT[closing].tally(machine.length, ai.length), TEXT[closing].untouched, ""].join("\n"));
   return [...machine, ...ai].some((finding) => finding.severity === "error") ? 1 : 0;
 };