chaffjs 0.14.0 → 0.16.0

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

@@ -1,3 +1,4 @@
+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";
@@ -10,33 +11,52 @@ import { renderEval } from "../render/eval.ts";
 import { neededBy } from "../run.ts";
 import type { Config } from "../config/load.ts";
 import { profileFor } from "../profile/for-file.ts";
+import { CLI_TEXT } from "../cli-text.ts";
+import { uiLanguageOf, type Texts, type UiLanguage } from "../ui.ts";
+
+const TEXT: Texts<{
+  readonly mixed: (mixes: string) => string;
+  readonly unknownRule: (id: string) => string;
+}> = {
+  ja: {
+    mixed: (mixes) => `言語かジャンルが混ざっています: ${mixes}\n1 つに絞って測ってください（例: npx chaff eval examples/blog-ja/）。`,
+    unknownRule: (id) => `${id} という rule はありません。`,
+  },
+  en: {
+    mixed: (mixes) => `Languages or genres are mixed: ${mixes}\nMeasure one at a time (for example npx chaff eval examples/blog-en/).`,
+    unknownRule: (id) => `There is no rule named ${id}.`,
+  },
+};
 
 export type Context = {
   readonly config: Config;
   readonly resolveGenre: (path: string, source: string, config: Config) => { genre: string; from: string };
   readonly flag: (argv: readonly string[], name: string) => string | undefined;
+  /** The language of what is not about the documents measured: chaff.yaml's language, else the locale. */
+  readonly ui: UiLanguage;
 };
 
 /**
  * 閾値の較正。手元の文書を「人間の良い文書」として扱い、どの閾値なら
  * 誤検知が目標を下回るかを測る。書き換えはしない。
+ * 測った結果は文書の言語で出す（混ざっていれば測らないので、言語は 1 つ）。断りは ui の言語。
  */
 export const runEval = async (targets: readonly string[], argv: readonly string[], context: Context): 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, flag } = context;
