chaffjs 0.1.0 → 0.3.0

package/src/cli.ts

@@ -3,6 +3,7 @@ import { existsSync } from "node:fs";
 import { 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 { guessLanguage } from "./detect.ts";
@@ -11,10 +12,8 @@ import { BASELINE_FILE, fingerprint, readBaseline, splitByBaseline, writeBaselin
 import { applySuppressions } from "./stet.ts";
 import { renderSuppressions, type PerFile } from "./render/suppressions.ts";
 import { clock, describeChange, snapshotOf, watchPaths, type Snapshot } from "./watch.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 { runEval } from "./commands/eval.ts";
+import { runTest } from "./commands/test.ts";
 import { frontMatterGenre, guessGenre } from "./genre.ts";
 import { GENRES, runInit } from "./init.ts";
 import { loadRules } from "./rule-load.ts";
@@ -23,7 +22,7 @@ import { renderExplain } from "./render/explain.ts";
 import { renderFriendly } from "./render/friendly.ts";
 import { rulesJson } from "./render/rules-json.ts";
 import { renderSummary, type FileOutcome } from "./render/summary.ts";
-import { runRules } from "./run.ts";
+import { neededBy, runRules } from "./run.ts";
 import type { Level, RuleDefinition } from "./plugin.ts";
 
 const USAGE = `chaff — 文章の読みにくいところを見つけます。文章は書き換えません。
@@ -31,7 +30,9 @@ const USAGE = `chaff — 文章の読みにくいところを見つけます。
   chaff <file|dir|glob>...       検査する（設定も API key も要りません）
   chaff .                        この場所の Markdown を全部
   chaff test <file|dir>...       意味を読む検査も動かす（API key が要ります）
+                                 判定役は chaff.yaml の ai_backend で選びます
   chaff init                     chaff.yaml を作る
+  chaff eval <dir>               手元の文書で閾値を測り直す
   chaff explain <rule>           そのルールの意図と根拠を読む
   chaff genres                   ジャンルの一覧
   chaff rules --json             いまの設定を JSON で出す（AI に渡す用）
@@ -43,6 +44,7 @@ const USAGE = `chaff — 文章の読みにくいところを見つけます。
   --experimental    試験中の rule も動かす
   --show-baseline   棚上げした分も含めて全部見る
   --watch           保存のたびに見直し、変わったところだけ出す
+  --dry-run         test で、何を AI に送るかだけを見る（API を呼びません）
 
 この箇所だけ黙らせる:  <!-- stet: rule-id — 理由 -->
 
@@ -52,6 +54,9 @@ const USAGE = `chaff — 文章の読みにくいところを見つけます。
 const readConfig = (): Config => (existsSync(join(process.cwd(), CONFIG_FILE)) ? loadConfig(join(process.cwd(), CONFIG_FILE)) : EMPTY);
 
 const resolveGenre = (path: string, source: string, config: Config): { genre: string; from: string } => {
+  // パスごとの上書きが最優先。「全体はこう、ここだけは違う」を書けるようにする。
+  const override = applyByPath(config.byPath, config.baseDir, path);
+  if (override.genre !== undefined) return { genre: override.genre, from: `${CONFIG_FILE} の by_path` };
   if (config.genre !== undefined) return { genre: config.genre, from: CONFIG_FILE };
   const guess = guessGenre(path, source, frontMatterGenre(source));
   return guess === undefined ? { genre: "blog/tech", from: "既定" } : { genre: guess.genre, from: guess.from };
@@ -86,12 +91,14 @@ const headerFor = (path: string, genre: string, from: string, language: string,
 
 const inspect = async (path: string, config: Config, argv: readonly string[]): Promise<Inspected> => {
   const source = await readFile(path, "utf8");
-  const language = config.language ?? guessLanguage(source).language;
+  const language = applyByPath(config.byPath, config.baseDir, path).language ?? config.language ?? guessLanguage(source).language;
   const adapter = await loadAdapter(language);
   const { genre, from } = resolveGenre(path, source, config);
-  const doc = buildDocument(path, source, adapter);
   const rules = loadRules(language);
-  const raw = runRules(doc, rules, config.rules, config.experimental || argv.includes("--experimental"), genre);
+  const experimental = config.experimental || argv.includes("--experimental");
+  await adapter.prepare?.(neededBy(rules, config.rules, experimental, genre, language));
+  const doc = buildDocument(path, source, adapter);
+  const raw = runRules(doc, rules, config.rules, experimental, genre);
   // 応答は 3 つ。stet で黙らせたものは、ここで落とす。
   const applied = applySuppressions(
     source,
@@ -163,74 +170,6 @@ const runWatch = async (targets: readonly string[], argv: readonly string[]): Pr
   return new Promise(() => undefined);
 };
 
-type Judged = { path: string; outcome: Awaited<ReturnType<typeof runSemantic>>; rules: RuleDefinition[]; language: string };
-
-const judgeAll = async (
-  paths: readonly string[],
-  config: Config,
-  checks: readonly UserCheck[],
-  options: Parameters<typeof runSemantic>[5],
-): Promise<Judged[]> =>
-  Promise.all(
-    paths.map(async (path) => {
-      const source = await readFile(path, "utf8");
-      const language = config.language ?? guessLanguage(source).language;
-      const adapter = await loadAdapter(language);
-      const doc = buildDocument(path, source, adapter);
-      const { genre } = resolveGenre(path, source, config);
-      const rules = loadRules(language);
-      return { path, outcome: await runSemantic(doc, rules, checks, config.rules, genre, options), rules, language };
-    }),
-  );
-
-/**
- * 機械と AI を見出しで分けて出す。読む人が「これは揺れる判定か」を知らないと、
- * AI の誤検知に振り回される。workflow spec §7、samples/README の軸 2。
- */
-const test = async (targets: readonly string[], argv: readonly string[]): Promise<number> => {
-  const paths = collectTargets(targets.length > 0 ? targets : ["."]);
-  if (paths.length === 0) {
-    console.error(`Markdown が 1 つも見つかりませんでした: ${targets.join(", ")}`);
-    return 1;
-  }
-  const config = readConfig();
-  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");
-  // 呼んでから落ちるのを待たない。認証が無いときの SDK の例外は型で判別できない。
-  if (!hasCredentials()) {
-    console.log(noCredentials);
-    return machineOnly;
-  }
-  const options = { model: config.aiModel, cacheDir: join(process.cwd(), CACHE_DIR), confidenceThreshold: config.confidenceThreshold };
-  const semantic = await judgeAll(paths, config, checks, options).catch((error: unknown) => {
-    if (!isAuthFailure(error)) throw error;
-    console.log(noCredentials);
-    return undefined;
-  });
-  if (semantic === undefined) return machineOnly;
-  semantic.forEach((entry) => {
-    if (entry.outcome.findings.length === 0 && entry.outcome.asked === 0) return;
-    console.log([`${entry.path}`, ...renderSemantic(entry.outcome, entry.rules, checks, entry.language)].join("\n"));
-  });
-  const machine = results.flatMap((result) => result.outcome.findings);
-  const ai = semantic.flatMap((entry) => entry.outcome.findings);
-  console.log(
-    ["", "─".repeat(60), "", `  機械 ${machine.length} 件 / AI ${ai.length} 件`, "  文章は書き換えていません。直すのは書いた人です。", ""].join("\n"),
-  );
-  return [...machine, ...ai].some((finding) => finding.severity === "error") ? 1 : 0;
-};
-
 const explain = (ruleId: string | undefined): number => {
   const config = readConfig();
   const language = config.language ?? "ja";
@@ -242,12 +181,13 @@ const explain = (ruleId: string | undefined): number => {
     return 1;
   }
   const current = config.rules[rule.id] ?? (rule.status === "experimental" && !config.experimental ? "off" : "normal");
-  console.log(renderExplain(rule, current, language, unitOf(rule.id, language)));
+  console.log(renderExplain(rule, current, language, unitOf(rule.id, language), config.genre));
   return 0;
 };
 
 /** 閾値の単位。explain で「4 とは何の 4 か」を示すため。 */
 const unitOf = (ruleId: string, language: string): string => {
+  if (ruleId === "bold-density") return "1000 字あたりの箇所数";
   if (ruleId !== "max-sentence-length") return "回";
   return language === "ja" ? "文字" : "語";
 };
@@ -312,7 +252,8 @@ const HANDLERS: Readonly<Record<string, Handler>> = {
   genres: showGenres,
   rules: showRules,
   explain: (argv) => explain(argv[1]),
-  test: (argv) => test(positional(argv), argv),
+  eval: (argv) => runEval(positional(argv), argv, { config: readConfig(), resolveGenre, flag }),
+  test: (argv) => runTest(positional(argv), argv, { config: readConfig(), resolveGenre, inspect }),
   baseline: (argv) => runBaseline(positional(argv), argv),
   suppressions: (argv) => runSuppressions(positional(argv), argv),
   relax: (argv) => changeSetting("relaxed", argv[1], flag(argv, "--why")),

package/src/commands/eval.ts

@@ -0,0 +1,67 @@
+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 { guessLanguage } from "../detect.ts";
+import { collectTargets } from "../files.ts";
+import { loadRules } from "../rule-load.ts";
+import { evaluate } from "../eval.ts";
+import { renderEval } from "../render/eval.ts";
+import { neededBy } from "../run.ts";
+import type { Config } from "../config/load.ts";
+
+export type Context = {
+  readonly config: Config;
+  readonly resolveGenre: (path: string, source: string, config: Config) => { genre: string; from: string };
+  readonly flag: (argv: readonly string[], name: string) => string | undefined;
+};
+
+/**
+ * 閾値の較正。手元の文書を「人間の良い文書」として扱い、どの閾値なら
+ * 誤検知が目標を下回るかを測る。書き換えはしない。
+ */
+export const runEval = async (targets: readonly string[], argv: readonly string[], context: Context): Promise<number> => {
+  const paths = collectTargets(targets.length > 0 ? targets : ["."]);
+  if (paths.length === 0) {
+    console.error(`Markdown が 1 つも見つかりませんでした: ${targets.join(", ")}`);
+    return 1;
+  }
+  const { config, resolveGenre, flag } = context;
+  const only = flag(argv, "--rule");
+  const docs = 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 { 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 };
+    }),
+  );
+  const language = docs[0]?.language ?? "ja";
+  const genre = docs[0]?.genre ?? "blog/tech";
+  // 言語とジャンルが混ざった corpus は測れない。閾値の単位が違うため。
+  const mixed = new Set(docs.map((entry) => `${entry.language}/${entry.genre}`));
+  if (mixed.size > 1) {
+    console.error(`言語かジャンルが混ざっています: ${[...mixed].join(", ")}\n1 つに絞って測ってください（例: npx chaff eval examples/blog-ja/）。`);
+    return 1;
+  }
+  const rules = loadRules(language).filter((rule) => only === undefined || rule.id === only);
+  if (rules.length === 0) {
+    console.error(`${only ?? "(名前なし)"} という rule はありません。`);
+    return 1;
+  }
+  console.log(
+    renderEval(
+      evaluate(
+        docs.map((entry) => entry.doc),
+        rules,
+        genre,
+        language,
+      ),
+      docs.length,
+      paths.length,
+    ),
+  );
+  return 0;
+};

package/src/commands/test.ts

@@ -0,0 +1,147 @@
+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 { 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, 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;
+  readonly resolveGenre: (path: string, source: string, config: Config) => { genre: string; from: string };
+  readonly inspect: (path: string, config: Config, argv: readonly string[]) => Promise<{ text: string; outcome: { findings: readonly Finding[] } }>;
+};
+
+type Judged = { path: string; outcome: Awaited<ReturnType<typeof runSemantic>>; rules: RuleDefinition[]; language: string };
+
+const judgeAll = async (
+  paths: readonly string[],
+  config: Config,
+  checks: readonly UserCheck[],
+  options: Parameters<typeof runSemantic>[5],
+  resolveGenre: TestContext["resolveGenre"],
+): Promise<Judged[]> =>
+  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);
+      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);
+      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。
+ */
+export const runTest = async (targets: readonly string[], argv: readonly string[], context: TestContext): Promise<number> => {
+  const paths = collectTargets(targets.length > 0 ? targets : ["."]);
+  if (paths.length === 0) {
+    console.error(`Markdown が 1 つも見つかりませんでした: ${targets.join(", ")}`);
+    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 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(config.aiBackend)) {
+    console.log(noCredentials);
+    return machineOnly;
+  }
+  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) => {
+    // API が返した失敗だけを受け止める。ネットワーク断やコードの誤りは握りつぶさない。
+    const failure = describeFailure(config.aiBackend, error);
+    if (failure === undefined) throw error;
+    console.log(failed(failure));
+    return undefined;
+  });
+  if (semantic === undefined) return machineOnly;
+  semantic.forEach((entry) => {
+    if (entry.outcome.findings.length === 0 && entry.outcome.asked === 0) return;
+    console.log([`${entry.path}`, ...renderSemantic(entry.outcome, entry.rules, checks, entry.language)].join("\n"));
+  });
+  const machine = results.flatMap((result) => result.outcome.findings);
+  const ai = semantic.flatMap((entry) => entry.outcome.findings);
+  console.log(
+    ["", "─".repeat(60), "", `  機械 ${machine.length} 件 / AI ${ai.length} 件`, "  文章は書き換えていません。直すのは書いた人です。", ""].join("\n"),
+  );
+  return [...machine, ...ai].some((finding) => finding.severity === "error") ? 1 : 0;
+};

