chaffjs 0.15.0 → 0.16.0

package/src/detectors/superlative-clause.ts

@@ -0,0 +1,82 @@
+import type { Lexicon, Token } from "../plugin.ts";
+import type { TokenRange } from "./lexicon-match.ts";
+import { PHRASE_END, PHRASE_START, phraseEnd } from "./superlative-scope.ts";
+
+/** 最上級の名詞句を後ろから限る語。どちらも言語パッケージの語彙表が持つ。 */
+export type Restrictors = {
+  /** 名詞の後ろで関係節を始める語（that・which）。空の言語は、名詞の後ろに節を置かない。 */
+  readonly relatives: Lexicon;
+  /** 最上級を手に入る範囲に限る形容詞（possible・available）。 */
+  readonly bounds: Lexicon;
+  /** 節の主語になる代名詞（we・they）。themselves のような再帰の代名詞は主語にならない。 */
+  readonly subjects: Lexicon;
+};
+
+const VERBAL = new Set(["VERB", "AUX"]);
+
+const isWord = (token: Token | undefined, words: Lexicon): boolean =>
+  token !== undefined && words.some((entry) => entry.pattern.toLowerCase() === token.surface.toLowerCase());
+
+const isVerbal = (token: Token | undefined): boolean => token !== undefined && VERBAL.has(token.pos);
+
+/** 節の主語（we・managers・the team・this）を読み飛ばした先に動詞があるか。主語の無い節（that has defined）は動詞で始まる。 */
+const verbAfterSubject = (tokens: readonly Token[], at: number, subjects: Lexicon): boolean => {
+  if (isVerbal(tokens[at])) return true;
+  if (isWord(tokens[at], subjects)) return isVerbal(tokens[at + 1]);
+  if (tokens[at]?.pos === "DET") return isVerbal(tokens[at + 1]) || isVerbal(tokens[phraseEnd(tokens, at + 1)]);
+  return isVerbal(tokens[phraseEnd(tokens, at)]);
+};
+
+const isArticle = (token: Token | undefined): boolean => token?.features?.["PronType"] === "Art";
+
+/**
+ * 関係詞を省いた節の主語は、代名詞（the best we have measured）か冠詞で始まる名詞句（the best option the team selected）。
+ * each・all のような限定詞（The best teams all adapt）や、冠詞の無い名詞（The best teams adapt）は節の始まりと読まない。
+ */
+const contactClause = (tokens: readonly Token[], at: number, subjects: Lexicon): boolean => {
+  if (isWord(tokens[at], subjects)) return isVerbal(tokens[at + 1]);
+  return isArticle(tokens[at]) && isVerbal(tokens[phraseEnd(tokens, at + 1)]);
+};
+
+/** 関係節（the threats that we have seen・the option which we chose）と、関係詞を省いた節。 */
+const clause = (tokens: readonly Token[], at: number, restrictors: Restrictors): boolean =>
+  isWord(tokens[at], restrictors.relatives) ? verbAfterSubject(tokens, at + 1, restrictors.subjects) : contactClause(tokens, at, restrictors.subjects);
+
+/** 分詞の後ろに文の動詞があるか。and を挟んだ動詞（The best option changed quickly and won）は分詞と並ぶ述語。 */
+const mainVerbFollows = (tokens: readonly Token[], at: number): boolean => {
+  const rest = tokens.slice(at + 1);
+  const verb = rest.findIndex(isVerbal);
+  return verb !== -1 && !rest.slice(0, verb).some((token) => token.pos === "CCONJ");
+};
+
+/**
+ * 名詞の後ろの過去分詞（the most scalable option discussed）。名詞句が動詞の目的語か補語で（We chose the best option discussed）、
+ * または分詞の後ろに文の動詞がある（The best results obtained were poor）ときだけ。目的語を取る分詞（The best solution
+ * proposed a fix）と、ほかに述語の無い分詞（The best option changed.）は文の動詞。
+ */
+const participle = (tokens: readonly Token[], range: TokenRange, at: number): boolean => {
+  const next = tokens[at + 1];
+  if (tokens[at]?.features?.["VerbForm"] !== "Part" || (next !== undefined && PHRASE_START.has(next.pos))) return false;
+  return isVerbal(tokens[range.start - 1]) || mainVerbFollows(tokens, at);
+};
+
+/** 最上級のすぐ後ろ（the best possible outcome）か、名詞句の後ろ（the best education possible）。 */
+const bounded = (tokens: readonly Token[], range: TokenRange, at: number, bounds: Lexicon): boolean =>
+  isWord(tokens[range.end], bounds) || isWord(tokens[at], bounds);
+
+/** 修飾の語は名詞の前に来るので、句の後ろで止まった分詞は名詞の後ろにある。 */
+const clauseOrParticiple = (tokens: readonly Token[], range: TokenRange, at: number, restrictors: Restrictors): boolean => {
+  const last = tokens[at - 1];
+  const endsPhrase = at === range.end || (last !== undefined && PHRASE_END.has(last.pos));
+  return (endsPhrase && clause(tokens, at, restrictors)) || participle(tokens, range, at);
+};
+
+/**
+ * 最上級の名詞句を後ろの節か分詞か形容詞が限っているか（the best we have measured・the most scalable option discussed・
+ * the best education possible）。何の中で最もなのかを言っているので、限定の無い最上級ではない。
+ * 名詞の後ろに節を置かない言語は関係詞の語彙表が空で、節も分詞も読まない。
+ */
+export const restricted = (tokens: readonly Token[], range: TokenRange, restrictors: Restrictors): boolean => {
+  const at = phraseEnd(tokens, range.end);
+  return bounded(tokens, range, at, restrictors.bounds) || (restrictors.relatives.length > 0 && clauseOrParticiple(tokens, range, at, restrictors));
+};

