chaffjs 0.15.0 → 0.16.0

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,7 +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";
@@ -12,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 に渡す用）
@@ -46,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)
@@ -79,22 +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, 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;
 };
 
@@ -115,6 +120,9 @@ 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}" のアダプタがありません。`,
@@ -126,12 +134,15 @@ export const CLI_TEXT: Texts<CliText> = {
     },
     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) => [
@@ -144,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 "回";
@@ -166,6 +175,9 @@ 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}".`,
@@ -176,25 +188,27 @@ export const CLI_TEXT: Texts<CliText> = {
     },
     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

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

package/src/commands/cite.ts

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

package/src/commands/eval.ts

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

package/src/commands/init-ask.ts

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