package/src/config/by-path.ts

@@ -0,0 +1,47 @@
+import { relative, sep } from "node:path";
+
+export type PathRule = { readonly files: readonly string[]; readonly genre: string | undefined; readonly language: string | undefined };
+
+/**
+ * glob を正規表現にする。使うのは 3 つだけ。
+ *   **\/  区切りをまたいでディレクトリ 0 個以上（docs/**\/*.md は docs/a.md にも当たる）
+ *   *    区切りをまたがずに何文字でも
+ *   ?    区切り以外の 1 文字
+ * これ以上を足すと、設定を書く人が覚えることが増える。
+ *
+ * 「ディレクトリ 0 個」を落とすと docs/**\/*.md が docs/a.md に当たらない。
+ * glob の典型的な落とし穴で、設定を書いた人は当たらない理由に気づけない。
+ */
+const DIRS = "\u0000";
+const ANY = "\u0001";
+
+const toPattern = (glob: string): RegExp => {
+  const body = glob
+    .replace(/[.+^${}()|[\]\\]/gu, "\\$&")
+    .replace(/\*\*\//gu, DIRS)
+    .replace(/\*\*/gu, ANY)
+    .replace(/\*/gu, "[^/]*")
+    .replace(/\?/gu, "[^/]")
+    .replaceAll(DIRS, "(?:[^/]*/)*")
+    .replaceAll(ANY, ".*");
+  return new RegExp(`^${body}$`, "u");
+};
+
+/** 設定ファイルからの相対で照合する。実行した場所に左右されないため。 */
+const normalize = (base: string, path: string): string => relative(base, path).split(sep).join("/");
+
+export const matches = (glob: string, base: string, path: string): boolean => toPattern(glob).test(normalize(base, path));
+
+/**
+ * 後に書いたものが勝つ。上から順に当て、最後に当たったものを使う。
+ * 「全体はこう、ここだけは違う」と書けるようにするため。
+ */
+export const applyByPath = (rules: readonly PathRule[], base: string, path: string): { genre?: string; language?: string } =>
+  rules.reduce<{ genre?: string; language?: string }>((acc, rule) => {
+    if (!rule.files.some((glob) => matches(glob, base, path))) return acc;
+    return {
+      ...acc,
+      ...(rule.genre === undefined ? {} : { genre: rule.genre }),
+      ...(rule.language === undefined ? {} : { language: rule.language }),
+    };
+  }, {});

package/src/config/load.ts

@@ -1,22 +1,31 @@
 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";
 
 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 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,
@@ -24,8 +33,11 @@ export const EMPTY: Config = {
   rules: {},
   experimental: false,
   path: undefined,
-  aiModel: DEFAULT_MODEL,
+  aiBackend: DEFAULT_BACKEND,
+  aiModel: defaultModel(DEFAULT_BACKEND),
   confidenceThreshold: 0.7,
+  byPath: [],
+  baseDir: process.cwd(),
 };
 
 const isRecord = (value: unknown): value is Record<string, unknown> => typeof value === "object" && value !== null && !Array.isArray(value);
@@ -37,17 +49,38 @@ const rulesOf = (raw: unknown): Record<string, Level> => {
 
 const str = (value: unknown): string | undefined => (typeof value === "string" ? value : undefined);
 
+/** files は 1 つの文字列でも配列でも書ける。 */
+const globsOf = (value: unknown): string[] => {
+  if (typeof value === "string") return [value];
+  return Array.isArray(value) ? value.map((entry) => String(entry)) : [];
+};
+
+const toPathRule = (raw: unknown): PathRule | undefined => {
+  if (!isRecord(raw)) return undefined;
+  const files = raw["files"];
+  const globs = globsOf(files);
+  if (globs.length === 0) return undefined;
+  return { files: globs, genre: str(raw["genre"]), language: str(raw["language"]) };
+};
+
+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,
+    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/count-per-section.ts

@@ -1,15 +1,39 @@
-import type { Detector, Finding } from "../plugin.ts";
+import { charLength, proseText } from "../measure.ts";
+import type { Detector, Finding, Section } from "../plugin.ts";
 
-/** 節あたりの強調の数。bold-density が使う。 */
+/** これより短い節では密度が暴れる。43 字に 1 箇所で「1000 字あたり 23」になる。 */
+const MIN_CHARS = 200;
+
+const PER = 1000;
+
+const charsOf = (section: Section): number => section.sentences.reduce((sum, sentence) => sum + charLength(sentence), 0);
+
+/**
+ * 節あたりの「密度」を見る。件数ではない。
+ *
+ * 件数で数えると、節が長いほど当たる。実文書で測ると、1095 字に 2 箇所の節と
+ * 557 字に 9 箇所の節が同じ「多すぎる」になっていた。読者が受け取る印象は逆なのに。
+ *
+ * rule の名前（bold-density）が最初から密度と言っていた。件数で実装していたのが誤り。
+ */
 export const countPerSection: Detector = (doc, options): Finding[] =>
   doc.sections
-    .filter((section) => section.strongCount > options.limit)
-    .map((section) => ({
+    .map((section) => ({ section, chars: charsOf(section) }))
+    .filter(({ chars }) => chars >= MIN_CHARS)
+    .map(({ section, chars }) => ({ section, chars, density: Math.round((section.strongCount / chars) * PER) }))
+    .filter(({ density }) => density > options.limit)
+    .map(({ section, chars, density }) => ({
       rule: "bold-density",
       severity: "warning",
       line: 0,
       column: 0,
       // 節全体を引くと段落をまたいで読めなくなる。最初の文だけ見せて場所を示す。
-      quote: section.firstSentence?.text.trim() ?? "",
-      values: { count: section.strongCount, limit: options.limit, offset: section.firstSentence?.span.start ?? section.span.start },
+      quote: section.firstSentence === undefined ? "" : proseText(section.firstSentence),
+      values: {
+        count: density,
+        limit: options.limit,
+        bolds: section.strongCount,
+        chars,
+        offset: section.firstSentence?.span.start ?? section.span.start,
+      },
     }));