chaffjs 0.1.0 → 0.3.0

package/src/eval.ts

@@ -0,0 +1,80 @@
+import { DETECTORS } from "./detectors/index.ts";
+import { charLength } from "./measure.ts";
+import type { ProseDocument, RuleDefinition } from "./plugin.ts";
+
+/**
+ * 閾値の較正。
+ *
+ * examples/ に置いた文書は、実際に公開した「人間の良い文書」。そこで多く発火する
+ * rule は、閾値が現実に合っていない疑いがある。spec §21 の目標（人間の良い文書での
+ * 誤検知率 5% 未満）を、そのまま推奨の判断に使う。
+ *
+ * これは較正であって正解ではない。corpus が変われば答えも変わる。だから自動では
+ * 適用せず、提示して選ばせる。
+ */
+export const TARGET_HIT_RATE = 0.05;
+
+/** 文書単位の割合は corpus が小さいと粗い。文字数あたりの密度を併記する。 */
+export type Point = { readonly limit: number; readonly findings: number; readonly documents: number; readonly per10k: number };
+
+/** 5% を表せるだけの文書数。これを下回ると割合が「0 か全部」になる。 */
+export const MIN_CORPUS = 20;
+
+export type RuleReport = {
+  readonly rule: string;
+  readonly name: string;
+  readonly current: number;
+  readonly sweep: readonly Point[];
+  readonly recommended: number | undefined;
+  readonly total: number;
+};
+
+/** strict が relaxed より大きい rule は、値が大きいほど厳しい（sentence-rhythm）。 */
+const stricterIsHigher = (rule: RuleDefinition): boolean => (rule.levels.strict ?? 0) > (rule.levels.relaxed ?? 0);
+
+const MULTIPLIERS = [0.5, 0.7, 0.85, 1, 1.25, 1.5, 2, 3];
+
+/** rule 自身が持つ段を基点に掃引する。rule ごとに単位が違うので、倍率で散らす。 */
+const candidates = (rule: RuleDefinition): number[] => {
+  const base = rule.levels.normal ?? 1;
+  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])].sort((left, right) => left - right);
+};
+
+const countAt = (docs: readonly ProseDocument[], rule: RuleDefinition, limit: number): Point => {
+  const detector = DETECTORS[rule.how_to_find];
+  if (detector === undefined) return { limit, findings: 0, documents: 0, per10k: 0 };
+  const perDoc = docs.map((doc) => {
+    const lexicon = rule.word_list === undefined ? undefined : doc.lexicons[rule.word_list];
+    if (rule.word_list !== undefined && lexicon === undefined) return 0;
+    return detector(doc, { limit, lexicon, where: rule.where }).length;
+  });
+  const findings = perDoc.reduce((sum, count) => sum + count, 0);
+  const chars = docs.reduce((sum, doc) => sum + doc.sentences.reduce((inner, sentence) => inner + charLength(sentence), 0), 0);
+  return { limit, findings, documents: perDoc.filter((count) => count > 0).length, per10k: chars === 0 ? 0 : (findings / chars) * 10000 };
+};
+
+/** 目標の誤検知率を満たす中で、いちばん厳しい閾値を選ぶ。 */
+const recommend = (rule: RuleDefinition, sweep: readonly Point[], total: number): number | undefined => {
+  const ok = sweep.filter((point) => point.documents / Math.max(1, total) <= TARGET_HIT_RATE);
+  if (ok.length === 0) return undefined;
+  const strictest = stricterIsHigher(rule) ? Math.max(...ok.map((p) => p.limit)) : Math.min(...ok.map((p) => p.limit));
+  return strictest;
+};
+
+export const evaluate = (docs: readonly ProseDocument[], rules: readonly RuleDefinition[], genre: string, language: string): RuleReport[] =>
+  rules
+    .filter((rule) => rule.layer !== "L4" && rule.use_for.some((target) => genre.startsWith(target)))
+    .map((rule) => {
+      const sweep = candidates(rule).map((limit) => countAt(docs, rule, limit));
+      const current = rule.levels.normal ?? 1;
+      return {
+        rule: rule.id,
+        name: rule.name[language] ?? rule.id,
+        current,
+        sweep,
+        recommended: recommend(rule, sweep, docs.length),
+        total: docs.length,
+      };
+    });

package/src/genre.ts

