chaffjs 0.15.0 → 0.17.0

package/src/document.ts

@@ -8,12 +8,14 @@ import { hasTitle } from "./heading-title.ts";
 import { maskSpans } from "./mask.ts";
 import { spansWithin, unmaskedSoftBreaks } from "./soft-break.ts";
 import { segmentJoined } from "./joined-view.ts";
+import { lineParagraphs } from "./line-paragraphs.ts";
+import { speakerLabels } from "./speaker-labels.ts";
 import { buildTree, type Outline } from "./structure/build.ts";
 import { isMarkdownPath } from "./structure/markdown-path.ts";
 import { pageFurniture, textOutline } from "./page-furniture.ts";
 import { tokenizedLexicons } from "./lexicon-tokens.ts";
 import { inPageAnchors, isInPageNavigation, isNavigationList, type InPageAnchors } from "./in-page-nav.ts";
-import type { BulletList, LanguageAdapter, Paragraph, ProseDocument, Section, Sentence, Span, StructureNode, DocumentProfile } from "./plugin.ts";
+import type { BulletList, LanguageAdapter, Paragraph, ProseDocument, Section, Sentence, Span, StructureNode, DocumentProfile, Token } from "./plugin.ts";
 
 type Place = { readonly offset?: number | undefined };
 type Node = {
@@ -203,7 +205,17 @@ const sentencesOf = (prose: string, paragraphs: readonly Span[], adapter: Langua
       })),
   );
 
