chaffjs 0.15.0 → 0.16.0

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 度目は問い合わせない。

package/src/line-paragraphs.ts

@@ -0,0 +1,83 @@
+import type { Span } from "./plugin.ts";
+
+/**
+ * 1 行に 1 段落を書き、段落の間に空行を置かない文書（青空文庫、議事録、`<br>` で改行した HTML）。
+ * Markdown では全体が 1 つの段落になるが、書いた人にとっては行が段落。
+ *
+ * 割るのは文の終わる改行だけ。文の境目は解析器が改行をつないだ上で決めたもの（#248）なので、折り返した文は割れない。
+ * 形で見分けるのは 2 つ:
+ * - 固定幅の折り返しは、行の多くが文の途中で終わる。文で終わる行（段落の最後の行を含む）が半分に届かなければ割らない
+ *   （議事録は発言者の行と発言の行が交互に来るので、半分ちょうどは割る）。
+ * - 1 行 1 文の書き方（行を意味の切れ目で改める。英語の Markdown に多い）は、段落のつもりではない。
+ *   文の頭で始まり文の終わりで終わる行が 2 文以上を持つことが、段落を 1 行に書いた印。それがたまにしか無ければ割らない。
+ */
+
+/** 2 文以上を持つ行がこれより少なければ、1 行 1 文の書き方にたまに混じる 2 文の行と見分けられない。 */
+const MIN_MULTI_SENTENCE = 3;
+/** 2 文以上を持つ行が、割った段落の数のこの割合に届かなければ割らない。議事録は 1 文の発言が多い。 */
+const MULTI_SENTENCE_SHARE = 1 / 5;
+
+const NEWLINE = /\r?\n/gu;
+
+type Line = { readonly span: Span; readonly newline: number };
+
+/** 段落の中の行と、その行を終える改行の位置（最後の行は段落の終わり）。 */
+const linesOf = (source: string, paragraph: Span): Line[] => {
+  const text = source.slice(paragraph.start, paragraph.end);
+  const breaks = [...text.matchAll(NEWLINE)].map((match) => ({ at: paragraph.start + match.index, width: match[0].length }));
+  const starts = [paragraph.start, ...breaks.map((found) => found.at + found.width)];
+  return starts.map((start, index) => {
+    const end = breaks[index]?.at ?? paragraph.end;
+    return { span: { start, end }, newline: end };
+  });
+};
+
+/** 文の前後の空白を除いた範囲。改行が文の中にあるかを、空白でなく文字で決める。 */
+const coreOf = (source: string, sentence: Span): Span => {
+  const text = source.slice(sentence.start, sentence.end);
+  return { start: sentence.start + text.length - text.trimStart().length, end: sentence.end - (text.length - text.trimEnd().length) };
+};
+
+/** cores（並び順、重ならない）の中で、start が offset 以上の最初の添字。何万行の段落でも行ごとに全部をなめない。 */
+const firstStartingAt = (cores: readonly Span[], offset: number): number => {
+  const search = (low: number, high: number): number => {
+    if (low >= high) return low;
+    const middle = (low + high) >> 1;
+    return (cores[middle]?.start ?? Number.POSITIVE_INFINITY) >= offset ? search(low, middle) : search(middle + 1, high);
+  };
+  return search(0, cores.length);
+};
+
+/** 改行をまたぐ文が無い。またぐなら、改行の直前に始まった文がまだ続いている。 */
+const endsSentence = (line: Line, cores: readonly Span[]): boolean => (cores[firstStartingAt(cores, line.newline) - 1]?.end ?? 0) <= line.newline;
+
+/** 行の並びを、文の終わる改行で区切った段落。 */
+const groupAt = (lines: readonly Line[], closing: readonly boolean[]): Span[] => {
+  const firsts = lines.flatMap((_, index) => (index === 0 || closing[index - 1] === true ? [index] : []));
+  return firsts.map((first, index) => ({
+    start: lines[first]?.span.start ?? 0,
+    end: lines[(firsts[index + 1] ?? lines.length) - 1]?.span.end ?? 0,
+  }));
+};
+
+const sentencesIn = (group: Span, cores: readonly Span[]): number => firstStartingAt(cores, group.end) - firstStartingAt(cores, group.start);
+
+/** 文の頭で始まり文の終わりで終わる行のうち、2 文以上を持つもの。固定幅の折り返しでは、行の両端が偶然そろうことはまれ。 */
+const wholeMultiSentenceLines = (lines: readonly Line[], closing: readonly boolean[], cores: readonly Span[]): number =>
+  lines.filter((line, index) => (index === 0 || closing[index - 1] === true) && closing[index] === true && sentencesIn(line.span, cores) >= 2).length;
+
+/** 行ごとの段落として読む形か。 */
+const isLineShaped = (lines: readonly Line[], closing: readonly boolean[], groups: readonly Span[], cores: readonly Span[]): boolean => {
+  const closed = closing.filter(Boolean).length;
+  const multi = wholeMultiSentenceLines(lines, closing, cores);
+  return closed * 2 >= closing.length && multi >= MIN_MULTI_SENTENCE && multi >= groups.length * MULTI_SENTENCE_SHARE;
+};
+
+/** paragraph を、書いた人が段落のつもりで改めた行ごとに割る。そう読めなければ paragraph 1 つ。sentences は段落の中の文。 */
+export const lineParagraphs = (source: string, paragraph: Span, sentences: readonly Span[]): Span[] => {
+  const lines = linesOf(source, paragraph);
+  const cores = sentences.map((sentence) => coreOf(source, sentence)).filter((core) => core.end > core.start);
+  const closing = lines.map((line) => endsSentence(line, cores));
+  const groups = groupAt(lines, closing);
+  return isLineShaped(lines, closing, groups, cores) ? groups : [paragraph];
+};

