chaffjs 0.3.0 → 0.5.0

package/src/cli.ts

@@ -1,11 +1,11 @@
 import { readFile } from "node:fs/promises";
-import { existsSync } from "node:fs";
-import { join } from "node:path";
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
 import { loadAdapter, packageFor } from "./adapter-load.ts";
 import { CONFIG_FILE, EMPTY, loadConfig, type Config } from "./config/load.ts";
 import { applyByPath } from "./config/by-path.ts";
 import { applyLevel } from "./config/write.ts";
-import { buildDocument } from "./document.ts";
+import { buildDocument, teamRules } from "./document.ts";
 import { guessLanguage } from "./detect.ts";
 import { collectTargets } from "./files.ts";
 import { BASELINE_FILE, fingerprint, readBaseline, splitByBaseline, writeBaseline } from "./baseline.ts";
@@ -21,6 +21,8 @@ import { renderCompact } from "./render/compact.ts";
 import { renderExplain } from "./render/explain.ts";
 import { renderFriendly } from "./render/friendly.ts";
 import { rulesJson } from "./render/rules-json.ts";
+import { renderSarif } from "./render/sarif.ts";
+import { VERSION } from "./version.ts";
 import { renderSummary, type FileOutcome } from "./render/summary.ts";
 import { neededBy, runRules } from "./run.ts";
 import type { Level, RuleDefinition } from "./plugin.ts";
