chaffjs 0.14.0 → 0.16.0

package/skills/chaff/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: chaff
-description: "Check prose with chaff (npx chaffjs): run it on Markdown or text, read each finding, fix the text or record why not, and tune chaff.yaml with rules --json and relax --why. Use when asked to lint, proofread or tighten documents, or to set up a team's writing rules."
+description: "Check prose with chaff (npx chaffjs): pick the genre preset for the kind of document (contract, statute, manual, FAQ, paper, fiction, transcript…), run it on Markdown or text, read each finding, fix the text or record why not, and tune chaff.yaml with rules --json and relax --why. Use when asked to lint, proofread or tighten documents, or to set up a team's writing rules."
 ---
 
 # Checking writing with chaff
@@ -9,12 +9,30 @@ chaff finds what makes writing hard to read — long sentences, padding, mixed s
 contract — and never rewrites anything. Reading the findings and changing the text is your part. Japanese and
 English documents both work; the language is detected per file.
 
+## Pick the genre first
+
+A genre is a preset for one kind of document: which rules run, where their limits are, and how the document is
+read. A contract checked as a blog post gets wrong findings, so choose the genre before reading any finding.
+
+1. Name the kind from the document itself. `npx chaffjs genres` lists every genre with what it is for:
+   `legal/contract`, `legal/statute`, `docs/manual`, `docs/faq`, `academic/paper`, `literature/fiction`,
+   `speech/transcript`, `business/report`, `technical/spec`, …
+2. Unsure? Run once without `--genre`. When the file looks like another kind, the line under the header says so
+   (`Looks like: Contract and terms. Try --genre legal/contract`); use that genre if it fits.
+3. Run with it: `npx chaffjs --genre legal/contract contract.md`. For a folder of one kind,
+   `npx chaffjs init --genre legal/contract` writes it into `chaff.yaml` (always pass `--genre`: without it,
+   `init` asks at a terminal).
+4. The header's first line shows the genre used and where it came from. Check it before trusting the findings.
+
+A rule the genre turns off is listed under "did not run" with the genre as the reason. That is the preset's
+choice, not a gap; turn it back on (`rules:` in `chaff.yaml`) only when the person asks.
+
 ## Run it
 
 ```sh
-npx chaffjs <file|dir|glob>...     # human-readable, one block per finding (a folder or glob picks up .md / .markdown / .mdx; name a .txt file directly)
-npx chaffjs . --compact            # two lines per finding: line:col severity message, then the rule id
-npx chaffjs <file> --experimental  # also the experimental rules
+npx chaffjs --genre <genre> <file|dir|glob>...   # human-readable, one block per finding (a folder or glob picks up .md / .markdown / .mdx; name a .txt file directly)
+npx chaffjs . --compact                          # two lines per finding: line:col severity message, then the rule id
+npx chaffjs <file> --experimental                # also the experimental rules
 ```
 
 A run exits 1 when a finding is an `error`. It also exits 1 when it could not check anything: no file to
@@ -39,15 +57,16 @@ relaxing a rule.
 
 ## Tune chaff.yaml
 
-- `npx chaffjs init` writes a commented `chaff.yaml` when there is none (an existing one is left as it is), and
-  adds `.chaff-cache/` and `.env*` to `.gitignore`.
-- `npx chaffjs rules --json` prints every rule with its levels, the setting in effect (`now`) and why a rule is
-  off. Read it instead of guessing rule names or limits.
+- `npx chaffjs init --genre <genre>` writes a commented `chaff.yaml` for that genre when there is none (an
+  existing one is left as it is), and adds `.chaff-cache/` and `.env*` to `.gitignore`.
+- `npx chaffjs rules --json [--genre <genre>]` prints every rule with its levels, the setting in effect (`now`,
+  the genre's preset included) and why a rule is off. Read it instead of guessing rule names or limits.
 - A level is `strict` / `normal` / `relaxed` / `off`; when even `relaxed` is too tight, a positive number is the
   limit itself (`max-sentence-length: 260`).
 - `prefer:` maps spellings to the team's (`e-mail: email`); `preferred-term: normal` turns the rule on.
 - Unknown rule names and unreadable values are reported on stderr — read stderr after editing `chaff.yaml`.
-- `genre:` sets the kind of document (`npx chaffjs genres` lists them); `--genre` overrides it for one run.
+- `genre:` sets the kind of document; `by_path` sets one per folder; `--genre` overrides both for one run.
+  `rules:` wins over the genre's preset.
 
 ## Structured documents
 

package/src/address-chain.ts

@@ -78,7 +78,7 @@ const chainAt = (patterns: Compiled, text: string, start: number): { readonly sp
   const firstEnd = matchEnd(patterns.address, text, start);
   if (firstEnd === undefined) return undefined;
   const { spans, cuts } = readChain(patterns, text, { start, end: firstEnd });
-  const cut = [...cuts].reverse().find((candidate) => endsHere(patterns, text, candidate.end));
+  const cut = cuts.findLast((candidate) => endsHere(patterns, text, candidate.end));
   return cut === undefined ? undefined : { spans: spans.slice(0, cut.addresses), end: cut.end };
 };
 
@@ -102,12 +102,15 @@ export const addressSpans = (text: string, profile: DocumentProfile | undefined)
   return spans;
 };
 
