chaffjs 0.2.0 → 0.4.0

package/src/commands/test.ts

@@ -2,16 +2,18 @@ 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";
 import { CHECKS_FILE, loadChecks, type UserCheck } from "../checks.ts";
-import { CACHE_DIR, hasCredentials, isAuthFailure } from "../judge.ts";
-import { runSemantic } from "../run-semantic.ts";
-import { MACHINE_BANNER, renderSemantic } from "../render/semantic.ts";
+import { CACHE_DIR, credentialHint, describeFailure, hasCredentials } from "../judge.ts";
+import { ENV_FILE, loadEnvFile } from "../env.ts";
+import { planSemantic, runSemantic } from "../run-semantic.ts";
+import { MACHINE_BANNER, renderPlan, renderSemantic } from "../render/semantic.ts";
 import type { Config } from "../config/load.ts";
 import type { Finding, RuleDefinition } from "../plugin.ts";
+import type { Failure } from "../backends/types.ts";
 
 export type TestContext = {
   readonly config: Config;
@@ -33,13 +35,48 @@ 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 };
     }),
   );
 
+/** API を呼ばずに、何が送られるかだけを出す。鍵が無くても二段構えの 1 段目を確かめられる。 */
+const dryRun = async (
+  paths: readonly string[],
+  config: Config,
+  checks: readonly UserCheck[],
+  resolveGenre: TestContext["resolveGenre"],
+  envFile: string | undefined,
+): Promise<void> => {
+  const plans = await Promise.all(
+    paths.map(async (path) => {
+      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, teamRules(config));
+      const { genre } = resolveGenre(path, source, config);
+      return { path, jobs: planSemantic(doc, loadRules(language), checks, config.rules, genre), sentences: doc.sentences.length };
+    }),
+  );
+  plans.forEach(({ path, jobs, sentences }) => console.log(renderPlan(path, jobs, sentences).join("\n")));
+  const total = plans.reduce((sum, plan) => sum + plan.jobs.reduce((count, job) => count + job.candidates.length, 0), 0);
+  const from = envFile === undefined ? "" : `  ${envFile} を読みました。`;
+  const where = `${config.aiBackend} / ${config.aiModel}（認証${hasCredentials(config.aiBackend) ? "あり" : "なし"}）`;
+  console.log(
+    [
+      "",
+      "─".repeat(60),
+      "",
+      `  合計 ${total} 箇所を送ります。--dry-run なので API は呼んでいません。`,
+      `  送り先: ${where}`,
+      ...(from === "" ? [] : [from]),
+      "",
+    ].join("\n"),
+  );
+};
+
 /**
  * 機械と AI を見出しで分けて出す。読む人が「これは揺れる判定か」を知らないと、
  * AI の誤検知に振り回される。workflow spec §7、samples/README の軸 2。
@@ -51,28 +88,49 @@ export const runTest = async (targets: readonly string[], argv: readonly string[
     return 1;
   }
   const { config, resolveGenre, inspect } = context;
+  // 鍵の置き場所で「設定したのに効かない」を起こさせない。シェルの環境変数のほうが勝つ。
+  const envFile = loadEnvFile(process.cwd());
   const checks = loadChecks(join(process.cwd(), CHECKS_FILE));
   const results = await Promise.all(paths.map((path) => inspect(path, config, argv)));
   results.forEach((result) => {
     console.log(result.text.replace(/\n/u, `\n${MACHINE_BANNER.join("\n")}`));
   });
   const machineOnly = results.some((result) => result.outcome.findings.some((finding) => finding.severity === "error")) ? 1 : 0;
-  const noCredentials = [
-    "",
-    "  意味を読む検査は動かしていません。Anthropic の認証情報がありません。",
-    "  ANTHROPIC_API_KEY を設定するか、ant auth login を実行してください。",
-    "  機械による判定はすべて動いています。",
-    "",
-  ].join("\n");
+  const where = envFile === undefined ? `${ENV_FILE} に書いても読みます（いまは ${ENV_FILE} がありません）` : `${envFile} は読みました`;
+  const notRun = (why: string, what: string): string =>
+    ["", `  意味を読む検査は動かしていません。${why}`, `  ${what}`, `  ${where}。`, "  機械による判定はすべて動いています。", ""].join("\n");
+  const noCredentials = notRun(`${config.aiBackend} の認証情報がありません。`, credentialHint(config.aiBackend));
+  /**
+   * API が返した失敗を人の言葉にする。生のスタックトレースを人に見せない。
+   * 鍵はあるのに弾かれたときに「ありません」と言うと、設定済みの鍵をもう一度設定しに行かせる。
+   * 残高切れも同じで、「鍵を確かめてください」と言われても鍵は正しい。
+   */
+  const failed = (failure: Failure): string => {
+    if (failure.kind === "auth")
+      return notRun(`${config.aiBackend} が鍵を受け付けませんでした（${failure.status ?? "?"}）。`, "鍵が正しいか、その provider のものかを確かめてください。");
+    if (failure.kind === "quota") return notRun(`${config.aiBackend} の残高か上限に達しました（${failure.status ?? "?"}）。`, failure.message);
+    return notRun(`${config.aiBackend} が ${failure.status ?? "?"} を返しました。`, failure.message);
+  };
+  if (argv.includes("--dry-run")) {
+    await dryRun(paths, config, checks, resolveGenre, envFile);
+    return machineOnly;
+  }
   // 呼んでから落ちるのを待たない。認証が無いときの SDK の例外は型で判別できない。