@@ -45,6 +47,7 @@ const USAGE = `chaff — 文章の読みにくいところを見つけます。
   --show-baseline   棚上げした分も含めて全部見る
   --watch           保存のたびに見直し、変わったところだけ出す
   --dry-run         test で、何を AI に送るかだけを見る（API を呼びません）
+  --sarif <path>    指摘を SARIF で書き出す（GitHub の PR の行に出すため）
 
 この箇所だけ黙らせる:  <!-- stet: rule-id — 理由 -->
 
@@ -81,7 +84,15 @@ const flag = (argv: readonly string[], name: string): string | undefined => {
   return at === -1 ? undefined : argv[at + 1];
 };
 
-type Inspected = { readonly text: string; readonly outcome: FileOutcome; readonly perFile: PerFile; readonly all: readonly string[] };
+type Inspected = {
+  readonly text: string;
+  readonly rules: readonly RuleDefinition[];
+  /** ファイルごとの言語。by_path で 1 つの repo に 2 言語が混ざる。 */
+  readonly language: string;
+  readonly outcome: FileOutcome;
+  readonly perFile: PerFile;
+  readonly all: readonly string[];
+};
 
 const headerFor = (path: string, genre: string, from: string, language: string, shelved: number, hushed: number): string => {
   const shelf = shelved > 0 ? `   棚上げ ${shelved} 件` : "";
@@ -97,7 +108,7 @@ const inspect = async (path: string, config: Config, argv: readonly string[]): P
   const rules = loadRules(language);
   const experimental = config.experimental || argv.includes("--experimental");
   await adapter.prepare?.(neededBy(rules, config.rules, experimental, genre, language));
-  const doc = buildDocument(path, source, adapter);
+  const doc = buildDocument(path, source, adapter, teamRules(config));
   const raw = runRules(doc, rules, config.rules, experimental, genre);
   // 応答は 3 つ。stet で黙らせたものは、ここで落とす。
   const applied = applySuppressions(
@@ -112,12 +123,30 @@ const inspect = async (path: string, config: Config, argv: readonly string[]): P
   const text = argv.includes("--compact") ? renderCompact(header, result, rules, language) : renderFriendly(header, result, rules, language);
   return {
     text,
+    rules,
+    language,
     outcome: { path, findings: split.fresh, notRun: raw.skipped.length },
     perFile: { path, suppressed: applied.suppressed, reasonless: applied.unusedReasonless },
     all: applied.kept.map((finding) => fingerprint(path, finding)),
   };
 };
 
+/**
+ * 指摘を PR の変更行に出すための出口。--sarif <path> を書いたときだけ作る。
+ * 端末の出力は変えない。CI で上げるためのファイルが増えるだけ。
+ */
+const writeSarif = (results: readonly Inspected[], argv: readonly string[]): void => {
+  const path = flag(argv, "--sarif");
+  if (path === undefined) return;
+  // 文言はファイルの言語で描く。by_path で 1 つの repo に 2 言語が混ざるため。
+  const located = results.flatMap((result) =>
+    result.outcome.findings.map((finding) => ({ path: result.outcome.path, finding, language: result.language, rules: result.rules })),
+  );
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, renderSarif(located, VERSION), "utf8");
+  console.log(`\n  SARIF を書きました: ${path}（${located.length} 件）`);
+};
+
 const lint = async (targets: readonly string[], argv: readonly string[]): Promise<number> => {
   const paths = collectTargets(targets);
   if (paths.length === 0) {
@@ -132,6 +161,7 @@ const lint = async (targets: readonly string[], argv: readonly string[]): Promis
     return 1;
   }
   const results = await Promise.all(paths.map((path) => inspect(path, config, argv)));
+  writeSarif(results, argv);
   results.filter((result) => result.outcome.findings.length > 0 || paths.length === 1).forEach((result) => console.log(result.text));
   renderSummary(results.map((result) => result.outcome)).forEach((line) => console.log(line));
   return results.some((result) => result.outcome.findings.some((finding) => finding.severity === "error")) ? 1 : 0;

package/src/commands/eval.ts

@@ -1,7 +1,7 @@
 import { readFile } from "node:fs/promises";
 import { loadAdapter } from "../adapter-load.ts";
 import { applyByPath } from "../config/by-path.ts";
-import { buildDocument } from "../document.ts";
+import { buildDocument, teamRules } from "../document.ts";
 import { guessLanguage } from "../detect.ts";
 import { collectTargets } from "../files.ts";
 import { loadRules } from "../rule-load.ts";
@@ -35,7 +35,7 @@ export const runEval = async (targets: readonly string[], argv: readonly string[
       const adapter = await loadAdapter(language);
       const { genre } = resolveGenre(path, source, config);
       await adapter.prepare?.(neededBy(loadRules(language), config.rules, config.experimental, genre, language));
-      return { doc: buildDocument(path, source, adapter), language, genre };
+      return { doc: buildDocument(path, source, adapter, teamRules(config)), language, genre };
     }),
   );
   const language = docs[0]?.language ?? "ja";

package/src/commands/test.ts

@@ -2,7 +2,7 @@ import { readFile } from "node:fs/promises";
 import { join } from "node:path";
 import { loadAdapter } from "../adapter-load.ts";
 import { applyByPath } from "../config/by-path.ts";
-import { buildDocument } from "../document.ts";
+import { buildDocument, teamRules } from "../document.ts";
 import { guessLanguage } from "../detect.ts";
 import { collectTargets } from "../files.ts";
 import { loadRules } from "../rule-load.ts";
@@ -35,7 +35,7 @@ const judgeAll = async (
       const source = await readFile(path, "utf8");
       const language = applyByPath(config.byPath, config.baseDir, path).language ?? config.language ?? guessLanguage(source).language;
       const adapter = await loadAdapter(language);
-      const doc = buildDocument(path, source, adapter);
+      const doc = buildDocument(path, source, adapter, teamRules(config));
       const { genre } = resolveGenre(path, source, config);
       const rules = loadRules(language);
       return { path, outcome: await runSemantic(doc, rules, checks, config.rules, genre, options), rules, language };
@@ -55,7 +55,7 @@ const dryRun = async (
       const source = await readFile(path, "utf8");
       const language = applyByPath(config.byPath, config.baseDir, path).language ?? config.language ?? guessLanguage(source).language;
       const adapter = await loadAdapter(language);
-      const doc = buildDocument(path, source, adapter);
+      const doc = buildDocument(path, source, adapter, teamRules(config));
       const { genre } = resolveGenre(path, source, config);
       return { path, jobs: planSemantic(doc, loadRules(language), checks, config.rules, genre), sentences: doc.sentences.length };
     }),

package/src/config/load.ts

@@ -18,6 +18,10 @@ export type Config = {
   readonly path: string | undefined;
   readonly aiModel: string;
   readonly confidenceThreshold: number;
+  /** チームの言葉。社内でしか通じない語を、チームが自分で並べる。 */
+  readonly jargon: readonly string[];
+  /** この種類の文書に無いと困る見出し。チームが自分で決める。 */
+  readonly requiredSections: readonly string[];
   /** パスごとの上書き。設定ファイルのある場所からの相対で照合する。 */
   readonly byPath: readonly PathRule[];
   readonly baseDir: string;
@@ -25,7 +29,7 @@ export type Config = {
 
 /** 判定の質が誤検知に直結するので、既定は最上位のモデル。cost は絞り込みで削る。spec §14。 */
 /** 既定は Anthropic。openai にすると判定役だけが替わり、rule も判定の形も変わらない。 */
-export const DEFAULT_BACKEND: BackendName = "anthropic";
+const DEFAULT_BACKEND: BackendName = "anthropic";
 
 export const EMPTY: Config = {
   genre: undefined,
@@ -36,6 +40,8 @@ export const EMPTY: Config = {
   aiBackend: DEFAULT_BACKEND,
   aiModel: defaultModel(DEFAULT_BACKEND),
   confidenceThreshold: 0.7,
+  jargon: [],
+  requiredSections: [],
   byPath: [],
   baseDir: process.cwd(),
 };
@@ -63,6 +69,9 @@ const toPathRule = (raw: unknown): PathRule | undefined => {
   return { files: globs, genre: str(raw["genre"]), language: str(raw["language"]) };
 };
 
+/** 利用者が書く語の並び。空白だけのものは落とす。 */
+const wordsOf = (raw: unknown): string[] => (Array.isArray(raw) ? raw.map((entry) => String(entry).trim()).filter((entry) => entry.length > 0) : []);
+
 const byPathOf = (raw: unknown): PathRule[] => (Array.isArray(raw) ? raw.map(toPathRule).filter((rule) => rule !== undefined) : []);
 
 /** 設定ファイルが無くても動く。あっても、既定から変えたものだけが書かれている。spec §18。 */
@@ -80,6 +89,8 @@ export const loadConfig = (path: string): Config => {
     aiBackend: backend,
     aiModel: str(raw["ai_model"]) ?? defaultModel(backend),
     confidenceThreshold: typeof raw["confidence_threshold"] === "number" ? raw["confidence_threshold"] : 0.7,
+    jargon: wordsOf(raw["jargon"]),
+    requiredSections: wordsOf(raw["required_sections"]),
     byPath: byPathOf(raw["by_path"]),
     baseDir: dirname(path),
   };

package/src/detectors/en-shape.ts

@@ -134,7 +134,8 @@ export const titleCaseMix: Detector = (doc, options): Finding[] => {
   const title = judged.filter((entry) => entry.title).length;
   const minorityIsTitle = title <= judged.length - title;
   const few = minorityIsTitle ? title : judged.length - title;
-  if (few === 0 || few > options.limit) return [];
+  // 同数なら少数派は無い。どちらかを「他と違う」と呼ぶのは、選びかたが恣意的になる。
+  if (few === 0 || few * 2 === judged.length || few > options.limit) return [];
   return judged
     .filter((entry) => entry.title === minorityIsTitle)
     .map(({ section }) => ({
@@ -173,7 +174,8 @@ export const oxfordComma: Detector = (doc, options): Finding[] => {
   const withComma = judged.filter((entry) => entry.oxford).length;
   const minorityUsesComma = withComma <= judged.length - withComma;
   const few = minorityUsesComma ? withComma : judged.length - withComma;
-  if (few === 0 || few > options.limit) return [];
+  // 同数なら少数派は無い。
+  if (few === 0 || few * 2 === judged.length || few > options.limit) return [];
   return judged
     .filter((entry) => entry.oxford === minorityUsesComma)
     .map(({ sentence }) => ({

package/src/detectors/heading-echo.ts

@@ -1,4 +1,5 @@
-import type { Detector, Finding } from "../plugin.ts";
+import { lengthOf } from "../measure.ts";
+import type { Detector, Finding, LengthUnit, Section } from "../plugin.ts";
 
 /** 見出しが短すぎると、偶然の一致で 100% になる。これ未満の見出しは見ない。 */
 const MIN_GRAMS = 4;
@@ -8,7 +9,9 @@ const MIN_GRAMS = 4;
  * 語 n-gram にすると wordSplit capability が要り、L1（言語を問わず動く）から外れる。
  */
 const trigrams = (text: string): Set<string> => {
-  const clean = [...text.replace(/\s+/gu, "")];
+  // 大文字小文字を畳む。英語では見出しが Title Case、本文が小文字になり、
+  // 同じ語でも一致しなくなる（Generating Output → generated output）。
+  const clean = [...text.toLowerCase().replace(/\s+/gu, "")];
   return new Set(clean.slice(0, Math.max(0, clean.length - 2)).map((__char, index) => clean.slice(index, index + 3).join("")));
 };
 
@@ -25,9 +28,32 @@ const containment = (heading: Set<string>, sentence: Set<string>): number => {
   return [...heading].filter((gram) => sentence.has(gram)).length / heading.size;
 };
 
+/**
+ * 見出しの語を含んでいても、文がそのぶん以上に中身を足していれば「何も受け取れない」ではない。
+ *
+ * 実文書（英語 11 本）で測ったら、この条件なしでは 72.7% の文書が該当した。
+ * 「## ToolsAgent」に対する「GraphAI provides ToolsAgent components that use LLMs to…」は
+ * 見出しの語を含むが、読み進める価値がある。見出し以外の中身の量で分ける。
+ */
+const NEW_MATERIAL = { word: 6, char: 20 };
+
+const headingUnits = (heading: string, unit: LengthUnit): number =>
+  unit === "word"
+    ? heading
+        .trim()
+        .split(/\s+/u)
+        .filter((word) => word.length > 0).length
+    : heading.replace(/\s+/gu, "").length;
+
+const addsLittle = (section: Section, unit: LengthUnit): boolean => {
+  const first = section.firstSentence;
+  if (first === undefined) return false;
+  return lengthOf(first, unit) - headingUnits(section.heading, unit) <= NEW_MATERIAL[unit];
+};
+
 export const headingEcho: Detector = (doc, options): Finding[] =>
   doc.sections
-    .filter((section) => section.heading.length > 0 && section.firstSentence !== undefined)
+    .filter((section) => section.heading.length > 0 && section.firstSentence !== undefined && addsLittle(section, doc.lengthUnit))
     .map((section) => ({ section, overlap: Math.round(containment(trigrams(section.heading), trigrams(section.firstSentence?.text ?? "")) * 100) }))
     .filter(({ overlap }) => overlap >= options.limit)
     .map(({ section, overlap }) => ({

package/src/detectors/index.ts

@@ -11,8 +11,9 @@ import { doubledParticle, nounEnding } from "./token-shape.ts";
 import { kanjiRun, middleDot } from "./char-shape.ts";
 import { adverbDensity, conjunctionRun, expletive, oxfordComma, titleCaseMix } from "./en-shape.ts";
 import { paragraphLength, paragraphVariance, preambleLength, ruleOfThree, sectionUniformity } from "./structure.ts";
-import { concreteEvidence, emojiDensity, ngramRepetition, undefinedAcronym } from "./signals.ts";
-import { aiTell, cushionDensity, hedgingDensity, repeatedConjunction, unqualifiedSuperlative } from "./lexicon.ts";
+import { concreteEvidence, dashDensity, emojiDensity, ngramRepetition, undefinedAcronym } from "./signals.ts";
+import { aiTell, contractionMix, cushionDensity, hedgingDensity, repeatedConjunction, unqualifiedSuperlative } from "./lexicon.ts";
+import { internalJargon, properNounDensity, requiredSections } from "./team.ts";
 
 /** rule 定義の how_to_find がここを引く。rule 側は実装を知らない。 */
 export const DETECTORS: Readonly<Record<string, Detector>> = {
@@ -39,6 +40,7 @@ export const DETECTORS: Readonly<Record<string, Detector>> = {
   "rule-of-three": ruleOfThree,
   "preamble-length": preambleLength,
   "emoji-density": emojiDensity,
+  "dash-density": dashDensity,
   "ngram-repetition": ngramRepetition,
   "undefined-acronym": undefinedAcronym,
   "concrete-evidence": concreteEvidence,
@@ -47,4 +49,8 @@ export const DETECTORS: Readonly<Record<string, Detector>> = {
   "unqualified-superlative": unqualifiedSuperlative,
   "repeated-conjunction": repeatedConjunction,
   "ai-tell": aiTell,
+  "contraction-mix": contractionMix,
+  "internal-jargon": internalJargon,
+  "required-sections": requiredSections,
+  "proper-noun-density": properNounDensity,
 };

package/src/detectors/lexicon.ts

@@ -122,3 +122,44 @@ export const aiTell: Detector = (doc, options): Finding[] => {
     },
   ];
 };
+
+/**
+ * 同じことを言う 2 つの書きかたが、1 つの文書で混ざっているか。
+ *
+ * **どちらが正しいかは決めない。** 短縮形を使うかどうかは文体の選択で、
+ * 立場を取ると方針の違う書き手に rule ごと無視される。spec §12.3。
+ *
+ * 語彙表は対を持つ（`pattern` と `instead_of`）。片方だけを数えても、
+ * 意図した硬い文体なのか不統一なのかが分からない。
+ */
+/**
+ * 語の境界で照合する。部分一致だと「it isn't」が「it is」を含んでしまい、
+ * 短縮形を使っている文が「使っていない」側に数えられる。
+ */
+const containsWord = (text: string, word: string): boolean => new RegExp(`\\b${word.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&")}\\b`, "u").test(text);
+
+export const contractionMix: Detector = (doc, options): Finding[] => {
+  const pairs = (options.lexicon ?? []).flatMap((entry) => (entry.instead_of === undefined ? [] : [{ short: entry.pattern, long: entry.instead_of }]));
+  const body = doc.sentences.map((sentence) => sentence.text.toLowerCase()).join(" ");
+  const used = pairs.filter((pair) => containsWord(body, pair.short.toLowerCase()));
+  const spelled = pairs.filter((pair) => containsWord(body, pair.long.toLowerCase()));
+  // 片方しか無ければ一貫している。両方あるときだけ、少数派を指摘する。
+  if (used.length === 0 || spelled.length === 0) return [];
+  const minorityIsShort = used.length <= spelled.length;
+  const few = minorityIsShort ? used : spelled;
+  if (few.length > options.limit) return [];
+  const wanted = few.map((pair) => (minorityIsShort ? pair.short : pair.long).toLowerCase());
+  const hits = doc.sentences.flatMap((sentence) => {
+    const text = sentence.text.toLowerCase();
+    const matched = wanted.find((word) => containsWord(text, word));
+    return matched === undefined ? [] : [{ sentence, matched }];
+  });
+  return hits.map((hit) => ({
+    rule: "contraction-consistency",
+    severity: "info",
+    line: 0,
+    column: 0,
+    quote: hit.sentence.text.trim(),
+    values: { matched: hit.matched, count: few.length, limit: options.limit, offset: hit.sentence.span.start },
+  }));
+};

package/src/detectors/signals.ts

@@ -49,13 +49,16 @@ export const emojiDensity: Detector = (doc, options): Finding[] => {
  * 同じ言い回しの繰り返し。character n-gram で見るので、語の区切りが要らない。
  * spec §10 が n-gram を選んだのはこのためで、新しい言語でそのまま動く。
  */
-const GRAM = 8;
+/**
+ * 窓の幅は単位で分ける。同じ 8 文字でも、日本語では 4〜5 形態素だが英語では 1 語半にしかならない。
+ * 実文書（英語 11 本）で 8 文字にしたら、上位は " generat"（generate）のような**語の断片**だった。
+ */
+const GRAM = { char: 8, word: 20 };
 
-/** 短い n-gram は偶然一致する。8 文字は「〜することができます」のような言い回しの長さ。 */
-const countGrams = (text: string): Map<string, number> => {
+const countGrams = (text: string, width: number): Map<string, number> => {
   const counts = new Map<string, number>();
-  Array.from({ length: Math.max(0, text.length - GRAM + 1) }).forEach((_, index) => {
-    const gram = text.slice(index, index + GRAM);
+  Array.from({ length: Math.max(0, text.length - width + 1) }).forEach((_, index) => {
+    const gram = text.slice(index, index + width);
     counts.set(gram, (counts.get(gram) ?? 0) + 1);
   });
   return counts;
@@ -69,7 +72,7 @@ const countGrams = (text: string): Map<string, number> => {
  * どちらを見るかは adapter が宣言する単位で決める。ひらがなを持たない char 単位の言語が
  * 来たら、この見分けは効かなくなる（そのときは adapter 側に判定を移す）。
  */
-const CONNECTIVE = { char: /[ぁ-ゖ]/u, word: / /u };
+const CONNECTIVE = { char: /[ぁ-ゖ]/u, word: /\S \S.*\S \S/u };
 
 const isPhrasing = (gram: string, unit: ProseDocument["lengthUnit"]): boolean => CONNECTIVE[unit].test(gram);
 
@@ -78,7 +81,7 @@ const gramsOf = (doc: ProseDocument): Map<string, number> => {
   const counts = new Map<string, number>();
   doc.sentences.forEach((sentence) => {
     const text = doc.lengthUnit === "char" ? proseText(sentence).replace(/\s+/gu, "") : proseText(sentence);
-    countGrams(text).forEach((count, gram) => counts.set(gram, (counts.get(gram) ?? 0) + count));
+    countGrams(text, GRAM[doc.lengthUnit]).forEach((count, gram) => counts.set(gram, (counts.get(gram) ?? 0) + count));
   });
   return counts;
 };
@@ -143,14 +146,21 @@ const COMMON = new Set([
 /**
  * 展開は略語の**すぐ隣**にあるときだけ認める。
  * 60 文字も見ると、同じ文のどこかに括弧があるだけで「説明済み」になり、1 件も出なくなる。
+ *
+ * 認めるのは 2 つの形。どちらも実際によく書かれる。
+ *   CI（継続的インテグレーション）   略語のあとに括弧
+ *   Continuous Integration (CI)      括弧の中が略語
  */
-const AFTER = /^\s*[(（]/u;
-const BEFORE = /[)）]\s*$/u;
+const OPENS = /^\s*[(（]/u;
+const CLOSES = /^\s*[)）]/u;
+const OPENED = /[(（]\s*$/u;
 
 const isExpanded = (body: string, acronym: string): boolean => {
   const at = body.indexOf(acronym);
   if (at === -1) return false;
-  return AFTER.test(body.slice(at + acronym.length, at + acronym.length + 3)) || BEFORE.test(body.slice(Math.max(0, at - 3), at));
+  const after = body.slice(at + acronym.length, at + acronym.length + 3);
+  const before = body.slice(Math.max(0, at - 3), at);
+  return OPENS.test(after) || (OPENED.test(before) && CLOSES.test(after));
 };
 
 export const undefinedAcronym: Detector = (doc, options): Finding[] => {
@@ -197,3 +207,26 @@ export const concreteEvidence: Detector = (doc, options): Finding[] => {
     },
   }));
 };
+
+/**
+ * ダッシュの多用。英語では正当な用法が多いが、2026 年時点で最も知られた生成文のシグナルでもある。
+ * 日本語の組版ではそもそも扱いが難しい。どちらが正しいかは severity の言語別指定で分ける。spec §12.4。
+ */
+const DASH = /[\u2014\u2015\u2013]/gu;
+
+export const dashDensity: Detector = (doc, options): Finding[] => {
+  const hits = findIn(doc, DASH);
+  const first = hits[0];
+  const rate = density(doc, hits.length);
+  if (wordsOf(doc) < FLOOR[doc.lengthUnit] || first === undefined || rate <= options.limit) return [];
+  return [
+    {
+      rule: "no-em-dash",
+      severity: "info",
+      line: 0,
+      column: 0,
+      quote: first.sentence.text.trim(),
+      values: { count: hits.length, density: rate, limit: options.limit, offset: first.offset },
+    },
+  ];
+};

package/src/detectors/team.ts

@@ -0,0 +1,90 @@
+import { proseText } from "../measure.ts";
+import { wordsOf } from "./structure.ts";
+import type { Detector, Finding, Sentence, Token } from "../plugin.ts";
+
+/**
+ * チームの言葉。社内でしか通じない語を、チームが chaff.yaml に自分で並べる。
+ *
+ * 何が社内用語かは組織ごとに違うので、chaff は語を持たない。並べる場所だけを用意する。
+ * 語彙表が空なら何も言わない（「用語を登録してください」とも言わない。押しつけない）。
+ */
+/**
+ * 表層でも原形でも当てる。利用者は辞書形で書く（「握る」）が、本文は活用している（「握った」）。
+ * 品詞解析があれば原形で当たり、無くても表層で当たる。要求はしない。
+ */
+const matches = (sentence: Sentence, word: string): boolean => sentence.text.includes(word) || (sentence.tokens ?? []).some((token) => token.lemma === word);
+
+export const internalJargon: Detector = (doc, options): Finding[] => {
+  const words = (options.lexicon ?? []).map((entry) => entry.pattern);
+  if (words.length === 0) return [];
+  const hits = doc.sentences.flatMap((sentence) => {
+    const matched = words.find((word) => matches(sentence, word));
+    return matched === undefined ? [] : [{ sentence, matched }];
+  });
+  if (hits.length < options.limit) return [];
+  return hits.map((hit) => ({
+    rule: "internal-jargon",
+    severity: "warning",
+    line: 0,
+    column: 0,
+    quote: hit.sentence.text.trim(),
+    values: { matched: hit.matched, count: hits.length, limit: options.limit, offset: hit.sentence.span.start },
+  }));
+};
+
+const has = (headings: readonly string[], wanted: string): boolean => headings.some((heading) => heading.includes(wanted));
+
+/**
+ * この種類の文書に無いと困る見出し。チームが chaff.yaml で決める。
+ *
+ * 「提案書にはリスクの節がある」のような取り決めは、組織ごとに違う。
+ * chaff は必須の見出しを持たず、**書かれた取り決めを守れているかだけ**を見る。
+ */
+export const requiredSections: Detector = (doc, options): Finding[] => {
+  const wanted = doc.requiredSections;
+  if (wanted.length === 0) return [];
+  const headings = doc.sections.map((section) => section.heading);
+  const missing = wanted.filter((name) => !has(headings, name));
+  if (missing.length < options.limit) return [];
+  return [
+    {
+      rule: "required-sections",
+      severity: "error",
+      line: 0,
+      column: 0,
+      quote: headings.filter((heading) => heading.length > 0).join(" / "),
+      values: { word: missing.join("、"), count: missing.length, limit: options.limit, offset: 0 },
+    },
+  ];
+};
+
+const PER = 1000;
+
+/** 密度を見る rule は短い文書を測らない。単位は言語で違うので床も分ける。 */
+const FLOOR = { word: 200, char: 500 };
+
+const isProperNoun = (token: Token): boolean => token.pos === "PROPN";
+
+/**
+ * 固有名詞の密度。製品名・社名・人名が続くと、知らない読者は文の骨組みを見失う。
+ *
+ * spec は未知語率としていたが、**品詞解析があれば PROPN を数えるだけで足りる**。
+ * 辞書を別に持つ必要はない。
+ */
+export const properNounDensity: Detector = (doc, options): Finding[] => {
+  const hits = doc.sentences.flatMap((sentence) => (sentence.tokens ?? []).filter(isProperNoun).map((token) => ({ sentence, token })));
+  const length = wordsOf(doc);
+  const rate = length === 0 ? 0 : Math.round((hits.length / length) * PER);
+  const first = hits[0];
+  if (length < FLOOR[doc.lengthUnit] || first === undefined || rate <= options.limit) return [];
+  return [
+    {
+      rule: "proper-noun-density",
+      severity: "info",
+      line: 0,
+      column: 0,
+      quote: proseText(first.sentence),
+      values: { count: hits.length, density: rate, limit: options.limit, offset: first.token.span.start },
+    },
+  ];
+};

package/src/document.ts

@@ -76,7 +76,17 @@ const EMPHASIS = new Set(["strong", "emphasis", "delete"]);
  */
 const DIRECTIVE = /^:::[^\n]*/gmu;
 
-const directiveSpans = (source: string): Span[] => [...source.matchAll(DIRECTIVE)].map((match) => ({ start: match.index, end: match.index + match[0].length }));
+/**
+ * `https://…` をそのまま書いた URL。GFM の autolink 拡張を入れていないので mdast では
+ * ただのテキストになり、本文として残る。残すと、見出しと URL の中の識別子が一致して
+ * 「見出しの繰り返し」と読まれる。表示される文字も本文ではない。
+ */
+const BARE_URL = /https?:\/\/[^\s)<>"'\]]+/gu;
+
+const matchSpans = (source: string, pattern: RegExp): Span[] =>
+  [...source.matchAll(pattern)].map((match) => ({ start: match.index, end: match.index + match[0].length }));
+
+const directiveSpans = (source: string): Span[] => [...matchSpans(source, DIRECTIVE), ...matchSpans(source, BARE_URL)];
 
 const collectMasks = (root: Node, source: string): Span[] => {
   const spans: Span[] = [...directiveSpans(source)];
@@ -216,7 +226,18 @@ const listsOf = (root: Node, source: string): BulletList[] => {
   return found;
 };
 
-export const buildDocument = (path: string, source: string, adapter: LanguageAdapter): ProseDocument => {
+/** チームが chaff.yaml に書いたもの。語彙表と同じ器に入れて、detector には出所を見せない。 */
+export type TeamRules = { readonly jargon: readonly string[]; readonly requiredSections: readonly string[] };
+
+const EMPTY_TEAM: TeamRules = { jargon: [], requiredSections: [] };
+
+/** Config から取り出す。document は Config の形を知らない。 */
+export const teamRules = (config: { readonly jargon: readonly string[]; readonly requiredSections: readonly string[] }): TeamRules => ({
+  jargon: config.jargon,
+  requiredSections: config.requiredSections,
+});
+
+export const buildDocument = (path: string, source: string, adapter: LanguageAdapter, team: TeamRules = EMPTY_TEAM): ProseDocument => {
   const root = parse(source);
   // 強調の記号は「本文でないもの」だが、太字の数を数えるときの「覆われた場所」ではない。
   // 同じ集合にすると、太字が自分の記号のせいで覆われた場所にあることになり、1 つも数えられなくなる。
@@ -237,6 +258,7 @@ export const buildDocument = (path: string, source: string, adapter: LanguageAda
     listSpans: listItems,
     paragraphs: paragraphsOf(paragraphSpans, sentences, listItems),
     lists: listsOf(root, source),
-    lexicons: adapter.lexicons,
+    lexicons: { ...adapter.lexicons, "internal-jargon": team.jargon.map((pattern) => ({ pattern })) },
+    requiredSections: team.requiredSections,
   };
 };

package/src/eval.ts

@@ -63,9 +63,21 @@ const recommend = (rule: RuleDefinition, sweep: readonly Point[], total: number)
   return strictest;
 };
 
+/**
+ * lint で動かない rule は掃引しない。
+ * 動かないものの閾値を測ると、「どの閾値でも 0 件」が「よく校正されている」に見える。
+ */
+const measurable = (rule: RuleDefinition, docs: readonly ProseDocument[], genre: string, language: string): boolean => {
+  if (rule.layer === "L4" || !rule.use_for.some((target) => genre.startsWith(target))) return false;
+  if (rule.languages !== undefined && !rule.languages.includes(language)) return false;
+  if (rule.from.length > 0) return false;
+  const capabilities = docs[0]?.capabilities;
+  return !rule.requires.some((need) => (need === "lemma" ? capabilities?.lemma : capabilities?.pos) !== true);
+};
+
 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)))
+    .filter((rule) => measurable(rule, docs, genre, language))
     .map((rule) => {
       const sweep = candidates(rule).map((limit) => countAt(docs, rule, limit));
       const current = rule.levels.normal ?? 1;

package/src/files.ts

@@ -26,7 +26,7 @@ const expand = (target: string): string[] => {
  * ロケールを明示する。既定のロケールに任せると、同じ入力でも機械によって順序が変わる。
  * 指摘の並びは CI のログにも baseline にも入るので、順序が揺れてはいけない。
  */
-export const byPath = (left: string, right: string): number => left.localeCompare(right, "en");
+const byPath = (left: string, right: string): number => left.localeCompare(right, "en");
 
 export const collectTargets = (targets: readonly string[]): string[] => {
   const found = targets.flatMap(expand).filter((path) => !isSkipped(path));

package/src/levels.ts

@@ -1,6 +1,6 @@
 import type { Level, LevelTable, RuleDefinition } from "./plugin.ts";
 
-export const LEVELS: readonly Level[] = ["strict", "normal", "relaxed", "off"];
+const LEVELS: readonly Level[] = ["strict", "normal", "relaxed", "off"];
 
 export const isLevel = (value: unknown): value is Level => typeof value === "string" && LEVELS.some((level) => level === value);
 

package/src/mask.ts

@@ -7,7 +7,14 @@ import type { Span } from "./plugin.ts";
  * 切り出して繋ぐのではなく覆うのは、オフセットを元文字列と一致させ続けるため。
  * 行・列の計算も、引用して見せる範囲も、これで元の位置のまま使える。
  */
-const blankOut = (text: string): string => text.replace(/[^\n]/gu, " ");
+/**
+ * 空白は**元の文字と同じ UTF-16 長**にする。
+ *
+ * `u` 付きの正規表現は 1 文字（コードポイント）ずつ当たるので、絵文字のような
+ * サロゲートペアを空白 1 つに置き換えると文字列が 1 だけ縮む。mdast のオフセットは
+ * UTF-16 単位なので、そこから先の指摘がすべて 1 ずれる。
+ */
+const blankOut = (text: string): string => text.replace(/[^\n]/gu, (char) => " ".repeat(char.length));
 
 const merge = (spans: readonly Span[]): Span[] =>
   [...spans]

package/src/measure.ts

@@ -13,7 +13,7 @@ export const proseText = (sentence: Sentence): string => sentence.text.replace(/
 
 export const charLength = (sentence: Sentence): number => sentence.text.replace(/\s+/gu, "").length;
 
-export const wordLength = (sentence: Sentence): number =>
+const wordLength = (sentence: Sentence): number =>
   proseText(sentence)
     .split(" ")
     .filter((word) => word.length > 0).length;