chaffjs 0.2.0 → 0.3.0

package/src/detectors/structure.ts

@@ -0,0 +1,119 @@
+import { charLength, lengthOf } from "../measure.ts";
+import type { BulletList, Detector, Finding, Paragraph, ProseDocument, Section } from "../plugin.ts";
+
+/**
+ * ばらつきは変動係数（標準偏差 ÷ 平均）で測る。
+ *
+ * 標準偏差そのものを見ると、長い文書ほど大きくなって閾値が効かない。
+ * 平均で割ると長さに依らなくなり、「揃いすぎ」と「ばらつきすぎ」を同じ尺度で言える。
+ */
+export const coefficientOfVariation = (values: readonly number[]): number | undefined => {
+  if (values.length < 2) return undefined;
+  const mean = values.reduce((sum, value) => sum + value, 0) / values.length;
+  if (mean === 0) return undefined;
+  const variance = values.reduce((sum, value) => sum + (value - mean) ** 2, 0) / values.length;
+  return Math.sqrt(variance) / mean;
+};
+
+/** 変動係数は 0..1 では読めないので、パーセントの整数にして閾値と突き合わせる。 */
+const PERCENT = 100;
+
+const asPercent = (value: number): number => Math.round(value * PERCENT);
+
+const uniformity = (doc: ProseDocument, values: readonly number[], span: { start: number }, limit: number, rule: string): Finding[] => {
+  const cv = coefficientOfVariation(values);
+  if (cv === undefined || asPercent(cv) >= limit) return [];
+  return [
+    {
+      rule,
+      severity: "info",
+      line: 0,
+      column: 0,
+      quote: doc.source.slice(span.start, span.start + 80).trim(),
+      values: { count: values.length, variance: asPercent(cv), limit, offset: span.start },
+    },
+  ];
+};
+
+/** 1 段落に文を詰めすぎると、読み手はどこで息継ぎしていいか分からなくなる。 */
+export const paragraphLength: Detector = (doc, options): Finding[] =>
+  doc.paragraphs
+    .filter((paragraph) => paragraph.sentences.length > options.limit)
+    .map((paragraph) => ({
+      rule: "max-paragraph-length",
+      severity: "warning",
+      line: 0,
+      column: 0,
+      quote: doc.source.slice(paragraph.span.start, paragraph.span.start + 80).trim(),
+      values: { count: paragraph.sentences.length, limit: options.limit, offset: paragraph.span.start },
+    }));
+
+const charsOf = (paragraph: Paragraph): number => paragraph.sentences.reduce((sum, sentence) => sum + charLength(sentence), 0);
+
+/** 段落の長さが揃いすぎている。人が書くと、言いたいことの重さで段落の長さは揺れる。 */
+export const paragraphVariance: Detector = (doc, options): Finding[] => {
+  const lengths = doc.paragraphs.map(charsOf).filter((length) => length > 0);
+  const first = doc.paragraphs[0];
+  return first === undefined ? [] : uniformity(doc, lengths, first.span, options.limit, "paragraph-length-variance");
+};
+
+const sectionChars = (section: Section): number => section.sentences.reduce((sum, sentence) => sum + charLength(sentence), 0);
+
+/** 節の長さが揃いすぎている。見出しごとに機械的に埋めた文書で起きる。 */
+export const sectionUniformity: Detector = (doc, options): Finding[] => {
+  const lengths = doc.sections.map(sectionChars).filter((length) => length > 0);
+  const first = doc.sections[0];
+  return first === undefined ? [] : uniformity(doc, lengths, first.span, options.limit, "section-length-uniformity");
+};
+
+/**
+ * 3 項目の箇条書きばかりになっている。
+ * 3 つ並べると収まりがよいので、言いたいことが 2 つでも 4 つでも 3 つにされる。
+ */
+const isThree = (list: BulletList): boolean => list.items.length === 3;
+
+export const ruleOfThree: Detector = (doc, options): Finding[] => {
+  const lists = doc.lists;
+  const threes = lists.filter(isThree);
+  const share = lists.length === 0 ? 0 : Math.round((threes.length / lists.length) * PERCENT);
+  const first = threes[0];
+  if (lists.length < 3 || first === undefined || share <= options.limit) return [];
+  return [
+    {
+      rule: "rule-of-three",
+      severity: "info",
+      line: 0,
+      column: 0,
+      quote: doc.source.slice(first.span.start, first.span.start + 80).trim(),
+      values: { count: threes.length, total: lists.length, share, limit: options.limit, offset: first.span.start },
+    },
+  ];
+};
+
+/**
+ * 本題に入るまでが長い。業務文書では、読み手は結論を探しに来ている。
+ *
+ * 「本題」は最初の中見出し（深さ 2 以上）とする。表題（深さ 1）の直後から数えると、
+ * 表題しか無い文書で全文が前置きになる。中見出しが無い文書では何も言わない。
+ */
+export const preambleLength: Detector = (doc, options): Finding[] => {
+  const body = doc.sections.find((section) => section.depth >= 2);
+  if (body === undefined) return [];
+  const before = doc.paragraphs.filter((paragraph) => paragraph.span.start < body.span.start);
+  if (before.length <= options.limit) return [];
+  const first = before[0];
+  return first === undefined
+    ? []
+    : [
+        {
+          rule: "preamble-length",
+          severity: "info",
+          line: 0,
+          column: 0,
+          quote: doc.source.slice(first.span.start, first.span.start + 80).trim(),
+          values: { count: before.length, limit: options.limit, offset: first.span.start },
+        },
+      ];
+};
+
+export const wordsOf = (doc: ProseDocument): number => doc.sentences.reduce((sum, sentence) => sum + lengthOf(sentence, doc.lengthUnit), 0);

