chaffjs 0.2.0 → 0.3.0

package/rules/unqualified-superlative.yaml

@@ -0,0 +1,26 @@
+id: unqualified-superlative
+layer: L2
+status: experimental
+how_to_find: unqualified-superlative
+word_list: superlative
+severity: warning
+
+name:
+  ja: 比べる相手のない最上級
+  en: Superlative with nothing to compare
+
+why:
+  ja: 「最も速い」だけでは、何と比べて最もなのかがありません。比較対象も条件も無い最上級は、読み手に確かめようがありません。
+  en: '"The fastest" without saying than what leaves the reader nothing to check.'
+
+message:
+  ja: 「{matched}」に比べる相手がありません（そういう言い方が {count} 箇所）
+  en: '"{matched}" has nothing to compare against ({count} such claims)'
+
+how_to_fix:
+  ja: 比較対象か条件を添えてください。「社内の 3 案のうち最も速い」のように。
+  en: Name the comparison. "The fastest of the three options we tried."
+
+levels: { strict: 1, normal: 2, relaxed: 4 }
+
+use_for: [business, blog]

package/src/backends/anthropic.ts

@@ -0,0 +1,61 @@
+import { existsSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import Anthropic from "@anthropic-ai/sdk";
+import { toFailure } from "./types.ts";
+import type { Failure, Judge, Prompt } from "./types.ts";
+
+export type AnthropicResponse = { readonly content: readonly { readonly type: string; readonly text?: string | undefined }[] };
+
+/** judge が使うのは messages.create だけ。最小の面だけを要求する。テストで差し替えられる。 */
+export type AnthropicClient = { readonly messages: { readonly create: (params: Anthropic.MessageCreateParamsNonStreaming) => Promise<AnthropicResponse> } };
+
+const isTextBlock = (block: unknown): block is { readonly text: string } =>
+  typeof block === "object" && block !== null && "text" in block && typeof block.text === "string";
+
+export const DEFAULT_MODEL = "claude-opus-5";
+
+/**
+ * 認証情報があるか。
+ *
+ * env var を見るだけでは足りない。SDK は ANTHROPIC_API_KEY / ANTHROPIC_AUTH_TOKEN /
+ * `ant auth login` のプロファイル / Workload Identity の順に解決するので、env が
+ * 無くても通ることがある。逆に、無いまま呼ぶと SDK は型の無い素の Error を投げる
+ * （AnthropicError でも APIError でもない）ので、あとから種類で判別できない。
+ * だから先に確かめる。
+ */
+const ENV_KEYS = ["ANTHROPIC_API_KEY", "ANTHROPIC_AUTH_TOKEN", "ANTHROPIC_IDENTITY_TOKEN", "ANTHROPIC_IDENTITY_TOKEN_FILE"];
+
+export const configDir = (): string => process.env["ANTHROPIC_CONFIG_DIR"] ?? join(homedir(), ".config", "anthropic");
+
+export const hasCredentials = (profileDir: string = configDir()): boolean =>
+  ENV_KEYS.some((name) => (process.env[name] ?? "").length > 0) || existsSync(profileDir);
+
+export const isAuthFailure = (error: unknown): boolean =>
+  error instanceof Anthropic.AuthenticationError || (error instanceof Anthropic.APIError && error.status === 401);
+
+/** API が返した失敗だけを拾う。ネットワーク断やコードの誤りは、握りつぶさずそのまま投げる。 */
+export const describeFailure = (error: unknown): Failure | undefined => {
+  if (!(error instanceof Anthropic.APIError)) return undefined;
+  const raw: { status: unknown; message: unknown } = error;
+  return toFailure(raw);
+};
+
+export const judge =
+  (client?: AnthropicClient): Judge =>
+  async (prompt: Prompt): Promise<string> => {
+    const anthropic: AnthropicClient = client ?? new Anthropic();
+    const response = await anthropic.messages.create({
+      model: prompt.model,
+      max_tokens: 1024,
+      system: prompt.system,
+      output_config: { format: { type: "json_schema", schema: prompt.schema } },
+      messages: [{ role: "user", content: prompt.user }],
+    });
+    const body = response.content.map((block) => (isTextBlock(block) ? block.text : undefined)).find((text) => text !== undefined);
+    if (body === undefined) throw new Error("判定が返りませんでした");
+    return body;
+  };
+
+/** 認証が無いときに人へ見せる案内。 */
+export const SETUP_HINT = "ANTHROPIC_API_KEY を設定するか、ant auth login を実行してください。";

package/src/backends/openai.ts

@@ -0,0 +1,46 @@
+import OpenAI from "openai";
+import { toFailure } from "./types.ts";
+import type { Failure, Judge, Prompt } from "./types.ts";
+
+export type OpenAIResponse = { readonly choices: readonly { readonly message: { readonly content: string | null } }[] };
+
+/** judge が使うのは chat.completions.create だけ。最小の面だけを要求する。 */
+export type OpenAIClient = {
+  readonly chat: { readonly completions: { readonly create: (params: OpenAI.ChatCompletionCreateParamsNonStreaming) => Promise<OpenAIResponse> } };
+};
+
+export const DEFAULT_MODEL = "gpt-5";
+
+export const hasCredentials = (): boolean => (process.env["OPENAI_API_KEY"] ?? "").length > 0;
+
+export const isAuthFailure = (error: unknown): boolean => error instanceof OpenAI.APIError && error.status === 401;
+
+/** API が返した失敗だけを拾う。ネットワーク断やコードの誤りは、握りつぶさずそのまま投げる。 */
+export const describeFailure = (error: unknown): Failure | undefined => {
+  if (!(error instanceof OpenAI.APIError)) return undefined;
+  const raw: { status: unknown; message: unknown } = error;
+  return toFailure(raw);
+};
+
+/**
+ * 同じ JSON schema をそのまま使う。包みかたが違うだけで、返させる形は provider で変えない。
+ * 変えると、provider を替えたときに判定の意味まで変わる。
+ */
+export const judge =
+  (client?: OpenAIClient): Judge =>
+  async (prompt: Prompt): Promise<string> => {
+    const openai: OpenAIClient = client ?? new OpenAI();
+    const response = await openai.chat.completions.create({
+      model: prompt.model,
+      messages: [
+        { role: "system", content: prompt.system },
+        { role: "user", content: prompt.user },
+      ],
+      response_format: { type: "json_schema", json_schema: { name: "verdict", schema: prompt.schema, strict: true } },
+    });
+    const body = response.choices[0]?.message.content;
+    if (body === null || body === undefined) throw new Error("判定が返りませんでした");
+    return body;
+  };
+
+export const SETUP_HINT = "OPENAI_API_KEY を設定してください。";

package/src/backends/types.ts

@@ -0,0 +1,38 @@
+/**
+ * 判定役の面。ここまでが provider ごとに違い、ここから先は共通。
+ *
+ * 返すのは JSON の文字列で、Verdict への変換と検証は judge.ts が 1 箇所で行う。
+ * provider が増えても「返ってきた形の確かめかた」は増やさない。
+ */
+export type JsonSchema = Readonly<Record<string, unknown>>;
+
+export type Prompt = { readonly system: string; readonly user: string; readonly schema: JsonSchema; readonly model: string };
+
+export type Judge = (prompt: Prompt) => Promise<string>;
+
+export type BackendName = "anthropic" | "openai";
+
+export const BACKENDS: readonly BackendName[] = ["anthropic", "openai"];
+
+export const isBackend = (value: unknown): value is BackendName => BACKENDS.some((name) => name === value);
+
+/** API が返した失敗。生のスタックトレースを人に見せないための、最小の分類。 */
+export type Failure = { readonly kind: "auth" | "quota" | "api"; readonly status: number | undefined; readonly message: string };
+
+const statusOf = (value: unknown): number | undefined => (typeof value === "number" ? value : undefined);
+
+const messageOf = (value: unknown): string => (typeof value === "string" && value.length > 0 ? value : "原因は返ってきませんでした");
+
+const kindOf = (status: number | undefined): Failure["kind"] => {
+  if (status === 401 || status === 403) return "auth";
+  return status === 429 ? "quota" : "api";
+};
+
+/**
+ * SDK の APIError から Failure を作る。分類は provider で変えない。
+ * status と message は SDK 上 any なので、ここで 1 度だけ形を確かめる。
+ */
+export const toFailure = (error: { readonly status: unknown; readonly message: unknown }): Failure => {
+  const status = statusOf(error.status);
+  return { kind: kindOf(status), status, message: messageOf(error.message) };
+};

package/src/cli.ts

@@ -22,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 — 文章の読みにくいところを見つけます。文章は書き換えません。
@@ -30,6 +30,7 @@ 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>           そのルールの意図と根拠を読む
@@ -43,6 +44,7 @@ const USAGE = `chaff — 文章の読みにくいところを見つけます。
   --experimental    試験中の rule も動かす
   --show-baseline   棚上げした分も含めて全部見る
   --watch           保存のたびに見直し、変わったところだけ出す
+  --dry-run         test で、何を AI に送るかだけを見る（API を呼びません）
 
 この箇所だけ黙らせる:  <!-- stet: rule-id — 理由 -->
 
@@ -92,9 +94,11 @@ const inspect = async (path: string, config: Config, argv: readonly string[]): P
   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,
@@ -177,7 +181,7 @@ 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;
 };
 

package/src/commands/eval.ts

@@ -7,6 +7,7 @@ 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 = {
@@ -32,7 +33,9 @@ export const runEval = async (targets: readonly string[], argv: readonly string[
       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);
-      return { doc: buildDocument(path, source, adapter), language, genre: resolveGenre(path, source, config).genre };
+      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";

package/src/commands/test.ts

@@ -7,11 +7,13 @@ 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;
@@ -40,6 +42,41 @@ const judgeAll = async (
     }),
   );
 
+/** 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。
@@ -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,6 +11,7 @@ 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;
@@ -21,7 +24,8 @@ export type Config = {
 };
 
 /** 判定の質が誤検知に直結するので、既定は最上位のモデル。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,7 +33,8 @@ 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(),
@@ -64,13 +69,16 @@ const byPathOf = (raw: unknown): PathRule[] => (Array.isArray(raw) ? raw.map(toP
 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 },
+    }));