package/src/detectors/superlative-scope.ts

@@ -21,14 +21,14 @@ export const scopeMarkersOf = (lexicon: Lexicon): ScopeMarkers => ({
 const NOMINAL = new Set(["NOUN", "PROPN"]);
 
 /** 名詞句の始まり。the world・Chicago・our products・the three・all。 */
-const PHRASE_START = new Set(["DET", "NOUN", "PROPN", "PRON", "NUM", "ADJ"]);
+export const PHRASE_START = new Set(["DET", "NOUN", "PROPN", "PRON", "NUM", "ADJ"]);
 
 /** 名詞の前に来る修飾（most skilled・widely used・stuffed）。名詞が出た後は名詞の連なりだけが続く。 */
 const PREMODIFIER = new Set(["ADJ", "ADV", "VERB", "NOUN", "PROPN", "NUM"]);
 const NOUN_RUN = new Set(["NOUN", "PROPN", "NUM"]);
 
 /** 範囲の前に置ける語。修飾だけで終わった句（the best is in …）は範囲ではなく述語。 */
-const PHRASE_END = new Set(["NOUN", "PROPN", "NUM", "ADJ"]);
+export const PHRASE_END = new Set(["NOUN", "PROPN", "NUM", "ADJ"]);
 
 const isMarker = (token: Token | undefined, markers: Lexicon): boolean =>
   token !== undefined && markers.some((entry) => entry.pattern.toLowerCase() === token.surface.toLowerCase());
@@ -47,7 +47,7 @@ const namedBefore = (tokens: readonly Token[], range: TokenRange, markers: Lexic
   isMarker(tokens[range.start - 1], markers) && isNamed(tokens[range.start - 2]);
 
 /** 最上級に続く名詞句の終わり。名詞が出るまでは修飾を、出た後は名詞の連なりを読む。 */
-const phraseEnd = (tokens: readonly Token[], at: number, nounSeen = false): number => {
+export const phraseEnd = (tokens: readonly Token[], at: number, nounSeen = false): number => {
   const token = tokens[at];
   if (token === undefined || !(nounSeen ? NOUN_RUN : PREMODIFIER).has(token.pos)) return at;
   return phraseEnd(tokens, at + 1, nounSeen || NOMINAL.has(token.pos));

package/src/detectors/team.ts

@@ -1,7 +1,8 @@
 import { proseText } from "../measure.ts";
 import { joinWords } from "./word-list.ts";
 import { wordsOf } from "./structure.ts";
-import type { Detector, Finding, Sentence, Token } from "../plugin.ts";
+import { nameSpans } from "../team-names.ts";
+import type { Detector, Finding, Sentence, Span, Token } from "../plugin.ts";
 
 /**
  * チームの言葉。社内でしか通じない語を、チームが chaff.yaml に自分で並べる。
@@ -76,8 +77,23 @@ const isProperNoun = (token: Token): boolean => token.pos === "PROPN";
  * spec は未知語率としていたが、**品詞解析があれば PROPN を数えるだけで足りる**。
  * 辞書を別に持つ必要はない。
  */
+const within = (spans: readonly Span[], token: Token): Span | undefined => spans.find((span) => token.span.start >= span.start && token.span.end <= span.end);
+
+/** 並べた名前は、何語に割れても 1 つの固有名詞（Bank of England は 2 つでなく 1 つ）。名前の中の 2 語目からを落とす。 */
+const properNounsOf = (sentence: Sentence, names: readonly string[]): Token[] => {
+  const named = nameSpans(sentence.text, names).map((span) => ({ start: sentence.span.start + span.start, end: sentence.span.start + span.end }));
+  const counted = new Set<Span>();
+  return (sentence.tokens ?? []).filter(isProperNoun).filter((token) => {
+    const name = within(named, token);
+    if (name === undefined) return true;
+    if (counted.has(name)) return false;
+    counted.add(name);
+    return true;
+  });
+};
+
 export const properNounDensity: Detector = (doc, options): Finding[] => {
-  const hits = doc.sentences.flatMap((sentence) => (sentence.tokens ?? []).filter(isProperNoun).map((token) => ({ sentence, token })));
+  const hits = doc.sentences.flatMap((sentence) => properNounsOf(sentence, doc.names ?? []).map((token) => ({ sentence, token })));
   const length = wordsOf(doc);
   const rate = length === 0 ? 0 : Math.round((hits.length / length) * PER);
   const first = hits[0];

package/src/detectors/token-shape.ts

@@ -1,6 +1,6 @@
 import { hasParticle, isClosed, lastContent } from "../sentence-shape.ts";
-import { isWithinAny, quotedSpans } from "../quoted-span.ts";
-import type { Detector, Finding, Sentence, Span, Token } from "../plugin.ts";
+import { isWithinAny, quotedIn } from "../quoted-span.ts";
+import type { Detector, Finding, Span, Token } from "../plugin.ts";
 
 /**
  * 文末が名詞で終わる（体言止め）。箇条書きでは普通だが、本文では文が途中で切れて読める。
@@ -45,10 +45,11 @@ export const nounEnding: Detector = (doc, options): Finding[] => {
  */
 type Run = { readonly surface: string; readonly tokens: readonly Token[] };
 
-const extend = (runs: readonly Run[], token: Token): Run[] => {
+const extend = (runs: Run[], token: Token): Run[] => {
   const last = runs.at(-1);
-  if (last !== undefined && last.surface === token.surface) return [...runs.slice(0, -1), { surface: last.surface, tokens: [...last.tokens, token] }];
-  return [...runs, { surface: token.surface, tokens: [token] }];
+  if (last !== undefined && last.surface === token.surface) runs[runs.length - 1] = { surface: last.surface, tokens: [...last.tokens, token] };
+  else runs.push({ surface: token.surface, tokens: [token] });
+  return runs;
 };
 
 const PARTICLE = new Set(["ADP", "SCONJ", "PART", "CCONJ"]);
@@ -66,13 +67,10 @@ const runsOf = (tokens: readonly Token[], nesting: readonly string[], quoted: re
   tokens.reduce<Run[]>((acc, token) => {
     if (isWithinAny(quoted, token.span)) return acc;
     if (nesting.includes(token.surface)) return extend(acc, token);
-    return token.pos === "PUNCT" || PARTICLE.has(token.pos) ? [...acc, BREAK] : acc;
+    if (token.pos === "PUNCT" || PARTICLE.has(token.pos)) acc.push(BREAK);
+    return acc;
   }, []);
 
-/** 文の中の、鉤括弧で引いたものを括弧ごと、文書全体の座標で。 */
-const quotedIn = (sentence: Sentence): Span[] =>
-  quotedSpans(sentence.text).map((span) => ({ start: sentence.span.start + span.start - 1, end: sentence.span.start + span.end + 1 }));
-
 export const doubledParticle: Detector = (doc, options): Finding[] => {
   const nesting = (options.lexicon ?? []).map((entry) => entry.pattern);
   return doc.sentences.flatMap((sentence) =>

package/src/document.ts

@@ -8,6 +8,7 @@ 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 { buildTree, type Outline } from "./structure/build.ts";
 import { isMarkdownPath } from "./structure/markdown-path.ts";
 import { pageFurniture, textOutline } from "./page-furniture.ts";
@@ -221,12 +222,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 +271,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,10 +282,12 @@ 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 ?? [],
 });
 
 export const buildDocument = (
@@ -305,11 +330,12 @@ export const buildDocument = (
     sections: sectionsOf(headingsOf(root, source), sentences, strongSpans(root, blocks), source.length),
     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,126 @@
+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 enough lines of the genre's own shape, per language. */
+export type GenreSuggest = { readonly paths: readonly RegExp[]; readonly lines: Readonly<Record<string, LineCue>> };
+
+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 suggestOf = (value: unknown, where: string): GenreSuggest => {
+  if (value === undefined) return { paths: [], lines: {} };
+  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 lines = Object.entries(value).filter(([key]) => key !== "paths");
+  return {
+    paths: paths.map((path) => patternOf(path, "iu", `${where} suggest.paths`)),
+    lines: Object.fromEntries(lines.map(([language, cue]) => [language, lineCueOf(cue, `${where} suggest.${language}`)])),
+  };
+};
+
+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,37 @@
+import type { GenreData, GenreDefinition } from "./genre-parse.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 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 =>
+  genre.suggest.paths.some((pattern) => pattern.test(input.path)) ? BY_PATH : 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;
+};