@@ -1,12 +1,19 @@
 export type GenreGuess = { readonly genre: string; readonly from: string };
 
+/**
+ * 仕様書・README は「読ませる文章」ではなく「間違えさせない文章」。
+ * 書き出しのつかみもリズムも要らない。技術文書として別に見る。
+ */
 const BY_PATH: readonly (readonly [RegExp, string])[] = [
+  [/(^|\/)readme\.md$/iu, "technical/readme"],
+  [/spec[^/]*\.md$/iu, "technical/spec"],
+  [/(^|\/)(spec|specs)\//iu, "technical/spec"],
   [/(^|\/)(proposals?|teian)\//iu, "business/proposal"],
   [/(^|\/)(minutes|gijiroku)\//iu, "business/meeting-notes"],
   [/(^|\/)(press|pr)\//iu, "business/press-release"],
   [/(^|\/)(reports?)\//iu, "business/report"],
   [/(^|\/)(blog|posts?|articles?)\//iu, "blog/tech"],
-  [/(^|\/)docs?\//iu, "blog/tech"],
+  [/(^|\/)docs?\//iu, "technical/readme"],
 ];
 
 /**

package/src/init.ts

@@ -26,7 +26,8 @@ genre: ${genre}
 rules:
 `;
 
-const GITIGNORE_LINE = ".chaff-cache/";
+/** 判定のキャッシュと、鍵を書くファイル。どちらも commit しない。 */
+const GITIGNORE_LINES = [".chaff-cache/", ".env*"];
 
 type Written = { readonly path: string; readonly note: string };
 
@@ -36,13 +37,15 @@ const writeIfAbsent = (path: string, body: string, note: string): Written | unde
   return { path, note };
 };
 
-/** judge のキャッシュは commit しない。init が .gitignore に足す。 */
+/** 判定のキャッシュと .env は commit しない。init が .gitignore に足す。 */
 const ensureGitignore = (dir: string): Written | undefined => {
   const path = join(dir, ".gitignore");
-  if (!existsSync(path)) return writeIfAbsent(path, `${GITIGNORE_LINE}\n`, "作成しました");
-  if (readFileSync(path, "utf8").includes(GITIGNORE_LINE)) return undefined;
-  appendFileSync(path, `${GITIGNORE_LINE}\n`, "utf8");
-  return { path, note: `${GITIGNORE_LINE} を追記しました` };
+  if (!existsSync(path)) return writeIfAbsent(path, `${GITIGNORE_LINES.join("\n")}\n`, "作成しました");
+  const body = readFileSync(path, "utf8");
+  const missing = GITIGNORE_LINES.filter((line) => !body.split("\n").includes(line));
+  if (missing.length === 0) return undefined;
+  appendFileSync(path, `${missing.join("\n")}\n`, "utf8");
+  return { path, note: `${missing.join(" と ")} を追記しました` };
 };
 
 export const runInit = (dir: string, genre: string): string[] => {
@@ -65,6 +68,8 @@ export const runInit = (dir: string, genre: string): string[] => {
 };
 
 export const GENRES: readonly string[] = [
+  "technical/spec",
+  "technical/readme",
   "blog/tech",
   "blog/essay",
   "blog/owned-media",

package/src/levels.ts

@@ -1,4 +1,4 @@
-import type { Level, RuleDefinition } from "./plugin.ts";
+import type { Level, LevelTable, RuleDefinition } from "./plugin.ts";
 
 export const LEVELS: readonly Level[] = ["strict", "normal", "relaxed", "off"];
 
@@ -14,11 +14,23 @@ export type Resolved = { readonly level: Level; readonly limit: number; readonly
  * 落ちたことを呼ぶ側に伝えるのは、`chaff strict` が「変えたつもりで変わっていない」
  * 状態を作らないようにするため。
  */
-export const resolve = (rule: RuleDefinition, level: Level): Resolved => {
+/**
+ * ジャンル別の閾値。"business/email" は "business" より細かいので先に当たる。
+ * 仕様書の一文と社内メールに同じ文長を課すと、どちらかが必ず間違う。spec §9。
+ */
+const tableFor = (rule: RuleDefinition, genre: string | undefined): LevelTable => {
+  if (genre === undefined) return rule.levels;
+  const parts = genre.split("/");
+  const keys = parts.map((_, index) => parts.slice(0, parts.length - index).join("/"));
+  return keys.reduce<LevelTable | undefined>((found, key) => found ?? rule.by_genre[key], undefined) ?? rule.levels;
+};
+
+export const resolve = (rule: RuleDefinition, level: Level, genre?: string): Resolved => {
   if (level === "off") return { level, limit: 0, fellBackToNormal: false };
-  const direct = rule.levels[level];
+  const table = tableFor(rule, genre);
+  const direct = table[level];
   if (direct !== undefined) return { level, limit: direct, fellBackToNormal: false };
-  const normal = rule.levels.normal;
+  const normal = table.normal ?? rule.levels.normal;
   if (normal === undefined) throw new Error(`rule "${rule.id}" has no normal level`);
   return { level: "normal", limit: normal, fellBackToNormal: true };
 };

package/src/look-at.ts

@@ -0,0 +1,53 @@
+import type { ProseDocument } from "./plugin.ts";
+import type { Candidate } from "./semantic.ts";
+
+/**
+ * 自然文で書かれた `look_at` を、決定的な絞り込みに変える。spec §14、§26-7。
+ *
+ * 変換に LLM も対話も使わない。書き手は「どこを見るか」を説明するとき、
+ * 見るべき語を**自然に括弧でくくる**。
+ *
+ *   look_at: 「お願いします」「ご確認ください」を含む文
+ *
+ * その括弧の中を取り出すだけで、文単位の絞り込みになる。
+ * 推測を足さないので、書いたものと動くものが一致する。
+ */
+const QUOTED = /[「『"'`]([^「『』」"'`]{1,40})[」』"'`]/gu;
+
+export const wordsFrom = (lookAt: string | undefined): string[] => {
+  if (lookAt === undefined) return [];
+  const found = [...lookAt.matchAll(QUOTED)].map((match) => match[1]?.trim() ?? "").filter((word) => word.length > 0);
+  return [...new Set(found)];
+};
+
+/** 数値を見ると書いてあれば、数字のある文に限る。 */
+const WANTS_NUMBER = /数値|数字|number|figure/iu;
+
+export type Narrowing = { readonly words: readonly string[]; readonly needsNumber: boolean; readonly kept: number; readonly total: number };
+
+const NUMBER = /\d/u;
+
+const matches = (text: string, words: readonly string[], needsNumber: boolean): boolean => {
+  if (needsNumber && !NUMBER.test(text)) return false;
+  return words.length === 0 || words.some((word) => text.includes(word));
+};
+
+/**
+ * 絞り込めたら文単位で、絞り込めなければ文書全体を渡す。
+ * 全体を渡すときは「絞り込めなかった」ことを呼ぶ側に返す。黙って高いほうを選ばない。
+ */
+export const narrow = (
+  doc: ProseDocument,
+  lookAt: string | undefined,
+  whole: (doc: ProseDocument) => Candidate[],
+): { candidates: Candidate[]; narrowing: Narrowing } => {
+  const words = wordsFrom(lookAt);
+  const needsNumber = lookAt !== undefined && WANTS_NUMBER.test(lookAt);
+  const total = doc.sentences.length;
+  if (words.length === 0 && !needsNumber) return { candidates: whole(doc), narrowing: { words, needsNumber, kept: total, total } };
+  const hits = doc.sentences.filter((sentence) => matches(sentence.text, words, needsNumber));
+  return {
+    candidates: hits.map((sentence) => ({ text: sentence.text.trim(), offset: sentence.span.start })),
+    narrowing: { words, needsNumber, kept: hits.length, total },
+  };
+};

package/src/measure.ts

@@ -0,0 +1,21 @@
+import type { Sentence } from "./plugin.ts";
+
+/**
+ * 文の長さ。**覆った部分の空白を数えない。**
+ *
+ * 非 prose は同じ長さの空白で覆っている（オフセットを保つため）。そのまま数えると、
+ * URL を 1 つ含む文が「245 文字」になる。実文書で max-sentence-length が指摘の
+ * 8 割を占めていた原因はこれで、読み手が長いと感じる長さではなかった。
+ *
+ * 日本語は文字数、英語は語数。単位は adapter が宣言する。
+ */
+export const proseText = (sentence: Sentence): string => sentence.text.replace(/\s+/gu, " ").trim();
+
+export const charLength = (sentence: Sentence): number => sentence.text.replace(/\s+/gu, "").length;
+
+export const wordLength = (sentence: Sentence): number =>
+  proseText(sentence)
+    .split(" ")
+    .filter((word) => word.length > 0).length;
+
+export const lengthOf = (sentence: Sentence, unit: "char" | "word"): number => (unit === "char" ? charLength(sentence) : wordLength(sentence));

package/src/plugin.ts

@@ -3,10 +3,25 @@
 
 export type Span = { readonly start: number; readonly end: number };
 
-export type Sentence = { readonly span: Span; readonly text: string };
+/**
+ * tokens は adapter が prepare 済みのときだけ入る。無いことと「品詞が無い文」を混ぜない。
+ * token の span は文の span と同じ座標系（segment に渡した文字列の先頭が 0）。
+ * 2 つの基準を混ぜると、ずれたときに どちらが悪いか分からなくなる。
+ */
+export type Sentence = { readonly span: Span; readonly text: string; readonly tokens?: readonly Token[] };
 
-/** 品詞は Universal Dependencies の UPOS に統一する。アダプタ独自の体系を露出させない。 */
-export type Token = { readonly span: Span; readonly surface: string; readonly pos: string; readonly lemma?: string };
+/**
+ * 品詞は Universal Dependencies の UPOS に統一する。アダプタ独自の体系を露出させない。
+ * features は UD の FEATS。「受動か」のように品詞だけでは足りず、かつ言語ごとに
+ * 見え方が違うものを、アダプタが自分の言語の知識で畳んでここに置く。例: Voice=Pass。
+ */
+export type Token = {
+  readonly span: Span;
+  readonly surface: string;
+  readonly pos: string;
+  readonly lemma?: string;
+  readonly features?: Readonly<Record<string, string>>;
+};
 
 export type Segmentation = {
   readonly sentences: readonly Sentence[];
@@ -33,6 +48,9 @@ export type AdapterCapabilities = {
   readonly lengthUnit: LengthUnit;
 };
 
+/** prepare に渡す要求。動く rule が要らないものの代金を払わせない。 */
+export type AdapterNeeds = { readonly pos: boolean };
+
 export type LanguageAdapter = {
   readonly kind: "language";
   /** BCP 47 の primary subtag。"ja" / "en"。 */
@@ -41,6 +59,11 @@ export type LanguageAdapter = {
   readonly capabilities: AdapterCapabilities;
   /** この言語である確からしさ。0..1。 */
   readonly detect: (source: string) => number;
+  /**
+   * 解析器の読み込み。capabilities は「払えばできる」の宣言で、prepare が「払う」。
+   * 日本語の辞書は初期化に 1.5 秒かかるので、要求されたときだけ呼ぶ。
+   */
+  readonly prepare?: (need: AdapterNeeds) => Promise<void>;
   readonly segment: (text: string) => Segmentation;
   /** L2 rule が word_list で引く。アダプタが自分の言語のぶんだけを持つ。 */
   readonly lexicons: Readonly<Record<string, Lexicon>>;
@@ -60,6 +83,11 @@ export type Section = {
   readonly firstSentence: Sentence | undefined;
 };
 
+export type Paragraph = { readonly span: Span; readonly sentences: readonly Sentence[] };
+
+/** 箇条書き 1 つ。項目は項目の文字数で持つ。長さのばらつきしか見ないため。 */
+export type BulletList = { readonly span: Span; readonly items: readonly number[] };
+
 /**
  * detector に渡る唯一の入り口。core が I/O を済ませてから呼ぶ。
  * detector は純関数で、fs / network / clock に触れない。spec §6。
@@ -69,8 +97,16 @@ export type ProseDocument = {
   readonly source: string;
   readonly language: string;
   readonly lengthUnit: LengthUnit;
+  /** rule の requires を突き合わせる先。満たさない rule は理由付きで skip する。 */
+  readonly capabilities: AdapterCapabilities;
   readonly sections: readonly Section[];
   readonly sentences: readonly Sentence[];
+  /** 箇条書きの範囲。体言止めのように、箇条書きでは普通で本文では困る形が見る。 */
+  readonly listSpans: readonly Span[];
+  /** 段落。文をいくつ載せているかと、長さのばらつきを見る rule が使う。 */
+  readonly paragraphs: readonly Paragraph[];
+  /** 箇条書き 1 つ。項目の数と長さのばらつきを見る rule が使う。 */
+  readonly lists: readonly BulletList[];
   /** アダプタが持つ語彙表。detector は言語を知らずにこれを引く。 */
   readonly lexicons: Readonly<Record<string, Lexicon>>;
 };
@@ -116,11 +152,17 @@ export type RuleDefinition = {
   /** 4 語と数値の対応。2 つ以上。未定義の段は normal に落ちる。spec §18.1。
    *  言語別の閾値を持つ rule（max-sentence-length）は、読み込み時に言語で平坦化済み。 */
   readonly levels: LevelTable;
+  /** ジャンル別の上書き。"business" は business/* 全部に効き、"business/email" が勝つ。spec §9。 */
+  readonly by_genre: Readonly<Record<string, LevelTable>>;
   readonly how_to_find: string;
   readonly word_list: string | undefined;
   /** L4 のみ。LLM に渡す決まり。言語別。 */
   readonly what_to_check: Localized | undefined;
   readonly where: string | undefined;
+  /** adapter に要る capability。"pos" / "lemma"。満たさなければ動かさない。spec §16。 */
+  readonly requires: readonly string[];
+  /** 動かす言語。未指定は全言語。「ですます調」のように言語に固有の rule が使う。 */
+  readonly languages: readonly string[] | undefined;
   readonly use_for: readonly string[];
   readonly severity: Severity;
 };

package/src/render/eval.ts

@@ -0,0 +1,62 @@
+import { MIN_CORPUS, TARGET_HIT_RATE, type RuleReport } from "../eval.ts";
+
+const pct = (part: number, whole: number): string => `${((part / Math.max(1, whole)) * 100).toFixed(1)}%`;
+
+const mark = (report: RuleReport, limit: number): string => {
+  if (limit === report.current && limit === report.recommended) return "  ← 現在 / 推奨";
+  if (limit === report.current) return "  ← 現在";
+  if (limit === report.recommended) return "  ← 推奨";
+  return "";
+};
+
+const sweepLines = (report: RuleReport): string[] =>
+  report.sweep.map((point) => {
+    const limit = String(point.limit).padStart(6);
+    const docs = `${String(point.documents).padStart(3)} 文書`;
+    const density = `1万字あたり ${point.per10k.toFixed(1)}`;
+    return `    ${limit}   ${docs} (${pct(point.documents, report.total).padStart(6)})   指摘 ${String(point.findings).padStart(3)} 件   ${density}${mark(report, point.limit)}`;
+  });
+
+const verdict = (report: RuleReport): string[] => {
+  const now = report.sweep.find((point) => point.limit === report.current);
+  const rate = now === undefined ? 0 : now.documents / Math.max(1, report.total);
+  if (rate <= TARGET_HIT_RATE) return [`    いまの閾値で目標（${TARGET_HIT_RATE * 100}% 未満）を満たしています。`];
+  if (report.recommended === undefined) {
+    return [`    どの閾値でも目標を満たしません。この corpus に対して rule 自体が合っていない可能性があります。`];
+  }
+  return [
+    `    いまの閾値では ${pct(now?.documents ?? 0, report.total)} の文書が該当し、目標（${TARGET_HIT_RATE * 100}% 未満）を超えています。`,
+    `    推奨: ${report.recommended}`,
+    "",
+    `    chaff.yaml に書くなら:  rules:\n                              ${report.rule}: ${report.recommended}`,
+  ];
+};
+
+const block = (report: RuleReport): string[] => ["", `  ${report.name}   (${report.rule})`, "", ...sweepLines(report), "", ...verdict(report), ""];
+
+/**
+ * 閾値は自動で書き換えない。提示して選ばせる。
+ * 較正は corpus に対する答えであって、正解ではないため。
+ */
+export const renderEval = (reports: readonly RuleReport[], total: number, paths: number): string =>
+  [
+    "",
+    `  ${paths} ファイルを corpus として ${reports.length} 本の rule を測りました。`,
+    "",
+    "  ここにある文書は「人間が書いて公開した良い文書」として扱っています。",
+    `  そこで多く発火する rule は、閾値が現実に合っていない疑いがあります（目標: ${TARGET_HIT_RATE * 100}% 未満）。`,
+    ...(total < MIN_CORPUS
+      ? [
+          "",
+          `  ※ corpus が ${total} 文書しかありません。${TARGET_HIT_RATE * 100}% を表すには ${MIN_CORPUS} 文書以上が要ります。`,
+          "     いまは割合が「0 か全部」に振れるので、右端の密度（1万字あたりの指摘数）のほうを見てください。",
+        ]
+      : []),
+    ...reports.flatMap(block),
+    "  " + "─".repeat(58),
+    "",
+    `  閾値は自動で書き換えていません。corpus が変われば答えも変わるためです。`,
+    "",
+  ]
+    .join("\n")
+    .replace(/\{total\}/gu, String(total));

package/src/render/explain.ts

@@ -2,14 +2,21 @@ import { definedLevels, resolve } from "../levels.ts";
 import { localized } from "./text.ts";
 import type { Level, RuleDefinition } from "../plugin.ts";
 
-const levelLine = (rule: RuleDefinition, level: Level, current: Level): string => {
+const levelLine = (rule: RuleDefinition, level: Level, current: Level, genre: string | undefined): string => {
   const mark = level === current ? "\u2192" : " ";
   const name = level.padEnd(9);
-  return level === "off" ? `  ${mark} ${name}見ない` : `  ${mark} ${name}${resolve(rule, level).limit}`;
+  return level === "off" ? `  ${mark} ${name}見ない` : `  ${mark} ${name}${resolve(rule, level, genre).limit}`;
+};
+
+/** ジャンルで数字が変わる rule は、それを言わないと「設定したのに効かない」に見える。 */
+const genreNote = (rule: RuleDefinition, genre: string | undefined): string[] => {
+  const others = Object.keys(rule.by_genre).filter((key) => key !== genre);
+  if (others.length === 0) return [];
+  return ["", `  この数字は ${genre ?? "既定"} のものです。ほかに ${others.join(" / ")} で別の数字を持っています。`];
 };
 
 /** rule の意図と根拠を読む。指摘に納得できないときの入口。 */
-export const renderExplain = (rule: RuleDefinition, current: Level, language: string, unit: string): string => {
+export const renderExplain = (rule: RuleDefinition, current: Level, language: string, unit: string, genre?: string): string => {
   const experimental = rule.status === "experimental" ? ["  このルールはまだ試験中で、既定では動きません（--experimental で動きます）。"] : [];
   return [
     "",
@@ -20,7 +27,8 @@ export const renderExplain = (rule: RuleDefinition, current: Level, language: st
     `  直しかた: ${localized(rule.how_to_fix, language)}`,
     "",
     `  設定できる値（単位: ${unit}）:`,
-    ...definedLevels(rule).map((level) => levelLine(rule, level, current)),
+    ...definedLevels(rule).map((level) => levelLine(rule, level, current, genre)),
+    ...genreNote(rule, genre),
     "",
     `  いまは ${current} です。`,
     ...experimental,

package/src/render/rules-json.ts

@@ -2,14 +2,25 @@ import { definedLevels, resolve } from "../levels.ts";
 import type { Config } from "../config/load.ts";
 import type { Level, RuleDefinition } from "../plugin.ts";
 
-const now = (rule: RuleDefinition, config: Config): Record<string, unknown> => {
+const now = (rule: RuleDefinition, config: Config, genre: string): Record<string, unknown> => {
   const explicit = config.rules[rule.id];
   if (explicit === "off") return { level: "off", why_off: "設定で止めている" };
-  if (explicit !== undefined) return { level: explicit, limit: resolve(rule, explicit).limit };
+  if (explicit !== undefined) return { level: explicit, limit: resolve(rule, explicit, genre).limit };
   if (rule.status === "experimental" && !config.experimental) {
     return { level: "off", why_off: "experimental な rule は既定で動かさない", turn_on_with: `npx chaff lint --experimental` };
   }
-  return { level: "normal", limit: resolve(rule, "normal").limit };
+  return { level: "normal", limit: resolve(rule, "normal", genre).limit };
+};
+
+/** ジャンルで数字が変わる rule があるので、いま効いている表と既定の表の両方を出す。 */
+const levelsOf = (rule: RuleDefinition, genre: string): Record<string, unknown> => {
+  const effective = Object.fromEntries(
+    definedLevels(rule)
+      .filter((level) => level !== "off")
+      .map((level) => [level, resolve(rule, level, genre).limit]),
+  );
+  const overridden = JSON.stringify(effective) !== JSON.stringify(rule.levels);
+  return overridden ? { levels: effective, levels_default: rule.levels, levels_from: "by_genre" } : { levels: rule.levels };
 };
 
 /** AI に設定を書かせるときの入口。推測せずに書けるだけの情報を 1 つに入れる。spec §19.3。 */
@@ -29,10 +40,10 @@ export const rulesJson = (rules: readonly RuleDefinition[], config: Config, lang
         why: rule.why,
         how_to_fix: rule.how_to_fix,
         use_for: rule.use_for,
-        levels: rule.levels,
+        ...levelsOf(rule, genre),
         levels_you_can_set: definedLevels(rule),
         your_setting: config.rules[rule.id] === undefined ? null : { level: config.rules[rule.id], from: config.path },
-        now: now(rule, config),
+        now: now(rule, config, genre),
       })),
       how_to_change: {
         by_command: ['npx chaff relax <rule-id> --why "<理由>"', 'npx chaff strict <rule-id> --why "<理由>"', 'npx chaff off <rule-id> --why "<理由>"'],

package/src/render/semantic.ts

@@ -1,6 +1,6 @@
 import type { Finding, RuleDefinition } from "../plugin.ts";
 import type { UserCheck } from "../checks.ts";
-import type { SemanticResult } from "../run-semantic.ts";
+import type { Job as Plan, SemanticResult } from "../run-semantic.ts";
 import { MARK, localized } from "./text.ts";
 
 const RULE = 60;
@@ -9,6 +9,19 @@ const indent = (text: string, pad: string): string[] => text.split("\n").map((li
 
 export const MACHINE_BANNER = ["", `═══ 機械による判定 ${"═".repeat(RULE - 18)}`, "    同じ文章なら何度実行しても同じ結果になります", ""];
 
+/**
+ * 自分の書いた検査が、どこまで絞り込めたかを見せる。
+ * 絞り込めないまま全文を読んでいることに気づけないと、遅さの原因が分からない。
+ */
+const narrowingLines = (result: SemanticResult): string[] =>
+  result.narrowed.flatMap(({ name, narrowing }) => {
+    if (narrowing.words.length === 0 && !narrowing.needsNumber) {
+      return [`    ${name}: 見るところを絞れず、全文を読みました`, `      look_at に「」で語を書くと、その語を含む文だけになります`];
+    }
+    const what = [...narrowing.words.map((word) => `「${word}」`), ...(narrowing.needsNumber ? ["数字"] : [])].join(" ");
+    return [`    ${name}: ${what} を含む ${narrowing.kept} 文だけを読みました（全 ${narrowing.total} 文）`];
+  });
+
 export const aiBanner = (result: SemanticResult): string[] => [
   "",
   `═══ AI による判定 ${"═".repeat(RULE - 17)}`,
@@ -16,6 +29,7 @@ export const aiBanner = (result: SemanticResult): string[] => [
   "    あります。おかしいと思ったら、そのまま無視して構いません。",
   "",
   `    ${result.sentencesSeen} 文のうち ${result.asked} 箇所を読みました（残りは機械が対象外と判断）`,
+  ...narrowingLines(result),
   "",
 ];
 
@@ -58,3 +72,26 @@ export const renderSemantic = (result: SemanticResult, rules: readonly RuleDefin
   ...result.findings.flatMap((finding) => block(finding, nameOf(finding.rule, rules, checks, language))),
   ...(result.skipped.length > 0 ? [`  ${result.skipped.length} 件の検査は、見るところが無いため動いていません。`, ""] : []),
 ];
+
+/**
+ * 何が送られるのかを、API を呼ばずに見せる。`chaff test --dry-run`。
+ *
+ * 鍵が無い環境でも二段構えの 1 段目まで確かめられる。全文が送られようとしていることに
+ * 請求書で気づくのでは遅い。spec §14。
+ */
+const howNarrowed = (job: Plan): string => {
+  const narrowing = job.narrowing;
+  if (narrowing === undefined) return "機械で絞り込み済み";
+  const quoted = narrowing.words.map((word) => `「${word}」`);
+  const parts = narrowing.needsNumber ? [...quoted, "数字"] : quoted;
+  if (parts.length === 0) return "絞り込めず全文";
+  return `${parts.join(" ")} を含む文`;
+};
+
+export const renderPlan = (path: string, jobs: readonly Plan[], sentences: number): string[] => {
+  const asked = jobs.reduce((sum, job) => sum + job.candidates.length, 0);
+  const lines = jobs.map((job) => `    ${String(job.candidates.length).padStart(3)} 箇所  ${job.name}  （${howNarrowed(job)}）`);
+  const first = jobs.find((job) => job.candidates.length > 0);
+  const sample = first === undefined ? [] : ["", "  最初の 1 件に送る文章:", "", ...indent(String(first.candidates[0]?.text ?? "").slice(0, 300), "    ")];
+  return ["", `${path}   全 ${sentences} 文のうち ${asked} 箇所を送ります（API は呼んでいません）`, "", ...lines, ...sample, ""];
+};

package/src/rule-load.ts

@@ -31,6 +31,16 @@ const flattenLevels = (raw: unknown, language: string): LevelTable | undefined =
   return isLevelTable(forLanguage) ? normalize(forLanguage) : undefined;
 };
 
+/** ジャンル別の上書きも、言語別の levels と同じ形で書ける。読めないものは黙って落とさず捨てる。 */
+const genreTables = (raw: unknown, language: string): Readonly<Record<string, LevelTable>> => {
+  if (!isRecord(raw)) return {};
+  const entries = Object.entries(raw).flatMap(([genre, table]) => {
+    const flattened = flattenLevels(table, language);
+    return flattened === undefined ? [] : [[genre, flattened] as const];
+  });
+  return Object.fromEntries(entries);
+};
+
 const SEVERITIES: readonly Severity[] = ["error", "warning", "info"];
 const isSeverity = (value: unknown): value is Severity => SEVERITIES.some((entry) => entry === value);
 
@@ -58,6 +68,8 @@ const missingFields = (raw: Record<string, unknown>, levels: LevelTable | undefi
 
 const localizedOf = (value: unknown): Record<string, string> => (isLocalized(value) ? value : {});
 
+const stringList = (value: unknown): string[] | undefined => (Array.isArray(value) ? value.map((entry) => String(entry)) : undefined);
+
 const toRule = (raw: unknown, language: string, file: string): RuleDefinition => {
   if (!isRecord(raw)) throw new Error(`${file}: rule は object であること`);
   const levels = flattenLevels(raw["levels"], language);
@@ -73,17 +85,32 @@ const toRule = (raw: unknown, language: string, file: string): RuleDefinition =>
     how_to_fix: localizedOf(raw["how_to_fix"]),
     message: localizedOf(raw["message"]),
     levels,
+    by_genre: genreTables(raw["by_genre"], language),
     how_to_find: String(raw["how_to_find"]),
     word_list: typeof raw["word_list"] === "string" ? raw["word_list"] : undefined,
     what_to_check: isLocalized(raw["what_to_check"]) ? raw["what_to_check"] : undefined,
     where: typeof raw["where"] === "string" ? raw["where"] : undefined,
+    requires: stringList(raw["requires"]) ?? [],
+    languages: stringList(raw["languages"]),
     use_for: Array.isArray(raw["use_for"]) ? raw["use_for"].map((entry) => String(entry)) : [],
     severity: isSeverity(raw["severity"]) ? raw["severity"] : "warning",
   };
 };
 
+/**
+ * 読めない rule ファイルは、どれが何で読めないかを言う。
+ * yaml の例外をそのまま投げると、スタックトレースだけが出てファイル名が出ない。
+ */
+const parseRule = (dir: string, file: string): unknown => {
+  try {
+    return parse(readFileSync(join(dir, file), "utf8"));
+  } catch (error) {
+    throw new Error(`${file} を読めません: ${error instanceof Error ? error.message.split("\n")[0] : String(error)}`, { cause: error });
+  }
+};
+
 export const loadRules = (language: string, dir: string = RULES_DIR): RuleDefinition[] =>
   readdirSync(dir)
     .filter((file) => file.endsWith(".yaml"))
     .sort((left, right) => left.localeCompare(right, "en"))
-    .map((file) => toRule(parse(readFileSync(join(dir, file), "utf8")), language, file));
+    .map((file) => toRule(parseRule(dir, file), language, file));