package/src/detectors/token-shape.ts

@@ -0,0 +1,81 @@
+import { hasParticle, isClosed, lastContent } from "../sentence-shape.ts";
+import type { Detector, Finding, Span, Token } from "../plugin.ts";
+
+/**
+ * 文末が名詞で終わる（体言止め）。箇条書きでは普通だが、本文では文が途中で切れて読める。
+ * 実文書で測ったら、指摘の 9 割が箇条書きの項目だった。箇条書きは除く。
+ */
+const NOMINAL = new Set(["NOUN", "PROPN"]);
+
+/** 非自立名詞は単独では何も指さない。「回るのか。」の「の」を体言止めと読まない。 */
+const isDependent = (token: Token): boolean => token.features?.["NounType"] === "Dependent";
+
+const inside = (span: Span, spans: readonly Span[]): boolean => spans.some((other) => span.start >= other.start && span.start < other.end);
+
+export const nounEnding: Detector = (doc, options): Finding[] => {
+  const ended = doc.sentences.filter((sentence) => {
+    if (inside(sentence.span, doc.listSpans) || !isClosed(sentence) || !hasParticle(sentence)) return false;
+    const last = lastContent(sentence);
+    return last !== undefined && NOMINAL.has(last.pos) && !isDependent(last);
+  });
+  const first = ended[0];
+  // 文書全体の数についての指摘なので、1 文ずつ出さない。13 件並べても直す順番が分からない。
+  if (first === undefined || ended.length <= options.limit) return [];
+  return [
+    {
+      rule: "taigen-dome-in-prose",
+      severity: "info",
+      line: 0,
+      column: 0,
+      quote: first.text.trim(),
+      values: { count: ended.length, limit: options.limit, offset: first.span.start },
+    },
+  ];
+};
+
+/**
+ * 名詞を名詞に繋ぐ助詞が続けて出る。「弊社の新製品の販売の計画」は係りかたが読めなくなる典型。
+ *
+ * 見るのは語彙表にある助詞だけ。助詞一般を数えると、「A も B も C も」の並列と
+ * 「コピーして持っていって」の連用が当たる。どちらも何重に続いても読めるので rule が合わない。
+ *
+ * 数えるのは**節の中**だけ。読点で切らないと「サービスの運営や、ドキュメントの作成」のような
+ * 並列まで 1 つの連なりとして数える。並列は必ず読点で区切られる。
+ */
+type Run = { readonly surface: string; readonly tokens: readonly Token[] };
+
+const extend = (runs: readonly 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] }];
+};
+
+const PARTICLE = new Set(["ADP", "SCONJ", "PART", "CCONJ"]);
+
+const BREAK: Run = { surface: "", tokens: [] };
+
+/**
+ * 名詞は連なりの中身なので飛ばす。読点と、語彙表に無い助詞は連なりを切る。
+ * 「弊社のAはBの」を 2 回続いたと数えないため。「は」でいちど句が閉じている。
+ */
+const runsOf = (tokens: readonly Token[], nesting: readonly string[]): Run[] =>
+  tokens.reduce<Run[]>((acc, token) => {
+    if (nesting.includes(token.surface)) return extend(acc, token);
+    return token.pos === "PUNCT" || PARTICLE.has(token.pos) ? [...acc, BREAK] : acc;
+  }, []);
+
+export const doubledParticle: Detector = (doc, options): Finding[] => {
+  const nesting = (options.lexicon ?? []).map((entry) => entry.pattern);
+  return doc.sentences.flatMap((sentence) =>
+    runsOf(sentence.tokens ?? [], nesting)
+      .filter((run) => run.tokens.length > options.limit)
+      .map((run) => ({
+        rule: "no-doubled-joshi",
+        severity: "warning" as const,
+        line: 0,
+        column: 0,
+        quote: sentence.text.trim(),
+        values: { word: run.surface, count: run.tokens.length, limit: options.limit, offset: run.tokens[0]?.span.start ?? sentence.span.start },
+      })),
+  );
+};