+  const { config, resolveGenre, flag, ui } = context;
   const only = flag(argv, "--rule");
   const docs = await Promise.all(
     paths.map(async (path) => {
-      const source = await readFile(path, "utf8");
+      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);
       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";
@@ -44,12 +64,12 @@ export const runEval = async (targets: readonly string[], argv: readonly string[
   // 言語とジャンルが混ざった corpus は測れない。閾値の単位が違うため。
   const mixed = new Set(docs.map((entry) => `${entry.language}/${entry.genre}`));
   if (mixed.size > 1) {
-    console.error(`言語かジャンルが混ざっています: ${[...mixed].join(", ")}\n1 つに絞って測ってください（例: npx chaff eval examples/blog-ja/）。`);
+    console.error(TEXT[ui].mixed([...mixed].join(", ")));
     return 1;
   }
   const rules = loadRules(language).filter((rule) => only === undefined || rule.id === only);
   if (rules.length === 0) {
-    console.error(`${only ?? "(名前なし)"} という rule はありません。`);
+    console.error(TEXT[ui].unknownRule(only ?? CLI_TEXT[ui].unnamed));
     return 1;
   }
   console.log(
@@ -63,6 +83,7 @@ export const runEval = async (targets: readonly string[], argv: readonly string[
       ),
       docs.length,
       paths.length,
+      uiLanguageOf(language),
     ),
   );
   return 0;

package/src/commands/feedback.ts

@@ -1,3 +1,4 @@
+import { plainSource } from "../plain-source.ts";
 import { existsSync, readFileSync, writeFileSync } from "node:fs";
 import { basename, join } from "node:path";
 import type { Finding, RuleDefinition } from "../plugin.ts";
@@ -178,7 +179,7 @@ export const runFeedback = async (targets: readonly string[], argv: readonly str
     console.error(text.notFound(request.path));
     return 1;
   }
-  const source = readFileSync(request.path, "utf8");
+  const source = plainSource(readFileSync(request.path, "utf8"));
   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/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

@@ -1,3 +1,4 @@
+import { plainSource } from "../plain-source.ts";
 import { readFile } from "node:fs/promises";
 import { join } from "node:path";
 import { loadAdapter } from "../adapter-load.ts";
@@ -6,20 +7,80 @@ 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 { 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 { 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 Judged = { path: string; outcome: Awaited<ReturnType<typeof runSemantic>>; rules: RuleDefinition[]; language: string };
@@ -33,11 +94,11 @@ const judgeAll = async (
 ): Promise<Judged[]> =>
   Promise.all(
     paths.map(async (path) => {
-      const source = await readFile(path, "utf8");
+      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 doc = buildDocument(path, source, adapter, teamRules(config), profileFor(config, path, source, language, genre));
       const rules = loadRules(language);
       return { path, outcome: await runSemantic(doc, rules, checks, config.rules, genre, options), rules, language };
     }),
@@ -49,43 +110,51 @@ 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 = await readFile(path, "utf8");
+      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 = 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 };
     }),
   );
-  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;
@@ -94,31 +163,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 = {
@@ -126,12 +184,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;
@@ -141,8 +201,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;
 };

package/src/commands/tree.ts

@@ -1,7 +1,9 @@
+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 { profileFor } from "../profile/for-file.ts";
+import { resolveGenre } from "../resolve-genre.ts";
 import { guessLanguage } from "../detect.ts";
 import { isMarkdownPath } from "../structure/markdown-path.ts";
 import { buildStructure } from "../structure/of.ts";
@@ -34,19 +36,19 @@ const TEXT: Texts<{
   },
 };
 
-export const treeText = (context: TreeContext): (typeof TEXT)["ja"] => TEXT[context.ui ?? "ja"];
+const treeText = (context: TreeContext): (typeof TEXT)["ja"] => TEXT[context.ui ?? "ja"];
 
-const FORMATS = ["sexp", "json"];
+const FORMATS: ReadonlySet<string> = new Set(["sexp", "json"]);
 
 /** 値を取るフラグ。その次の引数は値で、対象のファイルではない。 */
-const VALUED = ["--format", "--language"];
+const VALUED: ReadonlySet<string> = new Set(["--format", "--language", "--genre"]);
 
 export const treeTargets = (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] ?? ""));
 
 export const readSource = async (path: string, context: TreeContext): Promise<string | undefined> => {
   try {
-    return await readFile(path, "utf8");
+    return plainSource(await readFile(path, "utf8"));
   } catch (err) {
     console.error(treeText(context).unreadable(path, err instanceof Error ? err.message : String(err)));
     return undefined;
@@ -80,7 +82,7 @@ export const readTree = async (path: string, argv: readonly string[], context: T
   }
   // 日本語は形態素で数量と日付を読む。解析器が無ければ単位の表で読むので、木は作れる。
   await adapter.prepare?.({ pos: true });
-  const profile = profileFor(context.config, path, source, language);
+  const profile = profileFor(context.config, path, source, language, resolveGenre(path, source, context.config, context.flag(argv, "--genre")).genre);
   return { source, tree: buildStructure({ path, source, language, markdown: isMarkdownPath(path), profile }, adapter.structure) };
 };
 
@@ -107,7 +109,7 @@ export const inOrder = async (paths: readonly string[], each: (path: string) =>
  */
 export const runTree = async (paths: readonly string[], argv: readonly string[], context: TreeContext): Promise<number> => {
   const format = context.flag(argv, "--format") ?? "sexp";
-  if (paths.length === 0 || !FORMATS.includes(format)) {
+  if (paths.length === 0 || !FORMATS.has(format)) {
     console.error(treeText(context).usage);
     return 1;
   }

package/src/config/by-path.ts

@@ -44,12 +44,11 @@ export const matches = (glob: string, base: string, path: string): boolean => to
 type PathSettings = { genre?: string; language?: string; profile?: string };
 
 export const applyByPath = (rules: readonly PathRule[], base: string, path: string): PathSettings =>
-  rules.reduce<PathSettings>((acc, rule) => {
-    if (!rule.files.some((glob) => matches(glob, base, path))) return acc;
-    return {
-      ...acc,
-      ...(rule.genre === undefined ? {} : { genre: rule.genre }),
-      ...(rule.language === undefined ? {} : { language: rule.language }),
-      ...(rule.profile === undefined ? {} : { profile: rule.profile }),
-    };
-  }, {});
+  rules
+    .filter((rule) => rule.files.some((glob) => matches(glob, base, path)))
+    .reduce<PathSettings>((settings, rule) => {
+      if (rule.genre !== undefined) settings.genre = rule.genre;
+      if (rule.language !== undefined) settings.language = rule.language;
+      if (rule.profile !== undefined) settings.profile = rule.profile;
+      return settings;
+    }, {});

package/src/config/load.ts

@@ -30,6 +30,10 @@ export type Config = {
   readonly prefer: Readonly<Record<string, string>>;
   /** この種類の文書に無いと困る見出し。チームが自分で決める。 */
   readonly requiredSections: readonly string[];
+  /** チームの固有名詞（組織名・製品名）。1 つの名前として読み、漢字の連なりや繰り返しに数えない。 */
+  readonly names: readonly string[];
+  /** names に書かれていたが名前として読めなかった値。黙って捨てると、並べたつもりの名前が効いていないことに気づけない。 */
+  readonly unreadableNames: readonly string[];
   /** パスごとの上書き。設定ファイルのある場所からの相対で照合する。 */
   readonly byPath: readonly PathRule[];
   readonly baseDir: string;
@@ -54,6 +58,8 @@ export const EMPTY: Config = {
   jargon: [],
   prefer: {},
   requiredSections: [],
+  names: [],
+  unreadableNames: [],
   byPath: [],
   baseDir: process.cwd(),
 };
@@ -114,6 +120,21 @@ const preferOf = (raw: unknown): Record<string, string> =>
       )
     : {};
 
+const isNameEntry = (value: unknown): value is string | number => typeof value === "string" || typeof value === "number";
+
+const printed = (value: unknown): string => JSON.stringify(value) ?? String(value);
+
+/** 名前は文字列か数（2025 のような名前）の並び。並びでない値と、並びの中の名前でない項目は読めないものとして返す。 */
+const namesOf = (raw: unknown): { readonly names: string[]; readonly unreadable: string[] } => {
+  if (raw === undefined || raw === null) return { names: [], unreadable: [] };
+  if (!Array.isArray(raw)) return { names: [], unreadable: [printed(raw)] };
+  const entries: unknown[] = raw;
+  return {
+    names: wordsOf(entries.filter(isNameEntry)),
+    unreadable: entries.filter((entry) => !isNameEntry(entry)).map(printed),
+  };
+};
+
 const byPathOf = (raw: unknown): PathRule[] => (Array.isArray(raw) ? raw.map(toPathRule).filter((rule) => rule !== undefined) : []);
 
 /** 設定ファイルが無くても動く。あっても、既定から変えたものだけが書かれている。spec §18。 */
@@ -122,6 +143,7 @@ export const loadConfig = (path: string): Config => {
   if (!isRecord(raw)) return { ...EMPTY, path };
   const declared: unknown = raw["ai_backend"];
   const backend: BackendName = isBackend(declared) ? declared : DEFAULT_BACKEND;
+  const names = namesOf(raw["names"]);
   return {
     genre: str(raw["genre"]),
     profile: str(raw["profile"]),
@@ -137,6 +159,8 @@ export const loadConfig = (path: string): Config => {
     jargon: wordsOf(raw["jargon"]),
     prefer: preferOf(raw["prefer"]),
     requiredSections: wordsOf(raw["required_sections"]),
+    names: names.names,
+    unreadableNames: names.unreadable,
     byPath: byPathOf(raw["by_path"]),
     baseDir: dirname(path),
   };

package/src/config/name-problems.ts

@@ -0,0 +1,15 @@
+import type { Config } from "./load.ts";
+import type { Texts, UiLanguage } from "../ui.ts";
+
+const TEXT: Texts<{ readonly unreadable: (where: string, value: string) => string }> = {
+  ja: {
+    unreadable: (where, value) => `${where}: names の ${value} は名前として読めません。names には名前を 1 行に 1 つずつ並べてください（- 個人情報保護委員会）`,
+  },
+  en: {
+    unreadable: (where, value) => `${where}: cannot read ${value} under names as a name. Write names as a list, one name per line (- Bank of England)`,
+  },
+};
+
+/** chaff.yaml の names のうち、名前として読めなかったもの。読めないまま黙ると、書いた人は名前を並べたつもりで何も変わっていない。 */
+export const nameProblems = (config: Pick<Config, "unreadableNames" | "path">, ui: UiLanguage = "ja"): string[] =>
+  config.unreadableNames.map((value) => TEXT[ui].unreadable(config.path ?? "chaff.yaml", value));

package/src/date-stamp.ts

@@ -21,7 +21,7 @@ const LABEL_EDGE = /[\s:：]/u;
 const datesOf = (candidate: StampCandidate): Span[] => candidate.dates.filter((date) => date.end > date.start);
 
 const withoutDates = (candidate: StampCandidate): string => {
-  const ordered = datesOf(candidate).sort((left, right) => left.start - right.start);
+  const ordered = datesOf(candidate).toSorted((left, right) => left.start - right.start);
   const gaps = ordered.reduce<{ readonly parts: readonly string[]; readonly from: number }>(
     (acc, date) => ({ parts: [...acc.parts, candidate.text.slice(acc.from, date.start)], from: Math.max(acc.from, date.end) }),
     { parts: [], from: 0 },

package/src/detectors/acronym-compound.ts

@@ -0,0 +1,9 @@
+/** - で繋いだ略語（RT-PCR）の部品。繋いでいなければ、その語だけ。 */
+export const partsOf = (acronym: string): string[] => acronym.split("-");
+
+/**
+ * 略語が説明済みか。- で繋いだ語は、繋いだ形のまま説明されているか、部品がどれも説明済みなら説明済み。
+ * US-EU は US も EU も通じるので指摘しない。RT-PCR は RT がどこにも説明されていないので、繋いだ形で指摘する。
+ */
+export const isExplained = (acronym: string, explainedAlone: (word: string) => boolean): boolean =>
+  explainedAlone(acronym) || partsOf(acronym).every(explainedAlone);

package/src/detectors/acronym-context.ts

@@ -1,5 +1,10 @@
 import { escapeRegExp } from "../orthography.ts";
 import { ROMAN_NUMERAL } from "./roman-numeral.ts";
+import { citationKeySpans } from "./citation-key.ts";
+import { dottedNameSpans } from "./dotted-name.ts";
+import { loneNumeralSpans, nameNumeralSpans } from "./name-numeral.ts";
+import { placeholderSpans } from "./placeholder.ts";
+import { seriesLabelSpans } from "./series-label.ts";
 
 /**
  * 大文字の語が略語ではなく、決まった書き方の一部として読める所（3:30 PM、1pm ET、USD 1,000、Kansas City, MO 64108）。
@@ -18,6 +23,10 @@ export type NotationWords = {
   readonly emphasis: readonly string[];
   /** 番号を後ろに書く、文書の区切りの名前（Part、Section、Title）。 */
   readonly divisions: readonly string[];
+  /** 速記録が大文字で書く発言者の姓の前に置く敬称（Mr.、Mrs.、Madam）。 */
+  readonly honorifics: readonly string[];
+  /** 日付・時刻の数字の後ろに書く単位（年、月、日、時、分）。その前の同じ大文字の繰り返し（YY年）は書式の置き場所。 */
+  readonly dateTimeUnits: readonly string[];
 };
 
 // 空の語彙表は「その書き方が無い」。空の選択肢 (?:) は至る所で空文字に当たるので、何にも当たらない形にする。
@@ -37,6 +46,9 @@ const AMOUNT = String.raw`(?:\d{1,3}(?:,\d{3})+|\d+)(?:\.\d+)?`;
  */
 const divisionOf = (words: readonly string[]): string => oneOf(words.flatMap((word) => [word, word.toUpperCase()]));
 
+/** 敬称のすぐ後ろの大文字の姓（Mr. HAWLEY、Dr. O'NEIL）。速記録は発言者をこう書き、略語ではない。 */
+const SURNAME_IN_CAPITALS = String.raw`[A-Z]+(?:['’-][A-Z]+)*(?![\p{L}\p{N}_])`;
+
 // 強調の記号は空白に置き換えてある（**3:30** PM）ので、部品の間の空白は数を問わない。
 const patternsOf = (words: NotationWords): readonly RegExp[] => [
   new RegExp(String.raw`${CLOCK_12}\s*${oneOf(words.meridiem)}`, "gu"),
@@ -46,6 +58,7 @@ const patternsOf = (words: NotationWords): readonly RegExp[] => [
   new RegExp(String.raw`,\s+${oneOf(words.usStates)}\s+\d{5}(?:-\d{4})?(?!\d)`, "gu"),
   new RegExp(oneOf(words.emphasis), "gu"),
   new RegExp(String.raw`(?<![\p{L}\p{N}_])${divisionOf(words.divisions)}\s+${ROMAN_NUMERAL}(?![\p{L}\p{N}_&])`, "gu"),
+  new RegExp(String.raw`(?<![\p{L}\p{N}_])${oneOf(words.honorifics)}\s+${SURNAME_IN_CAPITALS}`, "gu"),
 ];
 
 export type NotAcronymSpans = (text: string) => Span[];
@@ -56,5 +69,13 @@ export type NotAcronymSpans = (text: string) => Span[];
  */
 export const notAcronymSpansOf = (words: NotationWords): NotAcronymSpans => {
   const patterns = patternsOf(words);
-  return (text) => patterns.flatMap((pattern) => [...text.matchAll(pattern)].map((match) => ({ start: match.index, end: match.index + match[0].length })));
+  return (text) => [
+    ...patterns.flatMap((pattern) => [...text.matchAll(pattern)].map((match) => ({ start: match.index, end: match.index + match[0].length }))),
+    ...citationKeySpans(text),
+    ...dottedNameSpans(text),
+    ...nameNumeralSpans(text),
+    ...loneNumeralSpans(text),
+    ...seriesLabelSpans(text),
+    ...placeholderSpans(text, words.dateTimeUnits),
+  ];
 };