-/** 番地を空白にする。空白が連なりを切るので、番地は数えられず、前後は別の連なりになる。 */
+/**
+ * 番地を同じ長さの空白にする。空白が連なりを切るので、番地は数えられず、前後は別の連なりになる。
+ * 長さを保つので、覆った後の位置は元の文字列の位置のまま。
+ */
 export const maskAddresses = (text: string, profile: DocumentProfile | undefined): string => {
   const spans = addressSpans(text, profile);
   if (spans.length === 0) return text;
   const pieces: string[] = [];
-  spans.forEach((span, index) => pieces.push(text.slice(spans[index - 1]?.end ?? 0, span.start), " "));
+  spans.forEach((span, index) => pieces.push(text.slice(spans[index - 1]?.end ?? 0, span.start), " ".repeat(span.end - span.start)));
   pieces.push(text.slice(spans.at(-1)?.end ?? 0));
   return pieces.join("");
 };

package/src/backends/anthropic.ts

@@ -4,6 +4,7 @@ import { join } from "node:path";
 import Anthropic from "@anthropic-ai/sdk";
 import { toFailure } from "./types.ts";
 import type { Failure, Judge, Prompt } from "./types.ts";
+import type { Texts } from "../ui.ts";
 
 type AnthropicResponse = { readonly content: readonly { readonly type: string; readonly text?: string | undefined }[] };
 
@@ -58,4 +59,7 @@ export const judge =
   };
 
 /** 認証が無いときに人へ見せる案内。 */
-export const SETUP_HINT = "ANTHROPIC_API_KEY を設定するか、ant auth login を実行してください。";
+export const SETUP_HINT: Texts<string> = {
+  ja: "ANTHROPIC_API_KEY を設定するか、ant auth login を実行してください。",
+  en: "Set ANTHROPIC_API_KEY, or run ant auth login.",
+};

package/src/backends/openai.ts

@@ -1,6 +1,7 @@
 import OpenAI from "openai";
 import { toFailure } from "./types.ts";
 import type { Failure, Judge, Prompt } from "./types.ts";
+import type { Texts } from "../ui.ts";
 
 type OpenAIResponse = { readonly choices: readonly { readonly message: { readonly content: string | null } }[] };
 
@@ -43,4 +44,4 @@ export const judge =
     return body;
   };
 
-export const SETUP_HINT = "OPENAI_API_KEY を設定してください。";
+export const SETUP_HINT: Texts<string> = { ja: "OPENAI_API_KEY を設定してください。", en: "Set OPENAI_API_KEY." };

package/src/backends/types.ts

@@ -17,11 +17,12 @@ const BACKENDS: readonly BackendName[] = ["anthropic", "openai"];
 export const isBackend = (value: unknown): value is BackendName => BACKENDS.some((name) => name === value);
 
 /** API が返した失敗。生のスタックトレースを人に見せないための、最小の分類。 */
-export type Failure = { readonly kind: "auth" | "quota" | "api"; readonly status: number | undefined; readonly message: string };
+/** message is the provider's own words, undefined when it gave none: the screen says so in the reader's language. */
+export type Failure = { readonly kind: "auth" | "quota" | "api"; readonly status: number | undefined; readonly message: string | undefined };
 
 const statusOf = (value: unknown): number | undefined => (typeof value === "number" ? value : undefined);
 