package/src/document.ts

@@ -4,7 +4,7 @@ import { gfmTableFromMarkdown } from "mdast-util-gfm-table";
 import { frontmatter } from "micromark-extension-frontmatter";
 import { frontmatterFromMarkdown } from "mdast-util-frontmatter";
 import { maskSpans } from "./mask.ts";
-import type { LanguageAdapter, ProseDocument, Section, Sentence, Span } from "./plugin.ts";
+import type { BulletList, LanguageAdapter, Paragraph, ProseDocument, Section, Sentence, Span } from "./plugin.ts";
 
 type Place = { readonly offset?: number | undefined };
 type Node = {
@@ -49,8 +49,37 @@ const linkChrome = (node: Node): Span[] => {
   ];
 };
 
-const collectMasks = (root: Node): Span[] => {
-  const spans: Span[] = [];
+/**
+ * 強調の記号（`**` `*` `_` `~~`）だけを覆う。囲まれた文字は本文なので残す。
+ *
+ * 残すと解析器が `**。` を 1 語の名詞として拾い、文の終わりが消える。
+ * 実文書で「文末が名詞」の誤検知を追って見つけた。文長にも同じだけ効いている。
+ */
+const MARKER = /^[*_~]+/u;
+
+const emphasisChrome = (node: Node, source: string): Span[] => {
+  const whole = spanOf(node);
+  if (whole === undefined) return [];
+  const width = MARKER.exec(source.slice(whole.start, whole.end))?.[0].length ?? 0;
+  if (width === 0) return [];
+  return [
+    { start: whole.start, end: whole.start + width },
+    { start: whole.end - width, end: whole.end },
+  ];
+};
+
+const EMPHASIS = new Set(["strong", "emphasis", "delete"]);
+
+/**
+ * `:::note` `:::` のようなディレクティブ。Zenn・Docusaurus・VitePress が使う記法で、
+ * 標準の Markdown には無いため段落として解析される。囲みの指定であって文章ではない。
+ */
+const DIRECTIVE = /^:::[^\n]*/gmu;
+
+const directiveSpans = (source: string): Span[] => [...source.matchAll(DIRECTIVE)].map((match) => ({ start: match.index, end: match.index + match[0].length }));
+
+const collectMasks = (root: Node, source: string): Span[] => {
+  const spans: Span[] = [...directiveSpans(source)];
   walk(root, (node) => {
     if (node.type === "link" || node.type === "linkReference") {
       spans.push(...linkChrome(node));
@@ -63,6 +92,14 @@ const collectMasks = (root: Node): Span[] => {
   return spans;
 };
 
+const emphasisSpans = (root: Node, source: string): Span[] => {
+  const spans: Span[] = [];
+  walk(root, (node) => {
+    if (EMPHASIS.has(node.type)) spans.push(...emphasisChrome(node, source));
+  });
+  return spans;
+};
+
 const textOf = (node: Node, source: string): string => {
   const parts: string[] = [];
   walk(node, (child) => {
@@ -107,10 +144,10 @@ const strongSpans = (root: Node, masked: readonly Span[]): Span[] => {
 
 const within = (span: Span, from: number, to: number): boolean => span.start >= from && span.start < to;
 
-const paragraphSpans = (root: Node): Span[] => {
+const spansOfType = (root: Node, type: string): Span[] => {
   const found: Span[] = [];
   walk(root, (node) => {
-    if (node.type !== "paragraph") return;
+    if (node.type !== type) return;
     const span = spanOf(node);
     if (span !== undefined) found.push(span);
   });
@@ -124,14 +161,17 @@ const paragraphSpans = (root: Node): Span[] => {
  * 覆った表やコードブロックを越えて次の句点まで飲み込む。段落は文が跨がない境界なので、
  * ここで切れば構造的に起きない。
  */
+const shift = (span: Span, by: number): Span => ({ start: by + span.start, end: by + span.end });
+
 const sentencesOf = (prose: string, paragraphs: readonly Span[], adapter: LanguageAdapter): Sentence[] =>
   paragraphs.flatMap((paragraph) =>
     adapter
       .segment(prose.slice(paragraph.start, paragraph.end))
       .sentences.filter((sentence) => sentence.text.trim().length > 0)
       .map((sentence) => ({
-        span: { start: paragraph.start + sentence.span.start, end: paragraph.start + sentence.span.end },
+        span: shift(sentence.span, paragraph.start),
         text: sentence.text,
+        ...(sentence.tokens === undefined ? {} : { tokens: sentence.tokens.map((token) => ({ ...token, span: shift(token.span, paragraph.start) })) }),
       })),
   );
 
@@ -153,18 +193,50 @@ const sectionsOf = (headings: readonly Heading[], sentences: readonly Sentence[]
     });
 };
 
+const paragraphsOf = (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)) }));
+
+/** 箇条書きは list ノードの直下の項目を数える。入れ子の項目は内側の list のものとして数える。 */
+const listsOf = (root: Node, source: string): BulletList[] => {
+  const found: BulletList[] = [];
+  walk(root, (node) => {
+    if (node.type !== "list") return;
+    const span = spanOf(node);
+    if (span === undefined) return;
+    const items = (node.children ?? []).flatMap((child) => {
+      const item = spanOf(child);
+      return child.type === "listItem" && item !== undefined ? [source.slice(item.start, item.end).replace(/\s+/gu, "").length] : [];
+    });
+    if (items.length > 0) found.push({ span, items });
+  });
+  return found;
+};
+
 export const buildDocument = (path: string, source: string, adapter: LanguageAdapter): ProseDocument => {
   const root = parse(source);
-  const masked = collectMasks(root);
+  // 強調の記号は「本文でないもの」だが、太字の数を数えるときの「覆われた場所」ではない。
+  // 同じ集合にすると、太字が自分の記号のせいで覆われた場所にあることになり、1 つも数えられなくなる。
+  const blocks = collectMasks(root, source);
+  const masked = [...blocks, ...emphasisSpans(root, source)];
   const prose = maskSpans(source, masked);
-  const sentences = sentencesOf(prose, paragraphSpans(root), adapter);
+  const paragraphSpans = spansOfType(root, "paragraph");
+  const listItems = spansOfType(root, "listItem");
+  const sentences = sentencesOf(prose, paragraphSpans, adapter);
   return {
     path,
     source,
     language: adapter.id,
     lengthUnit: adapter.capabilities.lengthUnit,
-    sections: sectionsOf(headingsOf(root, source), sentences, strongSpans(root, masked), source.length),
+    capabilities: adapter.capabilities,
+    sections: sectionsOf(headingsOf(root, source), sentences, strongSpans(root, blocks), source.length),
     sentences,
+    listSpans: listItems,
+    paragraphs: paragraphsOf(paragraphSpans, sentences, listItems),
+    lists: listsOf(root, source),
     lexicons: adapter.lexicons,
   };
 };

package/src/env.ts

@@ -0,0 +1,20 @@
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+
+export const ENV_FILE = ".env";
+
+/**
+ * 作業ディレクトリの .env を読む。依存は足さない（Node が持っている）。
+ *
+ * **すでに設定されている環境変数は上書きしない。** シェルで渡したほうが勝つ。
+ * 逆にすると、一時的に別の key で試したいときに .env が黙って勝ってしまう。
+ *
+ * 読んだかどうかを返すのは、鍵がどこから来たのかを人に見せるため。
+ * 「設定したのに効かない」を、鍵の置き場所で起こさせない。
+ */
+export const loadEnvFile = (dir: string): string | undefined => {
+  const path = join(dir, ENV_FILE);
+  if (!existsSync(path)) return undefined;
+  process.loadEnvFile(path);
+  return path;
+};

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[] => {

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/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/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,