chaffjs 0.7.0 → 0.8.0

package/src/adapter-load.ts

@@ -59,13 +59,41 @@ const LANGUAGE_ID = /^[a-z]{2,3}$/u;
 export const packageFor = (language: string): string | undefined =>
   ADAPTER_PACKAGE[language] ?? (LANGUAGE_ID.test(language) ? `@chaffjs/lang-${language}` : undefined);
 
-const importAdapter = async (specifier: string, language: string): Promise<unknown> => {
+/**
+ * 探す順。公式（`@chaffjs/lang-<言語>`）が先で、無ければ第三者の `chaff-lang-<言語>`。
+ * `@typescript-eslint/*` と `eslint-plugin-*` の分け方と同じで、README にもそう書いてある。同梱の言語は表のものだけ。
+ */
+export const packagesFor = (language: string): readonly string[] => {
+  if (ADAPTER_PACKAGE[language] !== undefined) return [ADAPTER_PACKAGE[language]];
+  return LANGUAGE_ID.test(language) ? [`@chaffjs/lang-${language}`, `chaff-lang-${language}`] : [];
+};
+
+export type Importer = (specifier: string) => Promise<unknown>;
+
+/**
+ * そのパッケージ自体が入っていないときだけ真。入っているパッケージが自分の依存を見つけられないときも同じ
+ * ERR_MODULE_NOT_FOUND になるので、Node の文言が探した名前を挙げているかで分ける。
+ */
+export const isAbsent = (err: unknown, specifier: string): boolean =>
+  err instanceof Error && "code" in err && err.code === "ERR_MODULE_NOT_FOUND" && err.message.includes(`'${specifier}'`);
+
+/** 入っている最初のものを読む。入っていないのは次へ。入っていて壊れているものは、次へ行かずにそのまま投げる。 */
+const importFirst = async (specifiers: readonly string[], language: string, importer: Importer): Promise<{ specifier: string; module: unknown }> => {
+  const [first, ...rest] = specifiers;
+  if (first === undefined) throw new Error(`no adapter for language "${language}"`);
   try {
-    return await import(specifier);
+    return { specifier: first, module: await importer(first) };
   } catch (err) {
-    const missing = err instanceof Error && "code" in err && err.code === "ERR_MODULE_NOT_FOUND";
-    if (missing) throw new Error(`言語 ${language} のパッケージ ${specifier} が入っていません（npm i -D ${specifier}）`, { cause: err });
-    throw err;
+    if (!isAbsent(err, first)) throw err;
+    if (rest.length > 0) return importFirst(rest, language, importer);
+    const all = packagesFor(language);
+    const install = `npm i -D ${all[0] ?? first}`;
+    // Only the requested language is known here; a Japanese message for Japanese, English for any other.
+    const message =
+      language === "ja"
+        ? `言語 ${language} のパッケージが入っていません（${all.join(" か ")}。${install}）`
+        : `No package for language ${language} is installed (${all.join(" or ")}; ${install})`;
+    throw new Error(message, { cause: err });
   }
 };
 
@@ -74,13 +102,16 @@ const importAdapter = async (specifier: string, language: string): Promise<unkno
  * core だけで起動し、文字種で言語を当ててから、その言語のアダプタを読む。
  * 全言語を静的に import すると、使わない言語のぶんまで npx の初回取得が膨らむ。
  */
-export const loadAdapter = async (language: string): Promise<LanguageAdapter> => {
-  const specifier = packageFor(language);
-  if (specifier === undefined) throw new Error(`no adapter for language "${language}"`);
-  const module = await importAdapter(specifier, language);
+export const loadAdapter = async (language: string, importer: Importer = (specifier) => import(specifier)): Promise<LanguageAdapter> => {
+  const { specifier, module } = await importFirst(packagesFor(language), language, importer);
   if (typeof module !== "object" || module === null) throw new Error(`${specifier} did not export a module`);
   const candidate = pickExport(module);
   const broken = checkAdapter(candidate);
-  if (broken !== undefined || !isAdapter(candidate)) throw new Error(`${specifier} が LanguageAdapter を export していません: ${broken ?? ""}`);
+  if (broken !== undefined || !isAdapter(candidate)) {
+    const why = broken ?? "";
+    throw new Error(
+      language === "ja" ? `${specifier} が LanguageAdapter を export していません: ${why}` : `${specifier} does not export a LanguageAdapter: ${why}`,
+    );
+  }
   return candidate;
 };

package/src/cli-args.ts

@@ -0,0 +1,9 @@
+/**
+ * Options of the commands that take files to check, whose value is the next argument. That value is not a file.
+ * `--why` (relax), `--format` and `--language` (tree) belong to commands that read their own arguments.
+ */
+export const VALUE_FLAGS: readonly string[] = ["--sarif", "--genre", "--rule"];
+
+/** The arguments that name what to check: everything that is neither an option nor an option's value. */
+export const targetsOf = (args: readonly string[]): string[] =>
+  args.filter((arg, index) => !arg.startsWith("--") && !(index > 0 && VALUE_FLAGS.includes(args[index - 1] ?? "")));

package/src/cli-text.ts

@@ -0,0 +1,182 @@
+// What the command line says, in Japanese and English. Per-file text follows the file's language; the rest
+// follows hostLanguage (chaff.yaml's language, else the terminal's locale).
+import type { Texts } from "./ui.ts";
+
+/** Where a file's genre came from, as the header names it. */
+export type GenreSource = "--genre" | "by_path" | "config" | "default" | "front-matter" | "path" | "content";
+
+const USAGE_JA = `chaff — 文章の読みにくいところを見つけます。文章は書き換えません。
+
+  chaff <file|dir|glob>...       検査する（設定も API key も要りません）
+  chaff .                        この場所の Markdown を全部
+  chaff test <file|dir>...       意味を読む検査も動かす（API key が要ります）
+                                 判定役は chaff.yaml の ai_backend で選びます
+  chaff init                     chaff.yaml を作る
+  chaff eval <dir>               手元の文書で閾値を測り直す
+  chaff explain <rule>           そのルールの意図と根拠を読む
+  chaff genres                   ジャンルの一覧
+  chaff tree <file> [--format sexp|json]  文書を番地の付いた木にする（条・項・定義・参照）
+  chaff cite <原文> <引用.json>           回答の引用（番地と引用文）が原文にあるかを確かめる
+  chaff rules --json             いまの設定を JSON で出す（AI に渡す用）
+  chaff baseline <dir>           いまある指摘を棚上げする（既存の repo に入れるとき）
+  chaff suppressions <dir>       stet で黙らせている指摘を数える
+  chaff relax|strict|off <rule> [--why "理由"]
+  chaff skill [--global]         Claude Code の skill を入れる（.claude/skills/chaff/、--global で ~/.claude/）
+
+  --compact         エンジニア向けの 1 行形式
+  --experimental    試験中の rule も動かす
+  --genre <ジャンル>  この実行だけジャンルを決める（chaff.yaml より優先）
+  --show-baseline   棚上げした分も含めて全部見る
+  --watch           保存のたびに見直し、変わったところだけ出す
+  --dry-run         test で、何を AI に送るかだけを見る（API を呼びません）
+  --sarif <path>    指摘を SARIF で書き出す（GitHub の PR の行に出すため）
+
+この箇所だけ黙らせる:  <!-- stet: rule-id — 理由 -->
+
+値は strict / normal / relaxed / off の 4 つから選びます。
+`;
+
+const USAGE_EN = `chaff — finds what makes writing hard to read. It never rewrites the text.
+
+  chaff <file|dir|glob>...       check (no config or API key needed)
+  chaff .                        every Markdown file here
+  chaff test <file|dir>...       also run the checks that read meaning (needs an API key)
+                                 the judge is chosen by ai_backend in chaff.yaml
+  chaff init                     create chaff.yaml
+  chaff eval <dir>               re-measure the limits on your own documents
+  chaff explain <rule>           read what a rule is for and why
+  chaff genres                   list the genres
+  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 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"]
+  chaff skill [--global]         install the Claude Code skill (.claude/skills/chaff/; --global for ~/.claude/)
+
+  --compact         one line per finding, for engineers
+  --experimental    run the experimental rules too
+  --genre <genre>   the genre for this run only (wins over chaff.yaml)
+  --show-baseline   show the shelved findings too
+  --watch           re-check on every save and print only what changed
+  --dry-run         with test, show what would be sent to the AI (no API call)
+  --sarif <path>    write the findings as SARIF (for comments on a GitHub PR)
+
+Silence one spot:  <!-- stet: rule-id — reason -->
+
+A rule's level is one of strict / normal / relaxed / off.
+`;
+
+export type CliText = {
+  readonly usage: string;
+  readonly languageName: (language: string) => string;
+  readonly genreSource: Readonly<Record<GenreSource, string>>;
+  readonly header: (path: string, genre: string, language: string, from: string, shelved: number, hushed: number) => string;
+  readonly noMarkdown: (targets: string) => string;
+  readonly noMarkdownHere: string;
+  readonly noAdapter: (language: string) => string;
+  readonly unknownGenre: (genre: string) => string;
+  readonly unknownRule: (id: string) => string;
+  readonly unknownRuleWithList: (id: string, list: string) => string;
+  readonly unnamed: string;
+  readonly sarifWritten: (path: string, count: number) => string;
+  readonly unchanged: string;
+  readonly findingsUnit: string;
+  readonly watching: (files: number, findings: number) => string;
+  readonly watchHint: string;
+  readonly baselineDone: (files: number, entries: number, file: string) => readonly string[];
+  readonly genres: (list: readonly string[]) => string;
+  readonly unit: (ruleId: string, language: string) => string;
+};
+
+export const CLI_TEXT: Texts<CliText> = {
+  ja: {
+    usage: USAGE_JA,
+    languageName: (language) => (language === "ja" ? "日本語" : "英語"),
+    genreSource: {
+      "--genre": "--genre",
+      by_path: "chaff.yaml の by_path",
+      config: "chaff.yaml",
+      default: "既定",
+      "front-matter": "front matter",
+      path: "パス",
+      content: "内容",
+    },
+    header: (path, genre, language, from, shelved, hushed) =>
+      [`${path}   ${genre} · ${language}   ジャンルは${from}から`, shelved > 0 ? `   棚上げ ${shelved} 件` : "", hushed > 0 ? `   stet ${hushed} 件` : ""].join(
+        "",
+      ),
+    noMarkdown: (targets) => `Markdown が 1 つも見つかりませんでした: ${targets}`,
+    noMarkdownHere: "Markdown が 1 つも見つかりませんでした。",
+    noAdapter: (language) => `言語 "${language}" のアダプタがありません。`,
+    unknownGenre: (genre) => `ジャンル "${genre}" はありません。npx chaff genres で一覧が出ます。`,
+    unknownRule: (id) => `${id} というルールはありません。npx chaff rules --json で一覧が出ます。`,
+    unknownRuleWithList: (id, list) => `${id} というルールはありません。\n一覧:\n${list}`,
+    unnamed: "(名前なし)",
+    sarifWritten: (path, count) => `\n  SARIF を書きました: ${path}（${count} 件）`,
+    unchanged: "変わりませんでした",
+    findingsUnit: " 件",
+    watching: (files, findings) => `\n  ${files} ファイルを見ています。いまの指摘は ${findings} 件です。`,
+    watchHint: "  保存するたびに、変わったところだけ出します。止めるには Ctrl-C。\n",
+    baselineDone: (files, entries, file) => [
+      "",
+      `  ${files} ファイルを走査しました。`,
+      "",
+      `  ${entries} 件の指摘を ${file} に記録しました。`,
+      "  以後、これらは報告されません。新しく増えたものだけが出ます。",
+      "",
+      `  ${file} を commit してください。`,
+      "",
+    ],
+    genres: (list) =>
+      ["", "  使えるジャンル:", ...list.map((genre) => `    ${genre}`), "", "  chaff.yaml の genre に書くか、--genre で指定します。", ""].join("\n"),
+    unit: (ruleId, language) => {
+      if (ruleId === "bold-density") return "1000 字あたりの箇所数";
+      if (ruleId !== "max-sentence-length") return "回";
+      return language === "ja" ? "文字" : "語";
+    },
+  },
+  en: {
+    usage: USAGE_EN,
+    languageName: (language) => (language === "ja" ? "Japanese" : "English"),
+    genreSource: {
+      "--genre": "--genre",
+      by_path: "by_path in chaff.yaml",
+      config: "chaff.yaml",
+      default: "the default",
+      "front-matter": "front matter",
+      path: "the path",
+      content: "the content",
+    },
+    header: (path, genre, language, from, shelved, hushed) =>
+      [`${path}   ${genre} · ${language}   genre from ${from}`, shelved > 0 ? `   ${shelved} shelved` : "", hushed > 0 ? `   ${hushed} stet` : ""].join(""),
+    noMarkdown: (targets) => `No Markdown files found: ${targets}`,
+    noMarkdownHere: "No Markdown files found.",
+    noAdapter: (language) => `No language package for "${language}".`,
+    unknownGenre: (genre) => `There is no genre "${genre}". npx chaff genres lists them.`,
+    unknownRule: (id) => `There is no rule named ${id}. npx chaff rules --json lists them.`,
+    unknownRuleWithList: (id, list) => `There is no rule named ${id}.\nRules:\n${list}`,
+    unnamed: "(no name)",
+    sarifWritten: (path, count) => `\n  Wrote SARIF: ${path} (${count} finding${count === 1 ? "" : "s"})`,
+    unchanged: "no change",
+    findingsUnit: " findings",
+    watching: (files, findings) => `\n  Watching ${files} file${files === 1 ? "" : "s"}. ${findings} finding${findings === 1 ? "" : "s"} now.`,
+    watchHint: "  Each save prints only what changed. Ctrl-C to stop.\n",
+    baselineDone: (files, entries, file) => [
+      "",
+      `  Checked ${files} file${files === 1 ? "" : "s"}.`,
+      "",
+      `  Recorded ${entries} finding${entries === 1 ? "" : "s"} in ${file}.`,
+      "  They will not be reported again; only new ones will.",
+      "",
+      `  Commit ${file}.`,
+      "",
+    ],
+    genres: (list) => ["", "  Genres:", ...list.map((genre) => `    ${genre}`), "", "  Set one with genre in chaff.yaml, or with --genre.", ""].join("\n"),
+    unit: (ruleId, language) => {
+      if (ruleId === "bold-density") return "places per 1000 characters";
+      if (ruleId !== "max-sentence-length") return "times";
+      return language === "ja" ? "characters" : "words";
+    },
+  },
+};

package/src/cli.ts

@@ -16,6 +16,7 @@ import { runEval } from "./commands/eval.ts";
 import { runTest } from "./commands/test.ts";
 import { frontMatterGenre, guessGenre } from "./genre.ts";
 import { GENRES, runInit } from "./init.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";
@@ -23,63 +24,50 @@ import { renderFriendly } from "./render/friendly.ts";
 import { rulesJson } from "./render/rules-json.ts";
 import { renderSarif } from "./render/sarif.ts";
 import { VERSION } from "./version.ts";
-import { runTree, treeTargets } from "./commands/tree.ts";
+import { runTree, treeTargets, type TreeContext } from "./commands/tree.ts";
 import { citeTargets, runCite } from "./commands/cite.ts";
+import { runSkill } from "./commands/skill.ts";
+import { homedir } from "node:os";
 import { ruleProblems } from "./config/rule-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";
 
-const USAGE = `chaff — 文章の読みにくいところを見つけます。文章は書き換えません。
-
-  chaff <file|dir|glob>...       検査する（設定も API key も要りません）
-  chaff .                        この場所の Markdown を全部
-  chaff test <file|dir>...       意味を読む検査も動かす（API key が要ります）
-                                 判定役は chaff.yaml の ai_backend で選びます
-  chaff init                     chaff.yaml を作る
-  chaff eval <dir>               手元の文書で閾値を測り直す
-  chaff explain <rule>           そのルールの意図と根拠を読む
-  chaff genres                   ジャンルの一覧
-  chaff tree <file> [--format sexp|json]  文書を番地の付いた木にする（条・項・定義・参照）
-  chaff cite <原文> <引用.json>           回答の引用（番地と引用文）が原文にあるかを確かめる
-  chaff rules --json             いまの設定を JSON で出す（AI に渡す用）
-  chaff baseline <dir>           いまある指摘を棚上げする（既存の repo に入れるとき）
-  chaff suppressions <dir>       stet で黙らせている指摘を数える
-  chaff relax|strict|off <rule> [--why "理由"]
-
-  --compact         エンジニア向けの 1 行形式
-  --experimental    試験中の rule も動かす
-  --show-baseline   棚上げした分も含めて全部見る
-  --watch           保存のたびに見直し、変わったところだけ出す
-  --dry-run         test で、何を AI に送るかだけを見る（API を呼びません）
-  --sarif <path>    指摘を SARIF で書き出す（GitHub の PR の行に出すため）
-
-この箇所だけ黙らせる:  <!-- stet: rule-id — 理由 -->
-
-値は strict / normal / relaxed / off の 4 つから選びます。
-`;
+/** 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 resolveGenre = (path: string, source: string, config: Config): { genre: string; from: string } => {
-  // パスごとの上書きが最優先。「全体はこう、ここだけは違う」を書けるようにする。
+const resolveGenre = (path: string, source: string, config: Config, cliGenre?: string): { genre: string; from: GenreSource } => {
+  // コマンドで指定したものが最優先。その実行だけの指定だから、設定より強い。
+  if (cliGenre !== undefined) return { genre: cliGenre, from: "--genre" };
+  // パスごとの上書きが次。「全体はこう、ここだけは違う」を書けるようにする。
   const override = applyByPath(config.byPath, config.baseDir, path);
-  if (override.genre !== undefined) return { genre: override.genre, from: `${CONFIG_FILE} の by_path` };
-  if (config.genre !== undefined) return { genre: config.genre, from: CONFIG_FILE };
+  if (override.genre !== undefined) return { genre: override.genre, from: "by_path" };
+  if (config.genre !== undefined) return { genre: config.genre, from: "config" };
   const guess = guessGenre(path, source, frontMatterGenre(source));
-  return guess === undefined ? { genre: "blog/tech", from: "既定" } : { genre: guess.genre, from: guess.from };
+  return guess === undefined ? { genre: "blog/tech", from: "default" } : { genre: guess.genre, from: guess.from };
 };
 
+/** resolveGenre with this run's --genre, for the commands that take it as a dependency. */
+const genreFrom =
+  (argv: readonly string[]) =>
+  (path: string, source: string, config: Config): { genre: string; from: GenreSource } =>
+    resolveGenre(path, source, config, flag(argv, "--genre"));
+
 const findRule = (rules: readonly RuleDefinition[], id: string | undefined): RuleDefinition | undefined => rules.find((rule) => rule.id === id);
 
 const changeSetting = (command: Level, ruleId: string | undefined, why: string | undefined): number => {
   const config = readConfig();
-  const rule = findRule(loadRules(config.language ?? "ja"), ruleId);
+  const language = config.language ?? hostLanguage(undefined, process.env);
+  const rule = findRule(loadRules(language), ruleId);
   if (rule === undefined) {
-    console.error(`${ruleId ?? "(名前なし)"} というルールはありません。npx chaff rules --json で一覧が出ます。`);
+    console.error(hostText(config).unknownRule(ruleId ?? hostText(config).unnamed));
     return 1;
   }
-  const outcome = applyLevel(join(process.cwd(), CONFIG_FILE), rule, command, why, config.language ?? "ja", process.env["USER"] ?? "unknown");
+  const outcome = applyLevel(join(process.cwd(), CONFIG_FILE), rule, command, why, language, process.env["USER"] ?? "unknown");
   console.log(outcome.message);
   return outcome.ok ? 0 : 1;
 };
@@ -99,17 +87,17 @@ type Inspected = {
   readonly all: readonly string[];
 };
 
-const headerFor = (path: string, genre: string, from: string, language: string, shelved: number, hushed: number): string => {
-  const shelf = shelved > 0 ? `   棚上げ ${shelved} 件` : "";
-  const stet = hushed > 0 ? `   stet ${hushed} 件` : "";
-  return `${path}   ${genre} \u00b7 ${language === "ja" ? "日本語" : "英語"}   ジャンルは${from}から${shelf}${stet}`;
+/** 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 = 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, from } = resolveGenre(path, source, config);
+  const { genre, from } = resolveGenre(path, source, config, flag(argv, "--genre"));
   const rules = loadRules(language);
   const experimental = config.experimental || argv.includes("--experimental");
   await adapter.prepare?.(neededBy(rules, config.rules, experimental, genre, language));
@@ -149,32 +137,42 @@ const writeSarif = (results: readonly Inspected[], argv: readonly string[]): voi
   );
   mkdirSync(dirname(path), { recursive: true });
   writeFileSync(path, renderSarif(located, VERSION), "utf8");
-  console.log(`\n  SARIF を書きました: ${path}（${located.length} 件）`);
+  console.log(hostText(readConfig()).sarifWritten(path, located.length));
 };
 
 /** 効いていない設定は、結果の前に一度だけ言う。標準エラーに出すので、JSON や SARIF の出力は汚さない。 */
 const warnRuleProblems = (config: Config, language: string): void => {
-  ruleProblems(config, loadRules(language)).forEach((problem) => console.error(`chaff: ${problem}`));
+  ruleProblems(config, loadRules(language), 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 => {
+  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 lint = async (targets: readonly string[], argv: readonly string[]): Promise<number> => {
   const paths = collectTargets(targets);
+  const config = readConfig();
   if (paths.length === 0) {
     // 0 件を成功にすると「CI は通っているが何も検証していない」状態が続く。§14。
-    console.error(`Markdown が 1 つも見つかりませんでした: ${targets.join(", ")}`);
+    console.error(hostText(config).noMarkdown(targets.join(", ")));
     return 1;
   }
-  const config = readConfig();
   const language = config.language ?? "ja";
   if (packageFor(language) === undefined) {
-    console.error(`言語 "${language}" のアダプタがありません。`);
+    console.error(hostText(config).noAdapter(language));
     return 1;
   }
   warnRuleProblems(config, language);
   const results = await Promise.all(paths.map((path) => inspect(path, config, argv)));
   writeSarif(results, argv);
   results.filter((result) => result.outcome.findings.length > 0 || paths.length === 1).forEach((result) => console.log(result.text));
-  renderSummary(results.map((result) => result.outcome)).forEach((line) => console.log(line));
+  renderSummary(
+    results.map((result) => result.outcome),
+    summaryLanguage(results, config),
+  ).forEach((line) => console.log(line));
   return results.some((result) => result.outcome.findings.some((finding) => finding.severity === "error")) ? 1 : 0;
 };
 
@@ -184,11 +182,12 @@ const lint = async (targets: readonly string[], argv: readonly string[]): Promis
  */
 const runWatch = async (targets: readonly string[], argv: readonly string[]): Promise<number> => {
   const paths = collectTargets(targets);
+  const config = readConfig();
+  const text = hostText(config);
   if (paths.length === 0) {
-    console.error(`Markdown が 1 つも見つかりませんでした: ${targets.join(", ")}`);
+    console.error(text.noMarkdown(targets.join(", ")));
     return 1;
   }
-  const config = readConfig();
   warnRuleProblems(config, config.language ?? "ja");
   const seen = new Map<string, Snapshot>();
   const once = async (path: string, first: boolean): Promise<void> => {
@@ -197,13 +196,13 @@ const runWatch = async (targets: readonly string[], argv: readonly string[]): Pr
     const before = seen.get(path) ?? {};
     seen.set(path, after);
     if (first) return;
-    const change = describeChange(before, after);
-    console.log(`${clock()}  ${path}  ${change ?? "変わりませんでした"}`);
+    const change = describeChange(before, after, text.findingsUnit);
+    console.log(`${clock()}  ${path}  ${change ?? text.unchanged}`);
   };
   await Promise.all(paths.map((path) => once(path, true)));
   const totals = [...seen.values()].reduce((sum, snapshot) => sum + Object.values(snapshot).reduce((inner, count) => inner + count, 0), 0);
-  console.log(`\n  ${paths.length} ファイルを見ています。いまの指摘は ${totals} 件です。`);
-  console.log("  保存するたびに、変わったところだけ出します。止めるには Ctrl-C。\n");
+  console.log(text.watching(paths.length, totals));
+  console.log(text.watchHint);
   const stop = watchPaths(paths, (path) => void once(path, false));
   process.on("SIGINT", () => {
     stop();
@@ -214,49 +213,33 @@ const runWatch = async (targets: readonly string[], argv: readonly string[]): Pr
 
 const explain = (ruleId: string | undefined): number => {
   const config = readConfig();
-  const language = config.language ?? "ja";
+  // 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 rule = findRule(rules, ruleId);
   if (rule === undefined) {
     const list = rules.map((entry) => `  ${entry.id}`).join("\n");
-    console.error(`${ruleId ?? "(名前なし)"} というルールはありません。\n一覧:\n${list}`);
+    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, unitOf(rule.id, language), config.genre));
+  console.log(renderExplain(rule, current, language, text.unit(rule.id, language), config.genre));
   return 0;
 };
 
-/** 閾値の単位。explain で「4 とは何の 4 か」を示すため。 */
-const unitOf = (ruleId: string, language: string): string => {
-  if (ruleId === "bold-density") return "1000 字あたりの箇所数";
-  if (ruleId !== "max-sentence-length") return "回";
-  return language === "ja" ? "文字" : "語";
-};
-
 const runBaseline = async (targets: readonly string[], argv: readonly string[]): Promise<number> => {
   const paths = collectTargets(targets.length > 0 ? targets : ["."]);
+  const config = readConfig();
   if (paths.length === 0) {
-    console.error("Markdown が 1 つも見つかりませんでした。");
+    console.error(hostText(config).noMarkdownHere);
     return 1;
   }
-  const config = readConfig();
   const results = await Promise.all(paths.map((path) => inspect(path, config, [...argv, "--show-baseline"])));
   const entries = results.flatMap((result) => result.all);
   const file = join(process.cwd(), BASELINE_FILE);
   writeBaseline(file, entries);
-  console.log(
-    [
-      "",
-      `  ${paths.length} ファイルを走査しました。`,
-      "",
-      `  ${entries.length} 件の指摘を ${BASELINE_FILE} に記録しました。`,
-      "  以後、これらは報告されません。新しく増えたものだけが出ます。",
-      "",
-      `  ${BASELINE_FILE} を commit してください。`,
-      "",
-    ].join("\n"),
-  );
+  console.log(hostText(config).baselineDone(paths.length, entries.length, BASELINE_FILE).join("\n"));
   return 0;
 };
 
@@ -264,56 +247,75 @@ 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)));
+  console.log(
+    renderSuppressions(
+      results.map((result) => result.perFile),
+      hostLanguage(config.language, process.env),
+    ),
+  );
   return 0;
 };
 
 type Handler = (argv: readonly string[]) => number | Promise<number>;
 
 /** `--` で始まらない引数。対象のパス。 */
-const positional = (argv: readonly string[]): string[] => argv.slice(1).filter((arg) => !arg.startsWith("--"));
+const positional = (argv: readonly string[]): string[] => targetsOf(argv.slice(1));
 
 const showRules = (): number => {
   const config = readConfig();
-  const language = config.language ?? "ja";
+  const language = config.language ?? hostLanguage(undefined, process.env);
   warnRuleProblems(config, language);
   console.log(rulesJson(loadRules(language), config, language, config.genre ?? "blog/tech"));
   return 0;
 };
 
 const showGenres = (): number => {
-  console.log(["", "  使えるジャンル:", ...GENRES.map((genre) => `    ${genre}`), "", "  chaff.yaml の genre に書くか、--genre で指定します。", ""].join("\n"));
+  console.log(hostText(readConfig()).genres(GENRES));
   return 0;
 };
 
+const treeContext = (): TreeContext => {
+  const config = readConfig();
+  return { config, flag, ui: hostLanguage(config.language, process.env) };
+};
+
 /** 分岐を数珠つなぎにせず表にする。足すときに main を太らせない。 */
 const HANDLERS: Readonly<Record<string, Handler>> = {
   init: (argv) => {
-    runInit(process.cwd(), flag(argv, "--genre") ?? "blog/tech").forEach((line) => console.log(line));
+    runInit(process.cwd(), flag(argv, "--genre") ?? "blog/tech", hostLanguage(readConfig().language, process.env)).forEach((line) => console.log(line));
     return 0;
   },
   genres: showGenres,
   rules: showRules,
   explain: (argv) => explain(argv[1]),
-  eval: (argv) => runEval(positional(argv), argv, { config: readConfig(), resolveGenre, flag }),
-  tree: (argv) => runTree(treeTargets(argv), argv, { config: readConfig(), flag }),
-  cite: (argv) => runCite(citeTargets(argv), argv, { config: readConfig(), flag }),
-  test: (argv) => runTest(positional(argv), argv, { config: readConfig(), resolveGenre, inspect }),
+  eval: (argv) => runEval(positional(argv), argv, { config: readConfig(), resolveGenre: genreFrom(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 }),
   baseline: (argv) => runBaseline(positional(argv), argv),
   suppressions: (argv) => runSuppressions(positional(argv), argv),
   relax: (argv) => changeSetting("relaxed", argv[1], flag(argv, "--why")),
   strict: (argv) => changeSetting("strict", argv[1], flag(argv, "--why")),
   off: (argv) => changeSetting("off", argv[1], flag(argv, "--why")),
+  skill: (argv) => runSkill(argv, { cwd: process.cwd(), home: homedir(), ui: hostLanguage(readConfig().language, process.env) }),
 };
 
+/** Every subcommand. Anything else on the command line is a file to check. */
+export const COMMANDS: readonly string[] = Object.keys(HANDLERS);
+
 export const main = async (argv: readonly string[]): Promise<number> => {
   const first = argv[0];
   if (first === undefined || first === "--help" || first === "-h") {
-    console.log(USAGE);
+    console.log(hostText(readConfig()).usage);
     return first === undefined ? 1 : 0;
   }
+  const cliGenre = flag(argv, "--genre");
+  if (cliGenre !== undefined && !GENRES.includes(cliGenre)) {
+    console.error(hostText(readConfig()).unknownGenre(cliGenre));
+    return 1;
+  }
   const handler = HANDLERS[first];
   if (handler !== undefined) return handler(argv);
-  const targets = (first === "lint" ? argv.slice(1) : argv).filter((arg) => !arg.startsWith("--"));
+  const targets = targetsOf(first === "lint" ? argv.slice(1) : argv);
   return argv.includes("--watch") ? runWatch(targets, argv) : lint(targets, argv);
 };