-const messageOf = (value: unknown): string => (typeof value === "string" && value.length > 0 ? value : "原因は返ってきませんでした");
+const messageOf = (value: unknown): string | undefined => (typeof value === "string" && value.length > 0 ? value : undefined);
 
 const kindOf = (status: number | undefined): Failure["kind"] => {
   if (status === 401 || status === 403) return "auth";

package/src/baseline.ts

@@ -29,7 +29,7 @@ export const readBaseline = (path: string): Baseline | undefined => {
 };
 
 export const writeBaseline = (path: string, entries: readonly string[]): void => {
-  const sorted = [...entries].sort((left, right) => left.localeCompare(right, "en"));
+  const sorted = entries.toSorted((left, right) => left.localeCompare(right, "en"));
   const body = { version: 1, created: new Date().toISOString().slice(0, 10), entries: sorted };
   writeFileSync(path, `${JSON.stringify(body, null, 2)}\n`, "utf8");
 };

package/src/calendar-number.ts

@@ -0,0 +1,75 @@
+import { digitRunAround } from "./number-name.ts";
+import type { Span, Token } from "./plugin.ts";
+
+/**
+ * 日付・時刻として書かれた数（9月、3時、2026年、10月1日、10時5分）。数を詰めて書くのが決まりで、空け方の好みではない。
+ * 長さ（3ヶ月、3時間、3日間）は別の語で書くので、ここには入らない。
+ *
+ * 単位は語彙表から渡す。chained は日付・時刻の単位を大きい順に（年月日時分秒）。大きい単位の後ろに小さい単位を続けて書けば
+ * 一つの日付・時刻になる。「2008年 2年連続」のように同じ単位や大きい単位が続けば、別のものの始まり。
+ * positional は数の後ろに置くだけで位置を言う単位（月、時）。year は 4 桁の数の後ろで暦の年を言う単位（年、年度）。
+ * 「5日」「5分」「3年」のように、単位だけでは長さと見分けのつかないものは、位置を言う単位と続けて書いたときだけ日付・時刻と読む。
+ */
+export type CalendarUnits = { readonly chained: readonly string[]; readonly positional: ReadonlySet<string>; readonly year: ReadonlySet<string> };
+
+/** 日付・時刻の数の並び。first は日付の頭の数、inner は前の単位に続く数（2026年9月の 9）。 */
+export type CalendarRun = { readonly run: Span; readonly place: "first" | "inner" };
+
+/** 数の並びと、その後ろの単位の終わり（文の中の位置）。rank は chained の中の単位の順（無ければ -1）、anchored は単位だけで日付・時刻と分かるもの。 */
+type Part = { readonly run: Span; readonly unitEnd: number; readonly rank: number; readonly anchored: boolean };
+
+const DIGIT = /\d/u;
+const CALENDAR_YEAR = /^\d{4}$/u;
+
+/** text の中の数の並び（数字・小数点・ハイフン）を左から。 */
+const digitRuns = (text: string): Span[] => {
+  const runs: Span[] = [];
+  let at = 0;
+  while (at < text.length) {
+    const run = DIGIT.test(text[at] ?? "") ? digitRunAround(text, at) : undefined;
+    if (run !== undefined) runs.push(run);
+    at = Math.max(run?.end ?? 0, at + 1);
+  }
+  return runs;
+};
+
+/** 空白 1 つを越えた位置。 */
+const pastSpace = (text: string, at: number): number => (text[at] === " " ? at + 1 : at);
+
+const isUnit = (surface: string, units: CalendarUnits): boolean => units.chained.includes(surface) || units.positional.has(surface) || units.year.has(surface);
+
+const isAnchor = (digits: string, surface: string, units: CalendarUnits): boolean =>
+  units.positional.has(surface) || (units.year.has(surface) && CALENDAR_YEAR.test(digits));
+
+/** 数のすぐ後ろ（空白 1 つまで）の語が日付・時刻の単位なら、その組。語の切れ目が合わなければ組にしない。 */
+const partOf = (text: string, run: Span, tokens: readonly Token[], base: number, units: CalendarUnits): Part | undefined => {
+  const unit = tokens.find((token) => token.span.start === base + pastSpace(text, run.end));
+  if (unit === undefined || !isUnit(unit.surface, units)) return undefined;
+  const rank = units.chained.indexOf(unit.surface);
+  return { run, unitEnd: unit.span.end - base, rank, anchored: isAnchor(text.slice(run.start, run.end), unit.surface, units) };
+};
+
+/** 前の組の単位のすぐ後ろ（空白 1 つまで）から始まり、単位が前より小さい組か。 */
+const continues = (text: string, previous: Part | undefined, part: Part): boolean =>
+  previous !== undefined && previous.rank >= 0 && part.rank > previous.rank && part.run.start === pastSpace(text, previous.unitEnd);
+
+/** 前の組に続く組を、同じ日付・時刻にまとめる。 */
+const chainsOf = (text: string, parts: readonly Part[]): Part[][] =>
+  parts.reduce<Part[][]>((chains, part) => {
+    const chain = chains.at(-1);
+    if (chain !== undefined && continues(text, chain.at(-1), part)) chain.push(part);
+    else chains.push([part]);
+    return chains;
+  }, []);
+
+/**
+ * 文 text の中の、日付・時刻の数の並び。tokens は文書全体の座標で、base は text の先頭の位置。
+ * 品詞が無ければ判断せず、何も返さない。
+ */
+export const calendarRuns = (text: string, tokens: readonly Token[] | undefined, base: number, units: CalendarUnits): CalendarRun[] => {
+  if (tokens === undefined) return [];
+  const parts = digitRuns(text).flatMap((run) => partOf(text, run, tokens, base, units) ?? []);
+  return chainsOf(text, parts)
+    .filter((chain) => chain.some((part) => part.anchored))
+    .flatMap((chain) => chain.map((part, index): CalendarRun => ({ run: part.run, place: index === 0 ? "first" : "inner" })));
+};

package/src/cli-args.ts

@@ -2,8 +2,8 @@
  * 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", "--line"];
+const VALUE_FLAGS: ReadonlySet<string> = new Set(["--sarif", "--genre", "--rule", "--line"]);
 
 /** 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] ?? "")));
+  args.filter((arg, index) => !arg.startsWith("--") && !(index > 0 && VALUE_FLAGS.has(args[index - 1] ?? "")));

package/src/cli-text.ts

@@ -1,6 +1,9 @@
 // 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";
+import { counted, formFor } from "./render/plural.ts";
+import type { GenreSetting } from "./genre-check.ts";
+import type { ProfileSetting } from "./profile/check.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";
@@ -11,11 +14,11 @@ const USAGE_JA = `chaff — 文章の読みにくいところを見つけます
   chaff .                        この場所の Markdown を全部
   chaff test <file|dir>...       意味を読む検査も動かす（API key が要ります）
                                  判定役は chaff.yaml の ai_backend で選びます
-  chaff init                     chaff.yaml を作る
+  chaff init                     chaff.yaml を作る（端末ならジャンルを尋ねる。--genre <ジャンル> でも選べる）
   chaff --version                chaffjs と言語パッケージの版
   chaff eval <dir>               手元の文書で閾値を測り直す
   chaff explain <rule>           そのルールの意図と根拠を読む
-  chaff genres                   ジャンルの一覧
+  chaff genres                   ジャンル（文書の種類）の一覧と、それぞれ何向けか
   chaff tree <file> [--format sexp|json]  文書を番地の付いた木にする（条・項・定義・参照）
   chaff cite <原文> <引用.json>           回答の引用（番地と引用文）が原文にあるかを確かめる
   chaff rules --json             いまの設定を JSON で出す（AI に渡す用）
@@ -45,11 +48,11 @@ const USAGE_EN = `chaff — finds what makes writing hard to read. It never rewr
   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 init                     create chaff.yaml (asks for the genre at a terminal; --genre <genre> chooses it)
   chaff --version                the version of chaffjs and its language packages
   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 genres                   list the genres (kinds of document) and what each is for
   chaff tree <file> [--format sexp|json]  the document as a tree of addresses (sections, clauses, definitions, references)
   chaff cite <source> <quotes.json>       check that quoted passages (address and text) are in the source
   chaff rules --json             the current settings as JSON (to give to an AI)
@@ -78,20 +81,25 @@ export type CliText = {
   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 suggested: (name: string, genre: string) => string;
+  readonly suggestedNote: (name: string, genre: string, used: string) => string;
   readonly noMarkdown: (targets: string) => string;
   readonly noMarkdownHere: string;
   readonly noAdapter: (language: string) => string;
-  readonly unknownGenre: (genre: string) => string;
+  readonly unknownGenre: (genre: string, where: string, known: readonly string[]) => string;
+  readonly genreWhere: (where: GenreSetting, files: readonly string[]) => string;
+  readonly unreadFrontMatterGenre: (path: string, genre: string, known: readonly string[]) => string;
+  readonly unknownProfile: (profile: string, where: string, known: readonly string[]) => string;
+  readonly profileWhere: (where: ProfileSetting, files: readonly 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 findingsUnit: (count: number) => 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;
 };
 
@@ -112,16 +120,29 @@ export const CLI_TEXT: Texts<CliText> = {
       [`${path}   ${genre} · ${language}   ジャンルは${from}から`, shelved > 0 ? `   棚上げ ${shelved} 件` : "", hushed > 0 ? `   stet ${hushed} 件` : ""].join(
         "",
       ),
+    suggested: (name, genre) => `   ${name}のようです。--genre ${genre} を試せます`,
+    suggestedNote: (name, genre, used) =>
+      `  ジャンルを決めていないので、${used} として見ました。${name}なら、--genre ${genre} でその種類の書き方に合わせて見ます（npx chaffjs genres で一覧）。`,
     noMarkdown: (targets) => `Markdown が 1 つも見つかりませんでした: ${targets}`,
     noMarkdownHere: "Markdown が 1 つも見つかりませんでした。",
     noAdapter: (language) => `言語 "${language}" のアダプタがありません。`,
-    unknownGenre: (genre) => `ジャンル "${genre}" はありません。npx chaff genres で一覧が出ます。`,
+    unknownGenre: (genre, where, known) =>
+      `ジャンル "${genre}" はありません（${where}）。使えるのは ${known.join("、")} です。npx chaff genres で一覧が出ます。`,
+    genreWhere: (where, files) => {
+      if (where === "config") return "chaff.yaml の genre";
+      return where === "by_path" ? `chaff.yaml の by_path、files: ${files.join(", ")}` : "--genre";
+    },
+    unreadFrontMatterGenre: (path, genre, known) =>
+      `${path}: front matter の genre "${genre}" はジャンルではないので読みませんでした。使えるのは ${known.join("、")} です。`,
+    unknownProfile: (profile, where, known) =>
+      `文書の種類 "${profile}" はありません（${where}）。使えるのは ${known.join("、")} と、種類を使わない none です。`,
+    profileWhere: (where, files) => (where === "config" ? "chaff.yaml の profile" : `chaff.yaml の by_path、files: ${files.join(", ")}`),
     unknownRule: (id) => `${id} というルールはありません。npx chaff rules --json で一覧が出ます。`,
     unknownRuleWithList: (id, list) => `${id} というルールはありません。\n一覧:\n${list}`,
     unnamed: "(名前なし)",
     sarifWritten: (path, count) => `\n  SARIF を書きました: ${path}（${count} 件）`,
     unchanged: "変わりませんでした",
-    findingsUnit: " 件",
+    findingsUnit: () => " 件",
     watching: (files, findings) => `\n  ${files} ファイルを見ています。いまの指摘は ${findings} 件です。`,
     watchHint: "  保存するたびに、変わったところだけ出します。止めるには Ctrl-C。\n",
     baselineDone: (files, entries, file) => [
@@ -134,8 +155,6 @@ export const CLI_TEXT: Texts<CliText> = {
       `  ${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 "回";
@@ -156,29 +175,40 @@ export const CLI_TEXT: Texts<CliText> = {
     },
     header: (path, genre, language, from, shelved, hushed) =>
       [`${path}   ${genre} · ${language}   genre from ${from}`, shelved > 0 ? `   ${shelved} shelved` : "", hushed > 0 ? `   ${hushed} stet` : ""].join(""),
+    suggested: (name, genre) => `   Looks like: ${name}. Try --genre ${genre}`,
+    suggestedNote: (name, genre, used) =>
+      `  No genre was set, so this was checked as ${used}. If it is ${name}, --genre ${genre} checks it the way that kind is written (npx chaffjs genres lists them).`,
     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.`,
+    unknownGenre: (genre, where, known) => `There is no genre "${genre}" (${where}). The genres are ${known.join(", ")}. npx chaff genres lists them.`,
+    genreWhere: (where, files) => {
+      if (where === "config") return "genre in chaff.yaml";
+      return where === "by_path" ? `by_path in chaff.yaml, files: ${files.join(", ")}` : "--genre";
+    },
+    unreadFrontMatterGenre: (path, genre, known) =>
+      `${path}: the front matter's genre "${genre}" is not a genre, so it was not used. The genres are ${known.join(", ")}.`,
+    unknownProfile: (profile, where, known) =>
+      `There is no document profile "${profile}" (${where}). The profiles are ${known.join(", ")}; none uses no profile.`,
+    profileWhere: (where, files) => (where === "config" ? "profile in chaff.yaml" : `by_path in chaff.yaml, files: ${files.join(", ")}`),
     unknownRule: (id) => `There is no rule named ${id}. npx chaff rules --json lists them.`,
     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"})`,
+    sarifWritten: (path, count) => `\n  Wrote SARIF: ${path} (${counted(count, "finding")})`,
     unchanged: "no change",
-    findingsUnit: " findings",
-    watching: (files, findings) => `\n  Watching ${files} file${files === 1 ? "" : "s"}. ${findings} finding${findings === 1 ? "" : "s"} now.`,
+    findingsUnit: (count) => ` ${formFor(count, "finding", "findings")}`,
+    watching: (files, findings) => `\n  Watching ${counted(files, "file")}. ${counted(findings, "finding")} now.`,
     watchHint: "  Each save prints only what changed. Ctrl-C to stop.\n",
     baselineDone: (files, entries, file) => [
       "",
-      `  Checked ${files} file${files === 1 ? "" : "s"}.`,
+      `  Checked ${counted(files, "file")}.`,
       "",
-      `  Recorded ${entries} finding${entries === 1 ? "" : "s"} in ${file}.`,
+      `  Recorded ${counted(entries, "finding")} 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";

package/src/cli.ts

@@ -7,6 +7,7 @@ import { applyByPath } from "./config/by-path.ts";
 import { applyLevel } from "./config/write.ts";
 import { buildDocument, teamRules } from "./document.ts";
 import { guessLanguage } from "./detect.ts";
+import { plainSource } from "./plain-source.ts";
 import { collectTargets } from "./files.ts";
 import { BASELINE_FILE, fingerprint, readBaseline, splitByBaseline, writeBaseline } from "./baseline.ts";
 import { applySuppressions } from "./stet.ts";
@@ -14,13 +15,18 @@ import { renderSuppressions, type PerFile } from "./render/suppressions.ts";
 import { clock, describeChange, snapshotOf, watchPaths, type Snapshot } from "./watch.ts";
 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 { GENRES } from "./genre.ts";
+import { resolveGenre } from "./resolve-genre.ts";
+import { runInit } from "./init.ts";
+import { initGenre } from "./commands/init-ask.ts";
 import { targetsOf } from "./cli-args.ts";
 import { loadRules } from "./rule-load.ts";
 import { 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";
@@ -30,29 +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 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: "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: "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[]) =>
@@ -90,21 +87,16 @@ 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 = 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, from } = resolveGenre(path, source, config, flag(argv, "--genre"));
+  const { genre, from, unread } = resolveGenre(path, source, config, flag(argv, "--genre"));
+  if (unread !== undefined) console.error(`chaff: ${CLI_TEXT[uiLanguageOf(language)].unreadFrontMatterGenre(path, unread, GENRES)}`);
   const rules = loadRules(language);
   const 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(
@@ -115,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,
@@ -146,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> => {
@@ -215,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)];
@@ -227,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;
 };
 
@@ -265,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;
 };
 
@@ -283,19 +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) => runEval(positional(argv), argv, { config: readConfig(), resolveGenre: genreFrom(argv), flag }),
+  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")),
@@ -332,11 +336,11 @@ export const main = async (argv: readonly string[]): Promise<number> => {
     console.log(VERSION_LINES.join("\n"));
     return 0;
   }
-  const cliGenre = flag(argv, "--genre");
-  if (cliGenre !== undefined && !GENRES.includes(cliGenre)) {
-    console.error(hostText(readConfig()).unknownGenre(cliGenre));
-    return 1;
-  }
+  // 知らないジャンルではどの 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];
   if (handler !== undefined) return handler(argv);
   const targets = targetsOf(first === "lint" ? argv.slice(1) : argv);