package/src/mask.ts

@@ -17,14 +17,13 @@ import type { Span } from "./plugin.ts";
 const blankOut = (text: string): string => text.replace(/[^\n]/gu, (char) => " ".repeat(char.length));
 
 const merge = (spans: readonly Span[]): Span[] =>
-  [...spans]
-    .sort((left, right) => left.start - right.start)
+  spans
+    .toSorted((left, right) => left.start - right.start)
     .reduce<Span[]>((acc, span) => {
       const last = acc.at(-1);
-      if (last !== undefined && span.start <= last.end) {
-        return [...acc.slice(0, -1), { start: last.start, end: Math.max(last.end, span.end) }];
-      }
-      return [...acc, span];
+      if (last !== undefined && span.start <= last.end) acc[acc.length - 1] = { start: last.start, end: Math.max(last.end, span.end) };
+      else acc.push(span);
+      return acc;
     }, []);
 
 export const maskSpans = (source: string, spans: readonly Span[]): string => {

package/src/plugin.ts

@@ -314,6 +314,8 @@ export type ProseDocument = {
   readonly lexicons: Readonly<Record<string, Lexicon>>;
   /** この種類の文書に無いと困る見出し。チームが chaff.yaml で決める。 */
   readonly requiredSections: readonly string[];
+  /** チームが chaff.yaml の names に並べた固有名詞。1 つの名前として読み、書き手の落ち度に数えない。 */
+  readonly names?: readonly string[];
   /** 番地の付いた木（§27）。adapter が structure を持たない言語では無い。 */
   readonly structure: StructureNode | undefined;
   /** 文書の種類（法令など）。選ばれなければ無い。 */
@@ -333,6 +335,8 @@ export type Finding = {
   readonly quote: string;
   /** message のプレースホルダに入れる値。 */
   readonly values: Readonly<Record<string, string | number>>;
+  /** 1 つの rule が 2 通りの見つけ方を持つとき、どちらで見つけたか。rule の messages から文を選ぶ。無ければ message。 */
+  readonly variant?: string;
 };
 
 /** rule 定義が threshold を渡す。数値は 4 語から解決済み。 */
@@ -360,6 +364,8 @@ export type RuleDefinition = {
   readonly why: Localized;
   readonly how_to_fix: Localized;
   readonly message: Localized;
+  /** 見つけ方ごとの message（Finding の variant で引く）。ほとんどの rule は持たない。 */
+  readonly messages: Readonly<Record<string, Localized>>;
   /** 4 語と数値の対応。2 つ以上。未定義の段は normal に落ちる。spec §18.1。
    *  言語別の閾値を持つ rule（max-sentence-length）は、読み込み時に言語で平坦化済み。 */
   readonly levels: LevelTable;

package/src/profile/check.ts

@@ -0,0 +1,34 @@
+import { NO_PROFILE } from "./select.ts";
+
+/** Where a profile was set: chaff.yaml's profile, or one of its by_path entries. */
+export type ProfileSetting = "config" | "by_path";
+
+type UnknownProfile = {
+  readonly where: ProfileSetting;
+  readonly profile: string;
+  /** The by_path entry's files, so the message can say which entry; empty for chaff.yaml's profile. */
+  readonly files: readonly string[];
+};
+
+type PathProfile = { readonly files: readonly string[]; readonly profile?: string | undefined };
+
+type WrittenProfiles = { readonly config: string | undefined; readonly byPath: readonly PathProfile[] };
+
+/** Commands that never read a document, so never choose a profile. A wrong one in chaff.yaml must not stop them. */
+const PROFILE_FREE: ReadonlySet<string> = new Set(["init", "genres", "skill", "relax", "strict", "off", "rules", "explain"]);
+
+/** The profiles a command would read from chaff.yaml: none for a command that reads no document. */
+export const writtenProfiles = (command: string, config: { readonly profile: string | undefined; readonly byPath: readonly PathProfile[] }): WrittenProfiles =>
+  PROFILE_FREE.has(command) ? { config: undefined, byPath: [] } : { config: config.profile, byPath: config.byPath };
+
+const setting = (where: ProfileSetting, profile: string | undefined, files: readonly string[] = []): UnknownProfile[] =>
+  profile === undefined ? [] : [{ where, profile, files }];
+
+/**
+ * Every profile a setting names that is neither a bundled one nor none. Such a name chooses nothing and also stops the choice from the content,
+ * so it silently acts as none. All of them, not only the one a file would use, because a wrong setting is wrong for every file.
+ */
+export const unknownProfiles = (written: WrittenProfiles, known: readonly string[]): UnknownProfile[] =>
+  [...setting("config", written.config), ...written.byPath.flatMap((entry) => setting("by_path", entry.profile, entry.files))].filter(
+    (entry) => entry.profile !== NO_PROFILE && !known.includes(entry.profile),
+  );

package/src/profile/for-file.ts

@@ -1,11 +1,18 @@
 import { applyByPath } from "../config/by-path.ts";
 import type { Config } from "../config/load.ts";
 import type { DocumentProfile } from "../plugin.ts";
+import { presetProfile } from "../genre-load.ts";
 import { loadProfiles } from "./load.ts";
 import { chooseProfile } from "./select.ts";
 
 type ProfileSettings = Pick<Config, "profile" | "byPath" | "baseDir">;
 
-/** 1 ファイルの文書の種類。by_path、chaff.yaml、内容の順に選ぶ。 */
-export const profileFor = (config: ProfileSettings, path: string, source: string, language: string): DocumentProfile | undefined =>
-  chooseProfile(loadProfiles(), { byPath: applyByPath(config.byPath, config.baseDir, path).profile, config: config.profile, source, language })?.profile;
+/** 1 ファイルの文書の種類。by_path、chaff.yaml、ジャンル、内容の順に選ぶ。 */
+export const profileFor = (config: ProfileSettings, path: string, source: string, language: string, genre?: string): DocumentProfile | undefined =>
+  chooseProfile(loadProfiles(), {
+    byPath: applyByPath(config.byPath, config.baseDir, path).profile,
+    config: config.profile,
+    genre: genre === undefined ? undefined : presetProfile(genre),
+    source,
+    language,
+  })?.profile;

package/src/profile/load.ts

@@ -12,7 +12,7 @@ const loaded: { value: readonly ProfileDefinition[] | undefined } = { value: und
 export const loadProfiles = (): readonly ProfileDefinition[] => {
   loaded.value ??= readdirSync(PROFILES_DIR)
     .filter((file) => file.endsWith(".yaml"))
-    .sort((left, right) => left.localeCompare(right))
+    .toSorted((left, right) => left.localeCompare(right))
     .flatMap((file) => {
       const path = join(PROFILES_DIR, file);
       try {

package/src/profile/select.ts

@@ -4,13 +4,15 @@ import { detected, type ProfileDefinition } from "./parse.ts";
 /** 設定で書いた「使わない」。内容から選ぶのも止める。 */
 export const NO_PROFILE = "none";
 
-type ProfileSource = "by-path" | "config" | "content";
+type ProfileSource = "by-path" | "config" | "genre" | "content";
 
 export type ChosenProfile = { readonly profile: DocumentProfile; readonly from: ProfileSource };
 
 export type ProfileRequest = {
   readonly byPath: string | undefined;
   readonly config: string | undefined;
+  /** The profile the file's genre reads with (genres.yaml), when it names one. */
+  readonly genre?: string | undefined;
   readonly source: string;
   readonly language: string;
 };
@@ -18,16 +20,21 @@ export type ProfileRequest = {
 const named = (definitions: readonly ProfileDefinition[], id: string, language: string): DocumentProfile | undefined =>
   definitions.find((definition) => definition.id === id)?.languages[language];
 
+const writtenIn = (request: ProfileRequest): ProfileSource => {
+  if (request.byPath !== undefined) return "by-path";
+  return request.config === undefined ? "genre" : "config";
+};
+
 /**
- * 強いものから: by_path、chaff.yaml の profile、内容。どれかが none と書けばそこで止め、内容からも選ばない。
+ * 強いものから: by_path、chaff.yaml の profile、ジャンルの profile、内容。どれかが none と書けばそこで止め、内容からも選ばない。
  * 名前で選んだ種類にその言語の中身が無ければ選ばない。黙って別の種類にしない。
  */
 export const chooseProfile = (definitions: readonly ProfileDefinition[], request: ProfileRequest): ChosenProfile | undefined => {
-  const written = request.byPath ?? request.config;
+  const written = request.byPath ?? request.config ?? request.genre;
   if (written === NO_PROFILE) return undefined;
   if (written !== undefined) {
     const profile = named(definitions, written, request.language);
-    return profile === undefined ? undefined : { profile, from: request.byPath === undefined ? "config" : "by-path" };
+    return profile === undefined ? undefined : { profile, from: writtenIn(request) };
   }
   const found = definitions.find((definition) => detected(definition, request.source, request.language));
   const profile = found?.languages[request.language];

package/src/quoted-span.ts

@@ -1,25 +1,39 @@
-import type { Span } from "./plugin.ts";
+import type { Sentence, Span } from "./plugin.ts";
 
-/** 鉤括弧の開きと、それを閉じる字。 */
-const CLOSER: Readonly<Record<string, string>> = { "「": "」", "『": "』" };
+/** 開きの字と、それを閉じる字。 */
+type Marks = Readonly<Record<string, string>>;
+
+/** 鉤括弧。日本語の引用と題名。 */
+export const KAGI_MARKS: Marks = { "「": "」", "『": "』" };
+
+/**
+ * 引用符も含めた、人の言葉を引く印。英語の "…" は開きと閉じが同じ字なので、開いている間に来たら閉じと読む。
+ * 一重の ’ は "don’t" の省略の印と見分けられないので入れない。
+ */
+export const QUOTATION_MARKS: Marks = { ...KAGI_MARKS, "“": "”", '"': '"' };
 
 type Open = { readonly closer: string; readonly at: number };
 type Scan = { readonly open: readonly Open[]; readonly spans: readonly Span[] };
 
-const step = (scan: Scan, char: string, at: number): Scan => {
-  const closer = CLOSER[char];
-  if (closer !== undefined) return { open: [...scan.open, { closer, at }], spans: scan.spans };
-  const last = scan.open.at(-1);
-  if (last === undefined || last.closer !== char) return scan;
-  return { open: scan.open.slice(0, -1), spans: [...scan.spans, { start: last.at + 1, end: at }] };
-};
+const step =
+  (marks: Marks) =>
+  (scan: Scan, char: string, at: number): Scan => {
+    const last = scan.open.at(-1);
+    if (last !== undefined && last.closer === char) return { open: scan.open.slice(0, -1), spans: [...scan.spans, { start: last.at + 1, end: at }] };
+    const closer = marks[char];
+    return closer === undefined ? scan : { open: [...scan.open, { closer, at }], spans: scan.spans };
+  };
 
 /**
- * 鉤括弧（「」『』）の中身の位置。括弧そのものは含まない。入れ子はそれぞれを返す。
+ * 引いたものの中身の位置（既定は鉤括弧「」『』）。括弧そのものは含まない。入れ子はそれぞれを返す。
  * 閉じない括弧と、開きと組にならない閉じ括弧は中身を作らない。位置は text の先頭を 0 とする。
  * 括弧は BMP の字なので、UTF-16 の 1 単位ずつ見れば位置がそのまま使える。
  */
-export const quotedSpans = (text: string): Span[] => [...text.split("").reduce<Scan>((scan, char, at) => step(scan, char, at), { open: [], spans: [] }).spans];
+export const quotedSpans = (text: string, marks: Marks = KAGI_MARKS): Span[] => [...text.split("").reduce<Scan>(step(marks), { open: [], spans: [] }).spans];
+
+/** 文の中の、引いたものを括弧ごと、文書全体の座標で。 */
+export const quotedIn = (sentence: Sentence, marks: Marks = KAGI_MARKS): Span[] =>
+  quotedSpans(sentence.text, marks).map((span) => ({ start: sentence.span.start + span.start - 1, end: sentence.span.start + span.end + 1 }));
 
 /** inner が、spans のどれかにまるごと入っているか。 */
 export const isWithinAny = (spans: readonly Span[], inner: Span): boolean => spans.some((span) => inner.start >= span.start && inner.end <= span.end);

package/src/reasons.ts

@@ -1,4 +1,5 @@
 import type { Texts } from "./ui.ts";
+import { formFor } from "./render/plural.ts";
 
 /** Why a rule did not run, in the document's language. Listed under the findings so "0 findings" is never a silent pass. */
 export type Reasons = {
@@ -8,6 +9,7 @@ export type Reasons = {
   readonly semantic: string;
   readonly experimental: string;
   readonly turnedOff: string;
+  readonly presetOff: (genre: string) => string;
   readonly noStructure: (language: string) => string;
   readonly unreadStructure: (clauses: number, units: number) => string;
   readonly noDetector: (name: string) => string;
@@ -27,6 +29,7 @@ export const REASONS: Texts<Reasons> = {
     semantic: "意味を読む検査のため（npx chaff test で動きます）",
     experimental: "まだ試験中のため",
     turnedOff: "設定で止めているため",
+    presetOff: (genre) => `ジャンル ${genre} では見ないため`,
     noStructure: (language) => `${language} のパッケージは文書の構造を読めないため`,
     unreadStructure: (clauses, units) =>
       `条項の番号が本文に ${String(clauses)} 個あるのに、番号として読めたのは ${String(units)} 個のため（深い字下げや、行が本文につながった文書）`,
@@ -40,9 +43,10 @@ export const REASONS: Texts<Reasons> = {
     semantic: "it reads meaning; npx chaff test runs it",
     experimental: "still experimental",
     turnedOff: "turned off in the settings",
+    presetOff: (genre) => `the ${genre} genre does not check it`,
     noStructure: (language) => `the ${language} package cannot read a document's structure`,
     unreadStructure: (clauses, units) =>
-      `the text has ${String(clauses)} clause numbers but only ${String(units)} were read as numbered lines (deep indents, or lines run into the text)`,
+      `the text has ${String(clauses)} clause numbers but only ${String(units)} ${formFor(units, "was read as a numbered line", "were read as numbered lines")} (deep indents, or lines run into the text)`,
     noDetector: (name) => `no detector named ${name}`,
     noLexicon: (language, list) => `the ${language} package has no word list ${list}`,
   },

package/src/render/compact.ts

@@ -1,11 +1,9 @@
 import type { RuleDefinition } from "../plugin.ts";
 import type { RunResult } from "../run.ts";
 import { messageOf } from "./text.ts";
+import { counted } from "./plural.ts";
 import { uiLanguageOf, type Texts } from "../ui.ts";
 
-/** 「1 finding」「2 findings」。 */
-const counted = (count: number, noun: string): string => `${String(count)} ${noun}${count === 1 ? "" : "s"}`;
-
 /**
  * 最後の集計の行は、画面のほかの部分と同じく文書の言語で出す。行ごとの重さ（warning / error）は、grep や別の道具が読むので英語のまま。
  */

package/src/render/eval.ts

@@ -1,5 +1,6 @@
 import { MIN_CORPUS, TARGET_HIT_RATE, type Point, type RuleReport } from "../eval.ts";
 import type { Texts, UiLanguage } from "../ui.ts";
+import { counted, formFor } from "./plural.ts";
 
 const pct = (part: number, whole: number): string => `${((part / Math.max(1, whole)) * 100).toFixed(1)}%`;
 
@@ -51,19 +52,19 @@ const TEXT: Texts<{
     recommended: "  ← recommended",
     both: "  ← current / recommended",
     point: (point, share) =>
-      `${String(point.documents).padStart(3)} ${point.documents === 1 ? "doc " : "docs"} (${share.padStart(6)})   ${String(point.findings).padStart(3)} ${point.findings === 1 ? "finding " : "findings"}   ${point.per10k.toFixed(1)} per 10,000 characters`,
+      `${String(point.documents).padStart(3)} ${formFor(point.documents, "doc ", "docs")} (${share.padStart(6)})   ${String(point.findings).padStart(3)} ${formFor(point.findings, "finding ", "findings")}   ${point.per10k.toFixed(1)} per 10,000 characters`,
     fits: `    The current limit meets the target (under ${TARGET}%).`,
     nothingFits: "    No limit meets the target. The rule itself may not suit this corpus.",
     over: (share) => `    At the current limit ${share} of the documents are hit, over the target (under ${TARGET}%).`,
     recommend: (limit) => `    Recommended: ${limit}`,
     toConfig: (rule, limit) => `${EN_CONFIG_LEAD}rules:\n${" ".repeat(EN_CONFIG_LEAD.length + YAML_INDENT)}${rule}: ${limit}`,
-    measured: (paths, rules) => `  Measured ${rules} rule${rules === 1 ? "" : "s"} on ${paths} file${paths === 1 ? "" : "s"} as a corpus.`,
+    measured: (paths, rules) => `  Measured ${counted(rules, "rule")} on ${counted(paths, "file")} as a corpus.`,
     premise: [
       "  The documents here are taken as good documents that people wrote and published.",
       `  A rule that fires often on them may have a limit that does not fit real writing (target: under ${TARGET}%).`,
     ],
     smallCorpus: (total) => [
-      `  Note: the corpus has only ${total} document${total === 1 ? "" : "s"}. Showing ${TARGET}% takes at least ${MIN_CORPUS}.`,
+      `  Note: the corpus has only ${counted(total, "document")}. Showing ${TARGET}% takes at least ${MIN_CORPUS}.`,
       "     For now each share is either 0 or all, so read the density on the right (findings per 10,000 characters).",
     ],
     untouched: "  No limit was changed. A different corpus gives a different answer.",

package/src/render/friendly.ts

@@ -2,6 +2,7 @@ import type { Finding, RuleDefinition } from "../plugin.ts";
 import type { RunResult } from "../run.ts";
 import { MARK, localized, messageOf } from "./text.ts";
 import { tally } from "./summary.ts";
+import { counted } from "./plural.ts";
 import { uiLanguageOf, type Texts } from "../ui.ts";
 
 const RULE = 60;
@@ -13,6 +14,7 @@ const TEXT: Texts<{
   readonly deterministic: string;
   readonly untouched: string;
   readonly forced: (n: number, ids: string) => string;
+  readonly presetOn: (n: number, ids: string) => string;
   readonly notRun: (n: number) => string;
   readonly because: (why: string) => string;
 }> = {
@@ -23,6 +25,7 @@ const TEXT: Texts<{
     deterministic: "              （同じ文章なら何度実行しても同じ結果になります）",
     untouched: "文章は書き換えていません。直すのは書いた人です。",
     forced: (n, ids) => `試験中の rule を ${n} 件、設定により有効にしています: ${ids}`,
+    presetOn: (n, ids) => `試験中の rule を ${n} 件、ジャンルの既定で有効にしています: ${ids}`,
     notRun: (n) => `${n} 件の rule は動いていません:`,
     because: (why) => `（${why}）`,
   },
@@ -32,8 +35,9 @@ const TEXT: Texts<{
     machine: "All judged by machine",
     deterministic: "              (the same text gives the same result every time)",
     untouched: "The text was not changed. Fixing it is the writer's job.",
-    forced: (n, ids) => `${n} experimental rule${n === 1 ? "" : "s"} turned on in the settings: ${ids}`,
-    notRun: (n) => `${n} rule${n === 1 ? "" : "s"} did not run:`,
+    forced: (n, ids) => `${counted(n, "experimental rule")} turned on in the settings: ${ids}`,
+    presetOn: (n, ids) => `${counted(n, "experimental rule")} turned on by the genre: ${ids}`,
+    notRun: (n) => `${counted(n, "rule")} did not run:`,
     because: (why) => ` (${why})`,
   },
 };
@@ -69,14 +73,21 @@ const block = (finding: Finding, rule: RuleDefinition, language: string): string
   "",
 ];
 
-export const renderFriendly = (header: string, result: RunResult, rules: readonly RuleDefinition[], language: string): string => {
+/** notes: lines after the not-run list (the genre chaff suggests when none is set). */
+export const renderFriendly = (
+  header: string,
+  result: RunResult,
+  rules: readonly RuleDefinition[],
+  language: string,
+  notes: readonly string[] = [],
+): string => {
   const byId = new Map(rules.map((rule) => [rule.id, rule]));
   const blocks = result.findings.flatMap((finding) => {
     const rule = byId.get(finding.rule);
     return rule === undefined ? [] : block(finding, rule, language);
   });
   const text = TEXT[uiLanguageOf(language)];
-  const notes = [
+  const closing = [
     "",
     "─".repeat(RULE),
     "",
@@ -85,10 +96,14 @@ export const renderFriendly = (header: string, result: RunResult, rules: readonl
     "",
     `  ${text.untouched}`,
   ];
-  const forced = result.forcedExperimental.length > 0 ? ["", `  ${text.forced(result.forcedExperimental.length, result.forcedExperimental.join(", "))}`] : [];
+  const forced = [
+    ...(result.forcedExperimental.length > 0 ? ["", `  ${text.forced(result.forcedExperimental.length, result.forcedExperimental.join(", "))}`] : []),
+    ...(result.presetExperimental.length > 0 ? ["", `  ${text.presetOn(result.presetExperimental.length, result.presetExperimental.join(", "))}`] : []),
+  ];
   const skipped =
     result.skipped.length > 0
       ? ["", `  ${text.notRun(result.skipped.length)}`, ...result.skipped.map((entry) => `      ${entry.rule}${text.because(entry.why)}`)]
       : [];
-  return ["", header, ...blocks, ...notes, ...forced, ...skipped, ""].join("\n");
+  const after = notes.flatMap((note) => ["", note]);
+  return ["", header, ...blocks, ...closing, ...forced, ...skipped, ...after, ""].join("\n");
 };

package/src/render/genres.ts

@@ -0,0 +1,31 @@
+import type { GenreData } from "../genre-parse.ts";
+import type { Texts, UiLanguage } from "../ui.ts";
+
+const TEXT: Texts<{ readonly heading: string; readonly usage: readonly string[] }> = {
+  ja: {
+    heading: "  ジャンル（文書の種類）を選ぶと、その種類の書き方に合わせて見ます:",
+    usage: [
+      "  この実行だけ:    npx chaffjs --genre legal/contract 契約書.md",
+      "  この場所に決める: npx chaffjs init --genre legal/contract   （chaff.yaml の genre に書きます）",
+    ],
+  },
+  en: {
+    heading: "  Pick the genre (the kind of document) and chaff checks it the way that kind is written:",
+    usage: [
+      "  For one run:       npx chaffjs --genre legal/contract contract.md",
+      "  For this folder:   npx chaffjs init --genre legal/contract   (writes genre in chaff.yaml)",
+    ],
+  },
+};
+
+/** `chaff genres`: every genre under its group, with what it is for, in the output language. */
+export const renderGenres = (data: GenreData, ui: UiLanguage): string => {
+  const width = Math.max(...data.genres.map((genre) => genre.id.length)) + 2;
+  const groups = data.groups.flatMap((group) => {
+    const members = data.genres.filter((genre) => genre.id.startsWith(`${group.id}/`));
+    return members.length === 0
+      ? []
+      : ["", `  ${group.name[ui] ?? group.id}`, ...members.map((genre) => `    ${genre.id.padEnd(width)}${genre.summary[ui] ?? ""}`)];
+  });
+  return ["", TEXT[ui].heading, ...groups, "", ...TEXT[ui].usage, ""].join("\n");
+};

package/src/render/plural.ts

@@ -0,0 +1,6 @@
+/** English agreement: only exactly one takes the singular ("0 findings", "1 finding", "1.5 findings"). */
+const isOne = (count: number | string): boolean => String(count) === "1";
+
+export const formFor = (count: number | string, singular: string, plural: string): string => (isOne(count) ? singular : plural);
+
+export const counted = (count: number, singular: string, plural = `${singular}s`): string => `${String(count)} ${formFor(count, singular, plural)}`;