-const sectionsOf = (headings: readonly Heading[], sentences: readonly Sentence[], strongs: readonly Span[], length: number): Section[] => {
+/** 見出しの語。品詞を読んでいない文書（文が tokens を持たない）では分けない。 */
+const headingTokensOf = (adapter: LanguageAdapter, tagged: boolean, heading: string): { headingTokens?: readonly Token[] } =>
+  tagged && heading !== "" ? { headingTokens: adapter.segment(heading).sentences.flatMap((sentence) => sentence.tokens ?? []) } : {};
+
+const sectionsOf = (
+  headings: readonly Heading[],
+  sentences: readonly Sentence[],
+  strongs: readonly Span[],
+  length: number,
+  tokensOf: (heading: string) => { headingTokens?: readonly Token[] },
+): Section[] => {
   const bounds = headings.map((heading, index) => ({ heading, from: heading.end, to: headings[index + 1]?.start ?? length }));
   const lead = { heading: { depth: 0, text: "", start: 0, end: 0 }, from: 0, to: headings[0]?.start ?? length };
   return [lead, ...bounds]
@@ -213,6 +225,7 @@ const sectionsOf = (headings: readonly Heading[], sentences: readonly Sentence[]
       return {
         depth: heading.depth,
         heading: heading.text,
+        ...tokensOf(heading.text),
         span: { start: from, end: to },
         sentences: inside,
         strongCount: strongs.filter((span) => within(span, from, to)).length,
@@ -221,12 +234,32 @@ const sectionsOf = (headings: readonly Heading[], sentences: readonly Sentence[]
     });
 };
 
-const paragraphsOf = (spans: readonly Span[], sentences: readonly Sentence[], listSpans: readonly Span[]): Paragraph[] =>
+/** sentences（並び順）の中で、start が offset 以上の最初の添字。1 行 1 段落の何万行でも、段落ごとに全部をなめない。 */
+const firstStartingAt = (sentences: readonly Sentence[], offset: number): number => {
+  const search = (low: number, high: number): number => {
+    if (low >= high) return low;
+    const middle = (low + high) >> 1;
+    return (sentences[middle]?.span.start ?? Number.POSITIVE_INFINITY) >= offset ? search(low, middle) : search(middle + 1, high);
+  };
+  return search(0, sentences.length);
+};
+
+const sentencesWithin = (sentences: readonly Sentence[], span: Span): Sentence[] =>
+  sentences.slice(firstStartingAt(sentences, span.start), firstStartingAt(sentences, span.end));
+
+const paragraphsOf = (prose: string, spans: readonly Span[], sentences: readonly Sentence[], listSpans: readonly Span[]): Paragraph[] =>
   spans
     // 箇条書きの中の段落は「段落」として数えない。項目 1 つを 1 段落と読むと、
     // 段落あたりの文数も長さのばらつきも、箇条書きの多い文書で壊れる。
     .filter((span) => !listSpans.some((list) => span.start >= list.start && span.start < list.end))
-    .map((span) => ({ span, sentences: sentences.filter((sentence) => within(sentence.span, span.start, span.end)) }));
+    .flatMap((span) =>
+      lineParagraphs(
+        prose,
+        span,
+        sentencesWithin(sentences, span).map((sentence) => sentence.span),
+      ),
+    )
+    .map((span) => ({ span, sentences: sentencesWithin(sentences, span) }));
 
 /** 箇条書きは list ノードの直下の項目を数える。入れ子の項目は内側の list のものとして数える。目次のような案内だけの箇条書きは数えない。 */
 const listsOf = (root: Node, source: string, anchors: InPageAnchors): BulletList[] => {
@@ -250,6 +283,8 @@ export type TeamRules = {
   readonly requiredSections: readonly string[];
   /** { 使わない書き方: 使う書き方 }。preferred-term が語彙表として読む。 */
   readonly prefer?: Readonly<Record<string, string>>;
+  /** チームの固有名詞。1 つの名前として読む rule が見る。 */
+  readonly names?: readonly string[];
 };
 
 const EMPTY_TEAM: TeamRules = { jargon: [], requiredSections: [] };
@@ -259,12 +294,23 @@ export const teamRules = (config: {
   readonly jargon: readonly string[];
   readonly requiredSections: readonly string[];
   readonly prefer?: Readonly<Record<string, string>>;
+  readonly names?: readonly string[];
 }): TeamRules => ({
   jargon: config.jargon,
   prefer: config.prefer ?? {},
   requiredSections: config.requiredSections,
+  names: config.names ?? [],
 });
 
+/**
+ * masked を覆った本文から、話し手の名前（戯曲・議事録）も覆う。名前は誰が話すかの印で、文でも本文でもない。
+ * 名前は覆った後の本文で探す。コードや表の中の行頭を話し手と数えない。
+ */
+const proseOf = (source: string, masked: readonly Span[]): string => {
+  const unlabelled = maskSpans(source, masked);
+  return maskSpans(unlabelled, speakerLabels(unlabelled));
+};
+
 export const buildDocument = (
   path: string,
   source: string,
@@ -279,7 +325,7 @@ export const buildDocument = (
   // テキストの文書は、ページのヘッダーとフッターも本文ではない（Markdown には改ページが無い）。
   const blocks = [...collectMasks(root, source, anchors), ...(isMarkdownPath(path) ? [] : pageFurniture(source))];
   const masked = [...blocks, ...emphasisSpans(root, source)];
-  const prose = maskSpans(source, masked);
+  const prose = proseOf(source, masked);
   // ページの案内は段落としても数えない。数えると、目次の行が「本題までの段落」に入る。
   const paragraphSpans = spansOfType(root, "paragraph", (node) => !isInPageNavigation(node, anchors));
   const listItems = spansOfType(root, "listItem");
@@ -302,14 +348,15 @@ export const buildDocument = (
     language: adapter.id,
     lengthUnit: adapter.capabilities.lengthUnit,
     capabilities: adapter.capabilities,
-    sections: sectionsOf(headingsOf(root, source), sentences, strongSpans(root, blocks), source.length),
+    sections: sectionsOf(headingsOf(root, source), sentences, strongSpans(root, blocks), source.length, (heading) => headingTokensOf(adapter, tagged, heading)),
     sentences,
     listSpans: listItems,
-    paragraphs: paragraphsOf(paragraphSpans, sentences, listItems),
+    paragraphs: paragraphsOf(prose, paragraphSpans, sentences, listItems),
     lists: listsOf(root, source, anchors),
     links: [...spansOfType(root, "link"), ...spansOfType(root, "linkReference")],
     lexicons: tagged ? tokenizedLexicons(lexicons, adapter) : lexicons,
     requiredSections: team.requiredSections,
+    names: team.names ?? [],
     // 構造の rule（参照先が無い・番号の抜け）が読む木。どの rule も読まなければ作らない。何万行の契約書で、他の rule の lint に代金を払わせない。
     get structure(): StructureNode | undefined {
       tree.value ??=

package/src/eval.ts

@@ -41,7 +41,7 @@ const candidates = (rule: RuleDefinition, current: number): number[] => {
   const fromLevels = [rule.levels.strict, rule.levels.normal, rule.levels.relaxed].filter((value) => value !== undefined);
   const scaled = MULTIPLIERS.map((factor) => Math.max(1, Math.round(base * factor)));
   // 数値で決めた上限は、段の表に無くても掃引に入れる。入れないと「現在」の行が出ない。
-  return [...new Set([...fromLevels, ...scaled, current])].sort((left, right) => left - right);
+  return [...new Set([...fromLevels, ...scaled, current])].toSorted((left, right) => left - right);
 };
 
 const countAt = (docs: readonly ProseDocument[], rule: RuleDefinition, limit: number): Point => {

package/src/feedback/draft.ts

@@ -61,7 +61,7 @@ const TEXT: Texts<{
       "false-positive": "<!-- Why it is wrong, and how the text should be read -->",
       missed: "<!-- What is wrong in the text, and which rule should have said so -->",
     },
-    lines: (from, to) => `lines ${String(from)}-${String(to)}`,
+    lines: (from, to) => (from === to ? `line ${String(from)}` : `lines ${String(from)}-${String(to)}`),
   },
 };
 

package/src/feedback/excerpt.ts

@@ -1,14 +1,14 @@
 /** Lines around a line of a document, 1-based and inclusive. Only these lines go into a report. */
 export type Excerpt = { readonly from: number; readonly to: number; readonly lines: readonly string[] };
 
-export const EXCERPT_RADIUS = 2;
+const EXCERPT_RADIUS = 2;
 
 /** Pure: the excerpts around each line, overlapping ones merged, in document order. Lines outside the document are dropped. */
 export const excerptsAround = (source: string, lines: readonly number[], radius: number = EXCERPT_RADIUS): Excerpt[] => {
   const all = source.split("\n");
   const ranges = [...new Set(lines)]
     .filter((line) => line >= 1 && line <= all.length)
-    .sort((left, right) => left - right)
+    .toSorted((left, right) => left - right)
     .map((line) => ({ from: Math.max(1, line - radius), to: Math.min(all.length, line + radius) }));
   const merged = ranges.reduce<{ from: number; to: number }[]>((acc, range) => {
     const last = acc.at(-1);

package/src/file-header.ts

@@ -0,0 +1,31 @@
+import { CLI_TEXT, type GenreSource } from "./cli-text.ts";
+import { loadGenres } from "./genre-load.ts";
+import type { GenreDefinition } from "./genre-parse.ts";
+import { suggestGenre } from "./genre-suggest.ts";
+import { loadProfiles } from "./profile/load.ts";
+import { uiLanguageOf } from "./ui.ts";
+
+/** The file's first lines, and the notes after its not-run list: the genre it looks like, when none was set. */
+type FileHeader = { readonly header: string; readonly notes: readonly string[] };
+
+/** unread: a genre the front matter wrote that chaff does not know (already reported on stderr). */
+type Placed = { readonly genre: string; readonly from: GenreSource; readonly unread?: string | undefined };
+
+type Counts = { readonly shelved: number; readonly hushed: number };
+
+/**
+ * The genre the file looks like, only when nothing set or guessed one: suggested on screen, never used for the run.
+ * A front matter genre chaff could not read is a genre the writer did set, so the note's "no genre was set" would be untrue.
+ */
+const suggestionFor = (path: string, source: string, language: string, placed: Placed): GenreDefinition | undefined =>
+  placed.from === "default" && placed.unread === undefined ? suggestGenre({ path, source, language }, loadGenres(), loadProfiles()) : undefined;
+
+/** In the file's language. The note names the genre the file was checked as. */
+export const fileHeader = (path: string, source: string, language: string, placed: Placed, counts: Counts): FileHeader => {
+  const text = CLI_TEXT[uiLanguageOf(language)];
+  const first = text.header(path, placed.genre, text.languageName(language), text.genreSource[placed.from], counts.shelved, counts.hushed);
+  const suggestion = suggestionFor(path, source, language, placed);
+  if (suggestion === undefined) return { header: first, notes: [] };
+  const name = suggestion.name[uiLanguageOf(language)] ?? suggestion.id;
+  return { header: [first, text.suggested(name, suggestion.id)].join("\n"), notes: [text.suggestedNote(name, suggestion.id, placed.genre)] };
+};

package/src/files.ts

@@ -4,11 +4,11 @@ import { join, relative, sep } from "node:path";
 const MARKDOWN = [".md", ".markdown", ".mdx"];
 
 /** 走査から外す。ここを通すと node_modules の README を延々と検査することになる。 */
-const SKIP = ["node_modules", "dist", "build", "coverage", ".git", ".chaff-cache"];
+const SKIP: ReadonlySet<string> = new Set(["node_modules", "dist", "build", "coverage", ".git", ".chaff-cache"]);
 
 const isMarkdown = (path: string): boolean => MARKDOWN.some((ext) => path.toLowerCase().endsWith(ext));
 
-const isSkipped = (path: string): boolean => path.split(sep).some((part) => SKIP.includes(part));
+const isSkipped = (path: string): boolean => path.split(sep).some((part) => SKIP.has(part));
 
 const expand = (target: string): string[] => {
   const stat = statSync(target, { throwIfNoEntry: false });
@@ -30,5 +30,5 @@ const byPath = (left: string, right: string): number => left.localeCompare(right
 
 export const collectTargets = (targets: readonly string[]): string[] => {
   const found = targets.flatMap(expand).filter((path) => !isSkipped(path));
-  return [...new Set(found)].sort((left, right) => byPath(relative(".", left), relative(".", right)));
+  return [...new Set(found)].toSorted((left, right) => byPath(relative(".", left), relative(".", right)));
 };

package/src/genre-check.ts

@@ -15,7 +15,7 @@ type PathGenre = { readonly files: readonly string[]; readonly genre: string | u
 type WrittenGenres = { readonly flag: string | undefined; readonly config: string | undefined; readonly byPath: readonly PathGenre[] };
 
 /** Commands that never read a genre from chaff.yaml. A wrong one there must not stop them: genres is how to find the right name. */
-const GENRE_FREE: ReadonlySet<string> = new Set(["init", "genres", "skill", "relax", "strict", "off", "tree", "cite"]);
+const GENRE_FREE: ReadonlySet<string> = new Set(["init", "genres", "skill", "relax", "strict", "off"]);
 
 /** The genres a command would read: --genre always (every command refuses a wrong one), chaff.yaml's only where the command reads a genre. */
 export const writtenGenres = (

package/src/genre-load.ts

@@ -0,0 +1,24 @@
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { parse } from "yaml";
+import { parseGenres, presetLevelsOf, presetProfileOf, type GenreData, type PresetLevels } from "./genre-parse.ts";
+
+const GENRES_FILE = join(dirname(fileURLToPath(import.meta.url)), "..", "genres.yaml");
+
+const loaded: { value: GenreData | undefined } = { value: undefined };
+
+/** The bundled genres.yaml. Read once. */
+export const loadGenres = (): GenreData => {
+  if (loaded.value !== undefined) return loaded.value;
+  try {
+    loaded.value = parseGenres(parse(readFileSync(GENRES_FILE, "utf8")));
+  } catch (error) {
+    throw new Error(`cannot read ${GENRES_FILE}: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
+  }
+  return loaded.value;
+};
+
+export const presetLevels = (genre: string): PresetLevels => presetLevelsOf(loadGenres(), genre);
+
+export const presetProfile = (genre: string): string | undefined => presetProfileOf(loadGenres(), genre);

package/src/genre-parse.ts

@@ -0,0 +1,151 @@
+import { isLevel } from "./levels.ts";
+import type { Level, Localized } from "./plugin.ts";
+
+/** A preset's rules: the level each named rule runs at, under whatever chaff.yaml's rules say. */
+export type PresetLevels = Readonly<Record<string, Level>>;
+
+/** A group of genres (legal, literature): its name, and the levels every genre in it shares. */
+export type GenreGroup = { readonly id: string; readonly name: Localized; readonly rules: PresetLevels };
+
+/** One genre of genres.yaml: what it is for, the levels it sets on top of its group's, and the profile it reads with. */
+export type GenreDefinition = {
+  readonly id: string;
+  readonly name: Localized;
+  readonly summary: Localized;
+  readonly rules: PresetLevels;
+  readonly profile: string | undefined;
+  readonly suggest: GenreSuggest;
+};
+
+/** A line shape that marks the genre, and how many lines must have it. */
+type LineCue = { readonly line: RegExp; readonly minLines: number };
+
+/**
+ * What makes a document look like this genre when no genre is set: its path, or per language, the shape of the body's first
+ * line (a letter's salutation) or enough lines of the genre's own shape.
+ */
+export type GenreSuggest = {
+  readonly paths: readonly RegExp[];
+  readonly lines: Readonly<Record<string, LineCue>>;
+  readonly openings: Readonly<Record<string, RegExp>>;
+};
+
+type LanguageCue = { readonly line: LineCue | undefined; readonly opening: RegExp | undefined };
+
+export type GenreData = { readonly groups: readonly GenreGroup[]; readonly genres: readonly GenreDefinition[] };
+
+const isRecord = (value: unknown): value is Record<string, unknown> => typeof value === "object" && value !== null && !Array.isArray(value);
+
+const isLocalized = (value: unknown): value is Localized =>
+  isRecord(value) && typeof value["ja"] === "string" && typeof value["en"] === "string" && value["ja"] !== "" && value["en"] !== "";
+
+const levelsOf = (value: unknown, where: string): PresetLevels => {
+  if (value === undefined) return {};
+  if (!isRecord(value)) throw new Error(`${where}: rules must be a map of rule ids to levels`);
+  const wrong = Object.entries(value).find(([, level]) => !isLevel(level));
+  if (wrong !== undefined) throw new Error(`${where}: ${wrong[0]} has the level ${String(wrong[1])}; use strict, normal, relaxed or off`);
+  return Object.fromEntries(Object.entries(value).filter((entry): entry is [string, Level] => isLevel(entry[1])));
+};
+
+const localizedOf = (value: unknown, field: string, where: string): Localized => {
+  if (!isLocalized(value)) throw new Error(`${where}: ${field} needs a ja and an en text`);
+  return value;
+};
+
+const idOf = (value: unknown, index: number): string => {
+  const id = isRecord(value) ? value["id"] : undefined;
+  if (typeof id !== "string" || id === "") throw new Error(`entry ${String(index + 1)} has no id`);
+  return id;
+};
+
+const groupOf = (value: unknown, index: number): GenreGroup => {
+  const id = idOf(value, index);
+  const raw = isRecord(value) ? value : {};
+  return { id, name: localizedOf(raw["name"], "name", id), rules: levelsOf(raw["rules"], id) };
+};
+
+const patternOf = (value: unknown, flags: string, where: string): RegExp => {
+  if (typeof value !== "string" || value === "") throw new Error(`${where}: a pattern must be a non-empty string`);
+  try {
+    return new RegExp(value, flags);
+  } catch (error) {
+    throw new Error(`${where}: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
+  }
+};
+
+const lineCueOf = (value: unknown, where: string): LineCue => {
+  if (!isRecord(value)) throw new Error(`${where}: needs line and min_lines`);
+  const minLines = value["min_lines"];
+  if (typeof minLines !== "number" || !Number.isInteger(minLines) || minLines < 1) throw new Error(`${where}: min_lines must be a whole number of 1 or more`);
+  return { line: patternOf(value["line"], "u", where), minLines };
+};
+
+const hasLineCue = (value: Readonly<Record<string, unknown>>): boolean => value["line"] !== undefined || value["min_lines"] !== undefined;
+
+const languageCueOf = (value: unknown, where: string): LanguageCue => {
+  if (!isRecord(value) || (!hasLineCue(value) && value["opening"] === undefined)) throw new Error(`${where}: needs line and min_lines, or opening`);
+  return {
+    line: hasLineCue(value) ? lineCueOf(value, where) : undefined,
+    opening: value["opening"] === undefined ? undefined : patternOf(value["opening"], "u", where),
+  };
+};
+
+const presentOf = <T>(cues: readonly (readonly [string, T | undefined])[]): Record<string, T> =>
+  Object.fromEntries(cues.filter((entry): entry is readonly [string, T] => entry[1] !== undefined));
+
+const suggestOf = (value: unknown, where: string): GenreSuggest => {
+  if (value === undefined) return { paths: [], lines: {}, openings: {} };
+  if (!isRecord(value)) throw new Error(`${where}: suggest must be a map`);
+  const paths = value["paths"] ?? [];
+  if (!Array.isArray(paths)) throw new Error(`${where}: suggest.paths must be a list`);
+  const cues = Object.entries(value)
+    .filter(([key]) => key !== "paths")
+    .map(([language, cue]) => [language, languageCueOf(cue, `${where} suggest.${language}`)] as const);
+  return {
+    paths: paths.map((path) => patternOf(path, "iu", `${where} suggest.paths`)),
+    lines: presentOf(cues.map(([language, cue]) => [language, cue.line] as const)),
+    openings: presentOf(cues.map(([language, cue]) => [language, cue.opening] as const)),
+  };
+};
+
+const genreOf = (value: unknown, index: number): GenreDefinition => {
+  const id = idOf(value, index);
+  const raw = isRecord(value) ? value : {};
+  const profile = raw["profile"];
+  if (profile !== undefined && (typeof profile !== "string" || profile === "")) throw new Error(`${id}: profile must be a profile's id`);
+  return {
+    id,
+    name: localizedOf(raw["name"], "name", id),
+    summary: localizedOf(raw["summary"], "summary", id),
+    rules: levelsOf(raw["rules"], id),
+    profile,
+    suggest: suggestOf(raw["suggest"], id),
+  };
+};
+
+const listOf = (raw: Record<string, unknown>, key: string): unknown[] => {
+  const value = raw[key];
+  if (!Array.isArray(value)) throw new Error(`genres.yaml needs a list under ${key}`);
+  return value;
+};
+
+/** genres.yaml as read by the yaml package. Throws on anything it cannot read: the file ships with chaff, so a wrong entry is chaff's bug. */
+export const parseGenres = (raw: unknown): GenreData => {
+  if (!isRecord(raw)) throw new Error("genres.yaml must be a map with groups and genres");
+  const groups = listOf(raw, "groups").map(groupOf);
+  const genres = listOf(raw, "genres").map(genreOf);
+  const orphan = genres.find((genre) => !groups.some((group) => genre.id.startsWith(`${group.id}/`)));
+  if (orphan !== undefined) throw new Error(`${orphan.id}: no group matches the part before its /`);
+  return { groups, genres };
+};
+
+/** The levels a genre's preset sets: its group's, then its own on top. Empty for a genre chaff does not know. */
+export const presetLevelsOf = (data: GenreData, genre: string): PresetLevels => {
+  const own = data.genres.find((entry) => entry.id === genre);
+  if (own === undefined) return {};
+  const group = data.groups.find((entry) => genre.startsWith(`${entry.id}/`));
+  return { ...group?.rules, ...own.rules };
+};
+
+/** The profile a genre reads its documents with, when it names one. */
+export const presetProfileOf = (data: GenreData, genre: string): string | undefined => data.genres.find((entry) => entry.id === genre)?.profile;

package/src/genre-suggest.ts

@@ -0,0 +1,50 @@
+import type { GenreData, GenreDefinition } from "./genre-parse.ts";
+import { openingLine } from "./opening-line.ts";
+import { detected, type ProfileDefinition } from "./profile/parse.ts";
+
+/** The file a genre is suggested for: where it is, what it says, and its language. */
+export type SuggestInput = { readonly path: string; readonly source: string; readonly language: string };
+
+/** A path cue names the kind outright, so it outweighs any count of lines. */
+const BY_PATH = Number.POSITIVE_INFINITY;
+
+/** How the body opens (Dear ..., 拝啓) says what the document is even when it encloses another kind; a path still says more. */
+const BY_OPENING = Number.MAX_VALUE;
+
+const opensAs = (genre: GenreDefinition, input: SuggestInput): boolean => {
+  const opening = genre.suggest.openings[input.language];
+  const first = openingLine(input.source);
+  return opening !== undefined && first !== undefined && opening.test(first);
+};
+
+/** How many times over the genre's lines reach their minimum: 1 is just enough, 0 is none of that shape. */
+const linesScore = (genre: GenreDefinition, input: SuggestInput): number => {
+  const cue = genre.suggest.lines[input.language];
+  if (cue === undefined) return 0;
+  return input.source.split("\n").filter((line) => cue.line.test(line)).length / cue.minLines;
+};
+
+/** A genre that reads with a profile has the profile's shape (a statute's article lines) as just-enough evidence. */
+const profileScore = (genre: GenreDefinition, input: SuggestInput, profiles: readonly ProfileDefinition[]): number => {
+  const profile = profiles.find((definition) => definition.id === genre.profile);
+  return profile !== undefined && detected(profile, input.source, input.language) ? 1 : 0;
+};
+
+const scoreOf = (genre: GenreDefinition, input: SuggestInput, profiles: readonly ProfileDefinition[]): number => {
+  if (genre.suggest.paths.some((pattern) => pattern.test(input.path))) return BY_PATH;
+  if (opensAs(genre, input)) return BY_OPENING;
+  return Math.max(linesScore(genre, input), profileScore(genre, input, profiles));
+};
+
+type Scored = { readonly genre: GenreDefinition; readonly score: number };
+
+/**
+ * The genre a file with no genre set looks like, for the screen to suggest. Never used to check the file: switching silently
+ * would change what an existing run reports. The genre whose cues the file meets most strongly wins (a transcript that
+ * discusses a bill has more speaker lines than lines about "this Act"); a tie goes to the genre listed first in genres.yaml.
+ */
+export const suggestGenre = (input: SuggestInput, data: GenreData, profiles: readonly ProfileDefinition[]): GenreDefinition | undefined =>
+  data.genres
+    .map((genre): Scored => ({ genre, score: scoreOf(genre, input, profiles) }))
+    .filter((entry) => entry.score >= 1)
+    .reduce<Scored | undefined>((best, entry) => (best === undefined || entry.score > best.score ? entry : best), undefined)?.genre;

package/src/genre.ts

@@ -1,16 +1,7 @@
-/** chaff が知っているジャンル。rule の use_for はこの頭の部分で当てる。 */
-export const GENRES: readonly string[] = [
-  "technical/spec",
-  "technical/readme",
-  "blog/tech",
-  "blog/essay",
-  "blog/owned-media",
-  "business/proposal",
-  "business/report",
-  "business/email",
-  "business/press-release",
-  "business/meeting-notes",
-];
+import { loadGenres } from "./genre-load.ts";
+
+/** chaff が知っているジャンル。genres.yaml の並び。rule の use_for はこの頭の部分で当てる。 */
+export const GENRES: readonly string[] = loadGenres().genres.map((genre) => genre.id);
 
 export type GenreGuess = { readonly genre: string; readonly from: "front-matter" | "path" | "content" };
 

package/src/init-choice.ts

@@ -0,0 +1,47 @@
+import type { GenreData } from "./genre-parse.ts";
+import type { Texts, UiLanguage } from "./ui.ts";
+
+/** The genre init writes when nothing is chosen: the one a check uses when none is set. */
+export const DEFAULT_GENRE = "blog/tech";
+
+const TEXT: Texts<{ readonly heading: string; readonly prompt: string; readonly notAGenre: (answer: string) => string; readonly noAnswer: string }> = {
+  ja: {
+    heading: "どの種類の文書をここに置きますか？ 選んだ種類の書き方に合わせて見ます。",
+    prompt: `番号か名前を入れてください（Enter で ${DEFAULT_GENRE}）: `,
+    notAGenre: (answer) => `「${answer}」は一覧にありません。何も作っていません。npx chaffjs init --genre <ジャンル> でも選べます。`,
+    noAnswer: "答えが無いまま入力が終わったので、何も作っていません。",
+  },
+  en: {
+    heading: "What kind of document goes here? chaff checks it the way that kind is written.",
+    prompt: `Type a number or a name (Enter for ${DEFAULT_GENRE}): `,
+    notAGenre: (answer) => `"${answer}" is not in the list. Nothing was created. npx chaffjs init --genre <genre> chooses one too.`,
+    noAnswer: "The input ended without an answer, so nothing was created.",
+  },
+};
+
+/** The numbered list init shows before it asks: every genre with what it is for, in genres.yaml's order. */
+export const genreChoices = (data: GenreData, ui: UiLanguage): string[] => {
+  const width = Math.max(...data.genres.map((genre) => genre.id.length)) + 2;
+  const numberWidth = String(data.genres.length).length;
+  return [
+    "",
+    TEXT[ui].heading,
+    "",
+    ...data.genres.map((genre, index) => `  ${String(index + 1).padStart(numberWidth)}  ${genre.id.padEnd(width)}${genre.summary[ui] ?? ""}`),
+    "",
+  ];
+};
+
+export const choicePrompt = (ui: UiLanguage): string => TEXT[ui].prompt;
+
+export const notAGenre = (answer: string, ui: UiLanguage): string => TEXT[ui].notAGenre(answer);
+
+export const noAnswer = (ui: UiLanguage): string => TEXT[ui].noAnswer;
+
+/** A number from the list, a genre's name, or nothing (the default). undefined for anything else: init then writes nothing. */
+export const genreFromAnswer = (answer: string, ids: readonly string[]): string | undefined => {
+  const typed = answer.trim();
+  if (typed === "") return DEFAULT_GENRE;
+  if (ids.includes(typed)) return typed;
+  return /^\d+$/u.test(typed) ? ids[Number(typed) - 1] : undefined;
+};

package/src/init.ts

@@ -1,9 +1,10 @@
 import { appendFileSync, existsSync, readFileSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import type { Texts, UiLanguage } from "./ui.ts";
+import { loadGenres } from "./genre-load.ts";
 
 const TEXT: Texts<{
-  readonly config: (genre: string) => string;
+  readonly config: (genre: string, summary: string) => string;
   readonly created: string;
   readonly appended: (lines: readonly string[]) => string;
   readonly configNote: string;
@@ -15,7 +16,7 @@ const TEXT: Texts<{
   readonly nextCheck: string;
 }> = {
   ja: {
-    config: (genre) => `# chaff.yaml — このチームの文章規範
+    config: (genre, summary) => `# chaff.yaml — このチームの文章規範
 #
 # ここに書くのは「既定から変えたもの」だけです。書かなければ既定で動きます。
 # このファイルを消しても chaff は動きます。
@@ -33,9 +34,13 @@ const TEXT: Texts<{
 #   npx chaff explain bold-density        そのルールの意図を読む
 #   npx chaff rules --json                AI に設定を書かせるときに渡す
 
-# この場所に置く文書の種類。
+# この場所に置く文書の種類（${summary}）。ほかの種類: npx chaffjs genres
 genre: ${genre}
 
+# チームが書く固有名詞（組織名・製品名）。1 つの名前として読み、漢字の連なりに数えない。
+# names:
+#   - 個人情報保護委員会
+
 # 既定から変えたものだけを書く。
 rules:
 `,
@@ -50,7 +55,7 @@ rules:
     nextCheck: "  npx chaff .            この場所の Markdown を全部見る",
   },
   en: {
-    config: (genre) => `# chaff.yaml — this team's writing rules
+    config: (genre, summary) => `# chaff.yaml — this team's writing rules
 #
 # Write only what differs from the defaults; anything left out uses the default.
 # chaff still runs if this file is deleted.
@@ -68,9 +73,13 @@ rules:
 #   npx chaff explain bold-density        read what the rule is for
 #   npx chaff rules --json                give this to an AI that writes the settings
 
-# The kind of document kept here.
+# The kind of document kept here (${summary}). The others: npx chaffjs genres
 genre: ${genre}
 
+# The names your team writes (organisations, products). Each is read as one name, not as words to count.
+# names:
+#   - Bank of England
+
 # Only what differs from the defaults.
 rules:
 `,
@@ -108,9 +117,14 @@ const ensureGitignore = (dir: string, text: (typeof TEXT)["ja"]): Written | unde
   return { path, note: text.appended(missing) };
 };
 
+/** What the genre is for, as chaff genres says it; the genre itself when chaff does not know it. */
+const summaryOf = (genre: string, ui: UiLanguage): string => loadGenres().genres.find((entry) => entry.id === genre)?.summary[ui] ?? genre;
+
 export const runInit = (dir: string, genre: string, ui: UiLanguage = "ja"): string[] => {
   const text = TEXT[ui];
-  const made = [writeIfAbsent(join(dir, "chaff.yaml"), text.config(genre), text.configNote), ensureGitignore(dir, text)].filter((entry) => entry !== undefined);
+  const made = [writeIfAbsent(join(dir, "chaff.yaml"), text.config(genre, summaryOf(genre, ui)), text.configNote), ensureGitignore(dir, text)].filter(
+    (entry) => entry !== undefined,
+  );
   if (made.length === 0) return [text.exists];
   return [
     "",

package/src/judge.ts

@@ -6,6 +6,7 @@ import * as openai from "./backends/openai.ts";
 import type { AnthropicClient } from "./backends/anthropic.ts";
 import type { OpenAIClient } from "./backends/openai.ts";
 import type { BackendName, Failure, Judge, JsonSchema } from "./backends/types.ts";
+import type { UiLanguage } from "./ui.ts";
 
 export const CACHE_DIR = ".chaff-cache";
 
@@ -87,7 +88,8 @@ export const isAuthFailure = (backend: BackendName, error: unknown): boolean =>
 export const describeFailure = (backend: BackendName, error: unknown): Failure | undefined =>
   backend === "openai" ? openai.describeFailure(error) : anthropic.describeFailure(error);
 
-export const credentialHint = (backend: BackendName): string => (backend === "openai" ? openai.SETUP_HINT : anthropic.SETUP_HINT);
+export const credentialHint = (backend: BackendName, language: UiLanguage): string =>
+  (backend === "openai" ? openai.SETUP_HINT : anthropic.SETUP_HINT)[language];
 
 /**
  * 同じ (model, rule, rubric, candidate) なら 2 度目は問い合わせない。