-  if (!hasCredentials()) {
+  if (!hasCredentials(config.aiBackend)) {
     console.log(noCredentials);
     return machineOnly;
   }
-  const options = { model: config.aiModel, cacheDir: join(process.cwd(), CACHE_DIR), confidenceThreshold: config.confidenceThreshold };
+  const options = {
+    model: config.aiModel,
+    backend: config.aiBackend,
+    cacheDir: join(process.cwd(), CACHE_DIR),
+    confidenceThreshold: config.confidenceThreshold,
+  };
   const semantic = await judgeAll(paths, config, checks, options, resolveGenre).catch((error: unknown) => {
-    if (!isAuthFailure(error)) throw error;
-    console.log(noCredentials);
+    // API が返した失敗だけを受け止める。ネットワーク断やコードの誤りは握りつぶさない。
+    const failure = describeFailure(config.aiBackend, error);
+    if (failure === undefined) throw error;
+    console.log(failed(failure));
     return undefined;
   });
   if (semantic === undefined) return machineOnly;

package/src/config/load.ts

@@ -2,6 +2,8 @@ import { readFileSync } from "node:fs";
 import { dirname } from "node:path";
 import { parse } from "yaml";
 import { isLevel } from "../levels.ts";
+import { defaultModel } from "../judge.ts";
+import { isBackend, type BackendName } from "../backends/types.ts";
 import type { Level } from "../plugin.ts";
 import type { PathRule } from "./by-path.ts";
 
@@ -9,19 +11,25 @@ export const CONFIG_FILE = "chaff.yaml";
 
 export type Config = {
   readonly genre: string | undefined;
+  readonly aiBackend: BackendName;
   readonly language: string | undefined;
   readonly rules: Readonly<Record<string, Level>>;
   readonly experimental: boolean;
   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;
 };
 
 /** 判定の質が誤検知に直結するので、既定は最上位のモデル。cost は絞り込みで削る。spec §14。 */
-export const DEFAULT_MODEL = "claude-opus-5";
+/** 既定は Anthropic。openai にすると判定役だけが替わり、rule も判定の形も変わらない。 */
+export const DEFAULT_BACKEND: BackendName = "anthropic";
 
 export const EMPTY: Config = {
   genre: undefined,
@@ -29,8 +37,11 @@ export const EMPTY: Config = {
   rules: {},
   experimental: false,
   path: undefined,
-  aiModel: DEFAULT_MODEL,
+  aiBackend: DEFAULT_BACKEND,
+  aiModel: defaultModel(DEFAULT_BACKEND),
   confidenceThreshold: 0.7,
+  jargon: [],
+  requiredSections: [],
   byPath: [],
   baseDir: process.cwd(),
 };
@@ -58,20 +69,28 @@ 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。 */
 export const loadConfig = (path: string): Config => {
   const raw: unknown = parse(readFileSync(path, "utf8"));
   if (!isRecord(raw)) return { ...EMPTY, path };
+  const declared: unknown = raw["ai_backend"];
+  const backend: BackendName = isBackend(declared) ? declared : DEFAULT_BACKEND;
   return {
     genre: str(raw["genre"]),
     language: str(raw["language"]),
     rules: rulesOf(raw["rules"]),
     experimental: raw["experimental"] === true,
     path,
-    aiModel: str(raw["ai_model"]) ?? DEFAULT_MODEL,
+    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/agentless-passive.ts

@@ -0,0 +1,34 @@
+import type { Detector, Finding, Sentence, Token } from "../plugin.ts";
+
+/**
+ * 受動のまま動作主を書かないと、誰がしたのかが文から消える。
+ * 「決定されました」は、決めた人を名指さずに決定を伝える。
+ *
+ * 受動かどうかはアダプタが Voice=Pass で印を付ける。日本語の「れる/られる」と
+ * 英語の be + 過去分詞は形が全く違うので、その判断は言語の側に置く。spec §12.1。
+ * 「名詞を修飾しているだけか」の判断も、語順が言語で逆になるため同じくアダプタ側。
+ * 動作主の語（によって / by）も言語ごとの語彙表から引く。detector は言語を知らない。
+ */
+const isPassive = (token: Token): boolean => token.features?.["Voice"] === "Pass";
+
+const hasAgent = (sentence: Sentence, markers: readonly string[]): boolean => markers.some((marker) => sentence.text.includes(marker));
+
+export const agentlessPassive: Detector = (doc, options): Finding[] => {
+  const markers = (options.lexicon ?? []).map((entry) => entry.pattern);
+  return doc.sentences
+    .map((sentence) => ({ sentence, passives: (sentence.tokens ?? []).filter(isPassive) }))
+    .filter(({ sentence, passives }) => passives.length >= options.limit && !hasAgent(sentence, markers))
+    .map(({ sentence, passives }) => ({
+      rule: "agentless-passive",
+      severity: "warning",
+      line: 0,
+      column: 0,
+      quote: sentence.text.trim(),
+      values: {
+        count: passives.length,
+        limit: options.limit,
+        word: passives.map((token) => token.surface).join(" "),
+        offset: passives[0]?.span.start ?? sentence.span.start,
+      },
+    }));
+};

package/src/detectors/char-shape.ts

@@ -0,0 +1,47 @@
+import type { Detector, Finding, Sentence } from "../plugin.ts";
+import { proseText } from "../measure.ts";
+
+/**
+ * 文字の並びだけを見る検出。品詞も語彙表も要らない。
+ * 覆った箇所は空白になっているので、proseText で潰してから数える。
+ */
+const KANJI_RUN = /[一-鿿]+/gu;
+
+const longestKanji = (sentence: Sentence): string =>
+  [...proseText(sentence).matchAll(KANJI_RUN)].reduce((longest, match) => (match[0].length > longest.length ? match[0] : longest), "");
+
+/**
+ * 漢字が続くと、どこで語が切れるのか読み手が探すことになる。
+ * 「情報処理推進機構認定試験」は 12 字。ひらがなを 1 つ挟むだけで読める。
+ */
+export const kanjiRun: Detector = (doc, options): Finding[] =>
+  doc.sentences
+    .map((sentence) => ({ sentence, run: longestKanji(sentence) }))
+    .filter(({ run }) => run.length > options.limit)
+    .map(({ sentence, run }) => ({
+      rule: "max-kanji-continuous",
+      severity: "warning",
+      line: 0,
+      column: 0,
+      quote: sentence.text.trim(),
+      values: { word: run, count: run.length, limit: options.limit, offset: sentence.span.start },
+    }));
+
+const MIDDLE_DOT = /・/gu;
+
+/**
+ * 中黒で並べると、どこまでが 1 つの項目か分からなくなる。
+ * 「企画・開発・運用・保守体制」は、保守体制が 1 つなのか保守と体制なのか読めない。
+ */
+export const middleDot: Detector = (doc, options): Finding[] =>
+  doc.sentences
+    .map((sentence) => ({ sentence, count: [...proseText(sentence).matchAll(MIDDLE_DOT)].length }))
+    .filter(({ count }) => count > options.limit)
+    .map(({ sentence, count }) => ({
+      rule: "no-nakaguro-parallel",
+      severity: "info",
+      line: 0,
+      column: 0,
+      quote: sentence.text.trim(),
+      values: { count, limit: options.limit, offset: sentence.span.start },
+    }));

package/src/detectors/en-shape.ts

@@ -0,0 +1,187 @@
+import { lengthOf } from "../measure.ts";
+import { isClosed } from "../sentence-shape.ts";
+import type { Detector, Finding, ProseDocument, Section, Sentence, Token } from "../plugin.ts";
+
+const PER = 1000;
+
+/** これより短い文書では密度が暴れる。1 語で「1000 語あたり 100」になる。 */
+const MIN_WORDS = 200;
+
+const wordsIn = (doc: ProseDocument): number => doc.sentences.reduce((sum, sentence) => sum + lengthOf(sentence, "word"), 0);
+
+const isLyAdverb = (token: Token): boolean => token.pos === "ADV" && token.surface.toLowerCase().endsWith("ly");
+
+/**
+ * -ly 副詞は、動詞が弱いことの目印になる。「walked quickly」より「hurried」。
+ * 1 つずつは正しいので、件数ではなく密度で見る（bold-density と同じ）。
+ */
+export const adverbDensity: Detector = (doc, options): Finding[] => {
+  const words = wordsIn(doc);
+  const hits = doc.sentences.flatMap((sentence) => (sentence.tokens ?? []).filter(isLyAdverb).map((token) => ({ sentence, token })));
+  const density = words === 0 ? 0 : Math.round((hits.length / words) * PER);
+  const first = hits[0];
+  if (words < MIN_WORDS || first === undefined || density <= options.limit) return [];
+  return [
+    {
+      rule: "adverb-overuse",
+      severity: "info",
+      line: 0,
+      column: 0,
+      quote: first.sentence.text.trim(),
+      values: { count: hits.length, density, words, limit: options.limit, offset: first.token.span.start },
+    },
+  ];
+};
+
+const BE = new Set(["be", "is", "are", "was", "were"]);
+
+/**
+ * There is / It is ... that は、主語を後ろへ押しやって誰が何をするのかを消す。
+ * 「There is a need to review」は、誰が必要としているのかを言っていない。
+ */
+const expletiveAt = (tokens: readonly Token[]): Token | undefined => {
+  const head = tokens.find((token) => token.pos !== "PUNCT");
+  if (head === undefined) return undefined;
+  const lead = head.surface.toLowerCase();
+  if (lead !== "there" && lead !== "it") return undefined;
+  const next = tokens.find((token) => token.span.start >= head.span.end && token.pos !== "PUNCT");
+  if (next === undefined || !BE.has(next.lemma ?? next.surface.toLowerCase())) return undefined;
+  // "it is" は "it is raining" のような正当な用法があるので、that 節を伴うときだけ数える。
+  if (lead === "it" && !tokens.some((token) => token.surface.toLowerCase() === "that")) return undefined;
+  return head;
+};
+
+export const expletive: Detector = (doc, options): Finding[] => {
+  const hits = doc.sentences.flatMap((sentence) => {
+    const at = expletiveAt(sentence.tokens ?? []);
+    return at === undefined ? [] : [{ sentence, at }];
+  });
+  if (hits.length <= options.limit) return [];
+  return hits.map(({ sentence, at }) => ({
+    rule: "expletive-construction",
+    severity: "info",
+    line: 0,
+    column: 0,
+    quote: sentence.text.trim(),
+    values: { word: at.surface, count: hits.length, limit: options.limit, offset: at.span.start },
+  }));
+};
+
+const firstWord = (sentence: Sentence): string =>
+  sentence.text
+    .trim()
+    .split(/\s+/u)[0]
+    ?.replace(/[^A-Za-z]/gu, "") ?? "";
+
+/**
+ * 接続詞で始まる文が続く。1 つなら効くが、続くと文が前の文の付け足しに見えて、
+ * 何が主張なのかが分からなくなる。
+ */
+export const conjunctionRun: Detector = (doc, options): Finding[] => {
+  const heads = (options.lexicon ?? []).map((entry) => entry.pattern.toLowerCase());
+  const runs = doc.sentences.filter(isClosed).reduce<Sentence[][]>(
+    (acc, sentence) => {
+      const last = acc.at(-1) ?? [];
+      if (!heads.includes(firstWord(sentence).toLowerCase())) return [...acc.slice(0, -1), last, []];
+      return [...acc.slice(0, -1), [...last, sentence]];
+    },
+    [[]],
+  );
+  return runs
+    .filter((run) => run.length > options.limit)
+    .flatMap((run) => {
+      const first = run[0];
+      return first === undefined
+        ? []
+        : [
+            {
+              rule: "sentence-initial-conjunction-run",
+              severity: "info" as const,
+              line: 0,
+              column: 0,
+              quote: run.map((sentence) => sentence.text.trim()).join(" "),
+              values: { count: run.length, limit: options.limit, offset: first.span.start },
+            },
+          ];
+    });
+};
+
+const WORD = /[A-Za-z][A-Za-z'-]*/gu;
+
+/** 小さい語は Title Case でも小文字のままなので、大文字化の判定から外す。 */
+const MINOR = new Set(["a", "an", "the", "and", "or", "but", "of", "in", "on", "at", "to", "for", "with", "as", "by", "from", "is"]);
+
+const isTitleCase = (heading: string): boolean | undefined => {
+  const words = [...heading.matchAll(WORD)].map((match) => match[0]).filter((word) => !MINOR.has(word.toLowerCase()));
+  // 1 語の見出しは、どちらの流儀でも先頭が大文字になる。判定できない。
+  if (words.length < 2) return undefined;
+  const capitalized = words.filter((word) => word[0] === word[0]?.toUpperCase()).length;
+  return capitalized === words.length;
+};
+
+const headingsOf = (sections: readonly Section[]): { readonly section: Section; readonly title: boolean }[] =>
+  sections.flatMap((section) => {
+    const title = isTitleCase(section.heading);
+    return title === undefined ? [] : [{ section, title }];
+  });
+
+/**
+ * 見出しの大文字化が混ざっている。どちらの流儀が正しいかは決めない。spec §12.3。
+ * 見るのは文書の中で揃っているかだけで、少数派のほうを指摘する。
+ */
+export const titleCaseMix: Detector = (doc, options): Finding[] => {
+  const judged = headingsOf(doc.sections);
+  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 [];
+  return judged
+    .filter((entry) => entry.title === minorityIsTitle)
+    .map(({ section }) => ({
+      rule: "title-case-consistency",
+      severity: "info",
+      line: 0,
+      column: 0,
+      quote: section.heading,
+      values: { count: few, limit: options.limit, offset: section.span.start },
+    }));
+};
+
+const LIST_CONJUNCTION = new Set(["and", "or"]);
+
+/**
+ * 3 つ以上の並列の最後の and / or の前に読点を打つか。Oxford comma。
+ *
+ * どちらが正しいかは決めない。スタイルガイドで割れる論点に立場を取ると rule ごと無視される。
+ * 見るのは 1 つの文書で揃っているかだけ。spec §12.3。
+ */
+const oxfordIn = (tokens: readonly Token[]): boolean | undefined => {
+  const at = tokens.findIndex((token) => LIST_CONJUNCTION.has(token.surface.toLowerCase()));
+  if (at < 1) return undefined;
+  const before = tokens.slice(0, at);
+  // 並列が 3 つ以上あるときだけ判定できる。読点が 1 つも無ければ 2 つの並列。
+  const commas = before.filter((token) => token.surface === ",").length;
+  if (commas === 0) return undefined;
+  return before.at(-1)?.surface === ",";
+};
+
+export const oxfordComma: Detector = (doc, options): Finding[] => {
+  const judged = doc.sentences.flatMap((sentence) => {
+    const oxford = oxfordIn(sentence.tokens ?? []);
+    return oxford === undefined ? [] : [{ sentence, oxford }];
+  });
+  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 [];
+  return judged
+    .filter((entry) => entry.oxford === minorityUsesComma)
+    .map(({ sentence }) => ({
+      rule: "oxford-comma-consistency",
+      severity: "info",
+      line: 0,
+      column: 0,
+      quote: sentence.text.trim(),
+      values: { count: few, limit: options.limit, offset: sentence.span.start },
+    }));
+};

package/src/detectors/index.ts

@@ -5,6 +5,15 @@ import { headingEcho } from "./heading-echo.ts";
 import { repeatedHead } from "./repeated-head.ts";
 import { sentenceRhythm } from "./sentence-rhythm.ts";
 import { phraseMatch } from "./phrase-match.ts";
+import { agentlessPassive } from "./agentless-passive.ts";
+import { sentenceEnding } from "./sentence-ending.ts";
+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 { internalJargon, properNounDensity, requiredSections } from "./team.ts";
 
 /** rule 定義の how_to_find がここを引く。rule 側は実装を知らない。 */
 export const DETECTORS: Readonly<Record<string, Detector>> = {
@@ -14,4 +23,32 @@ export const DETECTORS: Readonly<Record<string, Detector>> = {
   "repeated-head": repeatedHead,
   "sentence-rhythm": sentenceRhythm,
   "phrase-match": phraseMatch,
+  "agentless-passive": agentlessPassive,
+  "sentence-ending": sentenceEnding,
+  "noun-ending": nounEnding,
+  "doubled-particle": doubledParticle,
+  "kanji-run": kanjiRun,
+  "middle-dot": middleDot,
+  "adverb-density": adverbDensity,
+  expletive: expletive,
+  "conjunction-run": conjunctionRun,
+  "title-case-mix": titleCaseMix,
+  "oxford-comma": oxfordComma,
+  "paragraph-length": paragraphLength,
+  "paragraph-variance": paragraphVariance,
+  "section-uniformity": sectionUniformity,
+  "rule-of-three": ruleOfThree,
+  "preamble-length": preambleLength,
+  "emoji-density": emojiDensity,
+  "ngram-repetition": ngramRepetition,
+  "undefined-acronym": undefinedAcronym,
+  "concrete-evidence": concreteEvidence,
+  "hedging-density": hedgingDensity,
+  "cushion-density": cushionDensity,
+  "unqualified-superlative": unqualifiedSuperlative,
+  "repeated-conjunction": repeatedConjunction,
+  "ai-tell": aiTell,
+  "internal-jargon": internalJargon,
+  "required-sections": requiredSections,
+  "proper-noun-density": properNounDensity,
 };

package/src/detectors/lexicon.ts

@@ -0,0 +1,124 @@
+import { proseText } from "../measure.ts";
+import { wordsOf } from "./structure.ts";
+import type { Detector, Finding, ProseDocument, Sentence } from "../plugin.ts";
+
+const PER = 1000;
+
+/** 密度を見る rule は短い文書を測らない。単位は言語で違うので床も分ける。 */
+const FLOOR = { word: 200, char: 500 };
+
+type Hit = { readonly sentence: Sentence; readonly matched: string };
+
+const hitsFor = (doc: ProseDocument, patterns: readonly string[]): Hit[] =>
+  doc.sentences.flatMap((sentence) => {
+    const text = sentence.text.toLowerCase();
+    return patterns.filter((pattern) => text.includes(pattern.toLowerCase())).map((matched) => ({ sentence, matched }));
+  });
+
+/**
+ * 単位長あたりの出現率。件数で数えると長い文書ほど当たる（bold-density と同じ）。
+ * rule の id は呼び出し側が持つ。detector は「密度が閾値を超えたか」しか知らない。
+ */
+const densityRule =
+  (rule: string): Detector =>
+  (doc, options): Finding[] => {
+    const patterns = (options.lexicon ?? []).map((entry) => entry.pattern);
+    const hits = hitsFor(doc, patterns);
+    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 hits.map((hit) => ({
+      rule,
+      severity: "warning",
+      line: 0,
+      column: 0,
+      quote: hit.sentence.text.trim(),
+      values: { matched: hit.matched, count: hits.length, density: rate, limit: options.limit, offset: hit.sentence.span.start },
+    }));
+  };
+
+export const hedgingDensity = densityRule("excessive-hedging");
+export const cushionDensity = densityRule("cushion-phrase-density");
+
+/**
+ * 限定のない最上級。「最も速い」だけでは、何と比べて最もなのかが無い。
+ * 同じ文に比較対象や条件があれば、それは主張であって誇張ではない。
+ */
+const QUALIFIER = /\d|より|に比べ|のうち|among|than|compared|based on|according/iu;
+
+export const unqualifiedSuperlative: Detector = (doc, options): Finding[] => {
+  const patterns = (options.lexicon ?? []).map((entry) => entry.pattern);
+  const bare = hitsFor(doc, patterns).filter((hit) => !QUALIFIER.test(hit.sentence.text));
+  if (bare.length < options.limit) return [];
+  return bare.map((hit) => ({
+    rule: "unqualified-superlative",
+    severity: "warning",
+    line: 0,
+    column: 0,
+    quote: hit.sentence.text.trim(),
+    values: { matched: hit.matched, count: bare.length, limit: options.limit, offset: hit.sentence.span.start },
+  }));
+};
+
+const openerOf = (doc: ProseDocument, patterns: readonly string[]): (string | undefined)[] =>
+  doc.paragraphs.map((paragraph) => {
+    const head = paragraph.sentences[0]?.text.trim().toLowerCase() ?? "";
+    return patterns.find((pattern) => head.startsWith(pattern.toLowerCase()));
+  });
+
+/**
+ * 段落が同じ接続詞で始まり続ける。1 つなら流れを作るが、続くとどの段落も
+ * 前の段落の付け足しに見えて、話がどこへ向かっているのか分からなくなる。
+ */
+export const repeatedConjunction: Detector = (doc, options): Finding[] => {
+  const patterns = (options.lexicon ?? []).map((entry) => entry.pattern);
+  const openers = openerOf(doc, patterns);
+  const runs = openers.reduce<{ runs: number[][]; current: number[] }>(
+    (acc, opener, index) => {
+      if (opener === undefined) return { runs: [...acc.runs, acc.current], current: [] };
+      return { runs: acc.runs, current: [...acc.current, index] };
+    },
+    { runs: [], current: [] },
+  );
+  return [...runs.runs, runs.current]
+    .filter((run) => run.length > options.limit)
+    .flatMap((run) => {
+      const at = doc.paragraphs[run[0] ?? 0];
+      return at === undefined
+        ? []
+        : [
+            {
+              rule: "repeated-conjunction",
+              severity: "warning" as const,
+              line: 0,
+              column: 0,
+              quote: at.sentences[0]?.text.trim() ?? "",
+              values: { count: run.length, limit: options.limit, offset: at.span.start },
+            },
+          ];
+    });
+};
+
+/**
+ * AI 生成の signal。1 つでは何も言えないので、重みを足し合わせて文書の点にする。
+ * 単独で断じない。§20.2 の複合シグナルの入口で、これだけで「AI が書いた」とは言わない。
+ */
+export const aiTell: Detector = (doc, options): Finding[] => {
+  const weights = new Map((options.lexicon ?? []).map((entry) => [entry.pattern.toLowerCase(), entry.weight ?? 1]));
+  const body = doc.sentences.map(proseText).join(" ").toLowerCase();
+  const found = [...weights.entries()].filter(([pattern]) => body.includes(pattern));
+  const score = Math.round(found.reduce((sum, [, weight]) => sum + weight, 0) * 10);
+  const first = doc.sentences.find((sentence) => found.some(([pattern]) => sentence.text.toLowerCase().includes(pattern)));
+  if (first === undefined || score <= options.limit) return [];
+  return [
+    {
+      rule: "ai-tell",
+      severity: "info",
+      line: 0,
+      column: 0,
+      quote: first.text.trim(),
+      values: { word: found.map(([pattern]) => pattern).join("、"), count: found.length, density: score, limit: options.limit, offset: first.span.start },
+    },
+  ];
+};