chaffjs 0.6.0 → 0.8.0

package/src/orthography.ts

@@ -0,0 +1,115 @@
+// 表記のそろい。書き方の決まりのうち、文字だけで決まるもの。
+
+const escapeRegExp = (text: string): string => text.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
+
+/** text の中で word が現れる [始まり, 終わり) を、左から順に。大文字小文字を区別しないときは i で探す（位置は元の文字列のまま）。 */
+const spansOf = (text: string, word: string, ignoreCase: boolean): [number, number][] => {
+  const pattern = new RegExp(escapeRegExp(word), ignoreCase ? "giu" : "gu");
+  const found: [number, number][] = [];
+  for (let match = pattern.exec(text); match !== null; match = pattern.exec(text)) {
+    found.push([match.index, match.index + match[0].length]);
+    // 重なって現れるものも拾う。次は 1 つ先から探す。
+    pattern.lastIndex = match.index + 1;
+  }
+  return found;
+};
+
+/**
+ * avoid が現れる位置のうち、use の一部として現れたものを除いたもの。
+ * 「ユーザ」を避けて「ユーザー」と書く決まりのとき、「ユーザー」の中の「ユーザ」は指摘しない。
+ * 大文字小文字は区別しない（文頭の「E-mail」も「e-mail」）。ただし二つが大文字小文字だけ違う組
+ * （「Javascript」→「JavaScript」）は、それ自体が大文字小文字の決まりなので区別して探す。
+ */
+export const occurrencesOutside = (text: string, avoid: string, use: string): number[] => {
+  if (avoid === "") return [];
+  const ignoreCase = avoid.toLowerCase() !== use.toLowerCase();
+  const covered = use === "" ? [] : spansOf(text, use, ignoreCase);
+  const found: number[] = [];
+  // covered は始まりの順に並ぶ。始まりが at 以前のものの終わりの最大が end 以上なら、どれかに収まっている。
+  let next = 0;
+  let reach = -1;
+  let at = 0;
+  for (const [start, end] of spansOf(text, avoid, ignoreCase)) {
+    if (start < at) continue;
+    while (next < covered.length && (covered[next]?.[0] ?? Infinity) <= start) {
+      reach = Math.max(reach, covered[next]?.[1] ?? -1);
+      next += 1;
+    }
+    if (reach < end) found.push(start);
+    at = end;
+  }
+  return found;
+};
+
+export type SpacingKind = "letter" | "before-digit" | "after-digit";
+export type Boundary = { readonly offset: number; readonly kind: SpacingKind; readonly spaced: boolean };
+
+const JAPANESE = /[\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}ー]/u;
+const LETTER = /[A-Za-z]/u;
+const DIGIT = /\d/u;
+
+/** Latin 側の字の種類。digitSide は、その数字が日本語の右（前に日本語）か左（後ろに日本語）か。 */
+const kindOf = (char: string | undefined, digitSide: "before-digit" | "after-digit"): SpacingKind | undefined => {
+  if (char === undefined) return undefined;
+  if (LETTER.test(char)) return "letter";
+  return DIGIT.test(char) ? digitSide : undefined;
+};
+
+const isJapanese = (char: string | undefined): boolean => char !== undefined && JAPANESE.test(char);
+
+/** japanese が日本語の字のとき、other の英字・数字の種類。 */
+const latinBeside = (japanese: string | undefined, other: string | undefined, digitSide: "before-digit" | "after-digit"): SpacingKind | undefined =>
+  isJapanese(japanese) ? kindOf(other, digitSide) : undefined;
+
+/** 日本語の字の隣にある英字・数字との境目。間が半角空白 1 つなら「空けている」、何も無ければ「詰めている」。 */
+const ALPHANUMERIC = /[A-Za-z0-9.]/u;
+
+/**
+ * 日本語の左にある英数字の並びの、先頭の字。「3GBの」の「GB」は数量の単位で、並びは数字で始まる。
+ * そうした並びと日本語の境目は、英字の空け方ではなく数字の後ろの空け方として数える（「3回」と同じ）。
+ */
+const runStart = (chars: readonly string[], last: number): string | undefined => {
+  let first = last;
+  while (first > 0 && ALPHANUMERIC.test(chars[first - 1] ?? "")) first -= 1;
+  return chars[first];
+};
+
+/** 左の並びの種類。数字で始まる並び（3GB、10ms）は数字として扱う。 */
+const leftRunBeside = (chars: readonly string[], last: number, japanese: string | undefined): SpacingKind | undefined => {
+  const kind = latinBeside(japanese, chars[last], "after-digit");
+  return kind === "letter" && DIGIT.test(runStart(chars, last) ?? "") ? "after-digit" : kind;
+};
+
+const boundaryAt = (chars: readonly string[], index: number): Omit<Boundary, "offset"> | undefined => {
+  const [left, right, after] = [chars[index], chars[index + 1], chars[index + 2]];
+  const touching = latinBeside(left, right, "before-digit") ?? leftRunBeside(chars, index, right);
+  if (touching !== undefined) return { kind: touching, spaced: false };
+  if (right !== " ") return undefined;
+  const spaced = latinBeside(left, after, "before-digit") ?? leftRunBeside(chars, index, after);
+  return spaced === undefined ? undefined : { kind: spaced, spaced: true };
+};
+
+/** 文の中の境目を全部。offset は境目の位置（左の字の直後、UTF-16）。配列を作り直さずに一度なめる。 */
+export const latinBoundaries = (text: string): Boundary[] => {
+  const chars = [...text];
+  const found: Boundary[] = [];
+  let offset = 0;
+  chars.forEach((char, index) => {
+    offset += char.length;
+    const boundary = boundaryAt(chars, index);
+    if (boundary !== undefined) found.push({ ...boundary, offset });
+  });
+  return found;
+};
+
+/**
+ * 混ざっているとき、そろえるべき少数派。種類（英字・数字の前・数字の後ろ）ごとに数える。
+ * 同数なら、文書が先に使った書き方をその文書の書き方とみなし、後から出た書き方を少数派にする。
+ */
+export const minorityStyle = (boundaries: readonly Boundary[]): boolean | undefined => {
+  const spaced = boundaries.filter((boundary) => boundary.spaced).length;
+  const touching = boundaries.length - spaced;
+  if (spaced === 0 || touching === 0) return undefined;
+  if (spaced !== touching) return spaced < touching;
+  return !(boundaries[0]?.spaced ?? false);
+};

package/src/plugin.ts

@@ -100,6 +100,8 @@ export type NumberedLine = {
    * 枝番号（第3条の2）は並びの外なので付けない。読み方を知っているのは言語パッケージだけなので、core は計算しない。
    */
   readonly ordinal?: number | undefined;
+  /** 一行で番号の範囲をまとめるとき（「第四十三条から第五十五条まで 削除」）の最後の位置。次の番号はここから数える。 */
+  readonly ordinalTo?: number | undefined;
 };
 
 /** 番号を読むときに見える周り。「(i)」がローマ数字か英字かは、開いている番号で決まる。 */
@@ -144,6 +146,10 @@ export type StructureNode = {
   readonly children: readonly StructureNode[];
   /** 番号付きのまとまりの、並びの中の位置（NumberedLine.ordinal）。S 式には出さない。 */
   readonly ordinal?: number;
+  /** 番号付きのまとまりの深さ（NumberedLine.depth）。項と号のように、同じ親の下で別の並びを分ける。S 式には出さない。 */
+  readonly level?: number;
+  /** 範囲をまとめた行の最後の位置（NumberedLine.ordinalTo）。S 式には出さない。 */
+  readonly ordinalTo?: number;
 };
 
 // ───────── 文書モデルと rule ─────────

package/src/reasons.ts

@@ -0,0 +1,44 @@
+import type { Texts } from "./ui.ts";
+
+/** Why a rule did not run, in the document's language. Listed under the findings so "0 findings" is never a silent pass. */
+export type Reasons = {
+  readonly otherLanguage: (language: string) => string;
+  readonly noCapability: (capability: string) => string;
+  readonly noTags: string;
+  readonly semantic: string;
+  readonly experimental: string;
+  readonly turnedOff: string;
+  readonly noStructure: (language: string) => string;
+  readonly noDetector: (name: string) => string;
+  readonly noLexicon: (language: string, list: string) => string;
+};
+
+const CAPABILITY_NAME: Texts<Readonly<Record<string, string>>> = {
+  ja: { pos: "品詞解析", lemma: "原形" },
+  en: { pos: "part-of-speech tagging", lemma: "lemmas" },
+};
+
+export const REASONS: Texts<Reasons> = {
+  ja: {
+    otherLanguage: (language) => `${language} 向けの rule ではないため`,
+    noCapability: (capability) => `この言語では${CAPABILITY_NAME.ja[capability] ?? capability}が使えないため`,
+    noTags: "アダプタが品詞を返さなかったため",
+    semantic: "意味を読む検査のため（npx chaff test で動きます）",
+    experimental: "まだ試験中のため",
+    turnedOff: "設定で止めているため",
+    noStructure: (language) => `${language} のパッケージは文書の構造を読めないため`,
+    noDetector: (name) => `検出器 ${name} がないため`,
+    noLexicon: (language, list) => `${language} の語彙表 ${list} が無いため`,
+  },
+  en: {
+    otherLanguage: (language) => `not a rule for ${language}`,
+    noCapability: (capability) => `${CAPABILITY_NAME.en[capability] ?? capability} is not available for this language`,
+    noTags: "the language package returned no parts of speech",
+    semantic: "it reads meaning; npx chaff test runs it",
+    experimental: "still experimental",
+    turnedOff: "turned off in the settings",
+    noStructure: (language) => `the ${language} package cannot read a document's structure`,
+    noDetector: (name) => `no detector named ${name}`,
+    noLexicon: (language, list) => `the ${language} package has no word list ${list}`,
+  },
+};

package/src/render/explain.ts

@@ -1,39 +1,73 @@
 import { definedLevels, resolve } from "../levels.ts";
 import { localized } from "./text.ts";
+import { uiLanguageOf, type Texts } from "../ui.ts";
 import type { Level, RuleDefinition } from "../plugin.ts";
 
-const levelLine = (rule: RuleDefinition, level: Level, current: Level, genre: string | undefined): string => {
-  const mark = level === current ? "\u2192" : " ";
+const TEXT: Texts<{
+  readonly off: string;
+  readonly defaultGenre: string;
+  readonly genreNote: (genre: string, others: string) => string;
+  readonly experimental: string;
+  readonly howToFix: string;
+  readonly values: (unit: string) => string;
+  readonly now: (level: string) => string;
+  readonly change: (id: string) => string;
+}> = {
+  ja: {
+    off: "見ない",
+    defaultGenre: "既定",
+    genreNote: (genre, others) => `この数字は ${genre} のものです。ほかに ${others} で別の数字を持っています。`,
+    experimental: "このルールはまだ試験中で、既定では動きません（--experimental で動きます）。",
+    howToFix: "直しかた",
+    values: (unit) => `設定できる値（単位: ${unit}）:`,
+    now: (level) => `いまは ${level} です。`,
+    change: (id) => `変える:  npx chaff relax ${id} --why "理由"`,
+  },
+  en: {
+    off: "not checked",
+    defaultGenre: "the default genre",
+    genreNote: (genre, others) => `These numbers are for ${genre}. ${others} have numbers of their own.`,
+    experimental: "This rule is still experimental and does not run by default (--experimental runs it).",
+    howToFix: "How to fix",
+    values: (unit) => `Levels (unit: ${unit}):`,
+    now: (level) => `Now: ${level}.`,
+    change: (id) => `Change it:  npx chaff relax ${id} --why "reason"`,
+  },
+};
+
+const levelLine = (rule: RuleDefinition, level: Level, current: Level, genre: string | undefined, off: string): string => {
+  const mark = level === current ? "→" : " ";
   const name = level.padEnd(9);
-  return level === "off" ? `  ${mark} ${name}見ない` : `  ${mark} ${name}${resolve(rule, level, genre).limit}`;
+  return level === "off" ? `  ${mark} ${name}${off}` : `  ${mark} ${name}${resolve(rule, level, genre).limit}`;
 };
 
 /** ジャンルで数字が変わる rule は、それを言わないと「設定したのに効かない」に見える。 */
-const genreNote = (rule: RuleDefinition, genre: string | undefined): string[] => {
+const genreNote = (rule: RuleDefinition, genre: string | undefined, text: (typeof TEXT)["ja"]): string[] => {
   const others = Object.keys(rule.by_genre).filter((key) => key !== genre);
   if (others.length === 0) return [];
-  return ["", `  この数字は ${genre ?? "既定"} のものです。ほかに ${others.join(" / ")} で別の数字を持っています。`];
+  return ["", `  ${text.genreNote(genre ?? text.defaultGenre, others.join(" / "))}`];
 };
 
 /** rule の意図と根拠を読む。指摘に納得できないときの入口。 */
 export const renderExplain = (rule: RuleDefinition, current: Level, language: string, unit: string, genre?: string): string => {
-  const experimental = rule.status === "experimental" ? ["  このルールはまだ試験中で、既定では動きません（--experimental で動きます）。"] : [];
+  const text = TEXT[uiLanguageOf(language)];
+  const experimental = rule.status === "experimental" ? [`  ${text.experimental}`] : [];
   return [
     "",
     `  ${localized(rule.name, language)}   (${rule.id})`,
     "",
     `  ${localized(rule.why, language)}`,
     "",
-    `  直しかた: ${localized(rule.how_to_fix, language)}`,
+    `  ${text.howToFix}: ${localized(rule.how_to_fix, language)}`,
     "",
-    `  設定できる値（単位: ${unit}）:`,
-    ...definedLevels(rule).map((level) => levelLine(rule, level, current, genre)),
-    ...genreNote(rule, genre),
+    `  ${text.values(unit)}`,
+    ...definedLevels(rule).map((level) => levelLine(rule, level, current, genre, text.off)),
+    ...genreNote(rule, genre, text),
     "",
-    `  いまは ${current} です。`,
+    `  ${text.now(current)}`,
     ...experimental,
     "",
-    `  変える:  npx chaff relax ${rule.id} --why "理由"`,
+    `  ${text.change(rule.id)}`,
     "",
   ].join("\n");
 };

package/src/render/friendly.ts

@@ -2,8 +2,41 @@ import type { Finding, RuleDefinition } from "../plugin.ts";
 import type { RunResult } from "../run.ts";
 import { MARK, localized, messageOf } from "./text.ts";
 import { tally } from "./summary.ts";
+import { uiLanguageOf, type Texts } from "../ui.ts";
 
 const RULE = 60;
+
+const TEXT: Texts<{
+  readonly line: (n: number) => string;
+  readonly relax: string;
+  readonly machine: string;
+  readonly deterministic: string;
+  readonly untouched: string;
+  readonly forced: (n: number, ids: string) => string;
+  readonly notRun: (n: number) => string;
+  readonly because: (why: string) => string;
+}> = {
+  ja: {
+    line: (n) => `${n} 行目`,
+    relax: "このルールをゆるめる",
+    machine: "すべて機械による判定です",
+    deterministic: "              （同じ文章なら何度実行しても同じ結果になります）",
+    untouched: "文章は書き換えていません。直すのは書いた人です。",
+    forced: (n, ids) => `試験中の rule を ${n} 件、設定により有効にしています: ${ids}`,
+    notRun: (n) => `${n} 件の rule は動いていません:`,
+    because: (why) => `（${why}）`,
+  },
+  en: {
+    line: (n) => `line ${n}`,
+    relax: "Relax this rule",
+    machine: "All judged by machine",
+    deterministic: "              (the same text gives the same result every time)",
+    untouched: "The text was not changed. Fixing it is the writer's job.",
+    forced: (n, ids) => `${n} experimental rule${n === 1 ? "" : "s"} turned on in the settings: ${ids}`,
+    notRun: (n) => `${n} rule${n === 1 ? "" : "s"} did not run:`,
+    because: (why) => ` (${why})`,
+  },
+};
 const QUOTE_LIMIT = 120;
 
 const indent = (text: string, pad: string): string[] => text.split("\n").map((line) => `${pad}${line}`);
@@ -21,7 +54,8 @@ const quoteOf = (finding: Finding): string[] => {
  */
 const block = (finding: Finding, rule: RuleDefinition, language: string): string[] => [
   "",
-  `─── ${finding.line} 行目 ${"─".repeat(Math.max(0, RULE - String(finding.line).length - 8))}`,
+  // "12 行目" and "line 12" take the same width on a terminal, so the rule ends in the same column in both.
+  `─── ${TEXT[uiLanguageOf(language)].line(finding.line)} ${"─".repeat(Math.max(0, RULE - String(finding.line).length - 8))}`,
   ...quoteOf(finding),
   "",
   `  ${MARK[finding.severity] ?? "·"}  ${localized(rule.name, language)}`,
@@ -31,7 +65,7 @@ const block = (finding: Finding, rule: RuleDefinition, language: string): string
   "",
   ...indent(`→ ${localized(rule.how_to_fix, language)}`, "     "),
   "",
-  `     このルールをゆるめる:  npx chaff relax ${finding.rule}`,
+  `     ${TEXT[uiLanguageOf(language)].relax}:  npx chaff relax ${finding.rule}`,
   "",
 ];
 
@@ -41,22 +75,20 @@ export const renderFriendly = (header: string, result: RunResult, rules: readonl
     const rule = byId.get(finding.rule);
     return rule === undefined ? [] : block(finding, rule, language);
   });
+  const text = TEXT[uiLanguageOf(language)];
   const notes = [
     "",
     "─".repeat(RULE),
     "",
-    `  ${tally(result.findings)}   すべて機械による判定です`,
-    "              （同じ文章なら何度実行しても同じ結果になります）",
+    `  ${tally(result.findings, uiLanguageOf(language))}   ${text.machine}`,
+    text.deterministic,
     "",
-    "  文章は書き換えていません。直すのは書いた人です。",
+    `  ${text.untouched}`,
   ];
-  const forced =
-    result.forcedExperimental.length > 0
-      ? ["", `  試験中の rule を ${result.forcedExperimental.length} 件、設定により有効にしています: ${result.forcedExperimental.join(", ")}`]
-      : [];
+  const forced = result.forcedExperimental.length > 0 ? ["", `  ${text.forced(result.forcedExperimental.length, result.forcedExperimental.join(", "))}`] : [];
   const skipped =
     result.skipped.length > 0
-      ? ["", `  ${result.skipped.length} 件の rule は動いていません:`, ...result.skipped.map((entry) => `      ${entry.rule}（${entry.why}）`)]
+      ? ["", `  ${text.notRun(result.skipped.length)}`, ...result.skipped.map((entry) => `      ${entry.rule}${text.because(entry.why)}`)]
       : [];
   return ["", header, ...blocks, ...notes, ...forced, ...skipped, ""].join("\n");
 };

package/src/render/rules-json.ts

@@ -1,17 +1,50 @@
 import { definedLevels, resolve } from "../levels.ts";
 import type { Config } from "../config/load.ts";
 import type { RuleDefinition } from "../plugin.ts";
+import { uiLanguageOf, type Texts } from "../ui.ts";
 
-const now = (rule: RuleDefinition, config: Config, genre: string): Record<string, unknown> => {
+const TEXT: Texts<{
+  readonly offBySetting: string;
+  readonly offExperimental: string;
+  readonly valuesNote: string;
+  readonly reason: string;
+  readonly byFile: string;
+}> = {
+  ja: {
+    offBySetting: "設定で止めている",
+    offExperimental: "experimental な rule は既定で動かさない",
+    valuesNote: "この 4 語のかわりに数字を直接書いてもよい。4 語のほうを勧める。",
+    reason: "<理由>",
+    byFile: "chaff.yaml の rules に <rule-id>: <level> を足す。既定のままのものは書かない。",
+  },
+  en: {
+    offBySetting: "turned off in the settings",
+    offExperimental: "experimental rules do not run by default",
+    valuesNote: "A number may be written instead of these four words. The words are recommended.",
+    reason: "<reason>",
+    byFile: "Add <rule-id>: <level> under rules in chaff.yaml. Leave out anything at its default.",
+  },
+};
+
+const now = (rule: RuleDefinition, config: Config, genre: string, text: (typeof TEXT)["ja"]): Record<string, unknown> => {
   const explicit = config.rules[rule.id];
-  if (explicit === "off") return { level: "off", why_off: "設定で止めている" };
+  if (explicit === "off") return { level: "off", why_off: text.offBySetting };
+  const limit = rule.layer === "L4" ? undefined : config.limits[rule.id];
+  if (limit !== undefined) return { level: "normal", limit, set_as: "number" };
   if (explicit !== undefined) return { level: explicit, limit: resolve(rule, explicit, genre).limit };
   if (rule.status === "experimental" && !config.experimental) {
-    return { level: "off", why_off: "experimental な rule は既定で動かさない", turn_on_with: `npx chaff lint --experimental` };
+    return { level: "off", why_off: text.offExperimental, turn_on_with: `npx chaff lint --experimental` };
   }
   return { level: "normal", limit: resolve(rule, "normal", genre).limit };
 };
 
+const yourSetting = (rule: RuleDefinition, config: Config): Record<string, unknown> | null => {
+  const level = config.rules[rule.id];
+  if (level === undefined) return null;
+  const limit = rule.layer === "L4" ? undefined : config.limits[rule.id];
+  return limit === undefined ? { level, from: config.path } : { level, limit, from: config.path };
+};
+
 /** ジャンルで数字が変わる rule があるので、いま効いている表と既定の表の両方を出す。 */
 const levelsOf = (rule: RuleDefinition, genre: string): Record<string, unknown> => {
   const effective = Object.fromEntries(
@@ -24,14 +57,15 @@ const levelsOf = (rule: RuleDefinition, genre: string): Record<string, unknown>
 };
 
 /** AI に設定を書かせるときの入口。推測せずに書けるだけの情報を 1 つに入れる。spec §19.3。 */
-export const rulesJson = (rules: readonly RuleDefinition[], config: Config, language: string, genre: string): string =>
-  JSON.stringify(
+export const rulesJson = (rules: readonly RuleDefinition[], config: Config, language: string, genre: string): string => {
+  const text = TEXT[uiLanguageOf(language)];
+  return JSON.stringify(
     {
       schema_version: 1,
       config_file: "chaff.yaml",
       detected: { genre, language },
       values_you_can_use: ["strict", "normal", "relaxed", "off"],
-      values_note: "この 4 語のかわりに数字を直接書いてもよい。4 語のほうを勧める。",
+      values_note: text.valuesNote,
       rules: rules.map((rule) => ({
         id: rule.id,
         layer: rule.layer,
@@ -42,14 +76,15 @@ export const rulesJson = (rules: readonly RuleDefinition[], config: Config, lang
         use_for: rule.use_for,
         ...levelsOf(rule, genre),
         levels_you_can_set: definedLevels(rule),
-        your_setting: config.rules[rule.id] === undefined ? null : { level: config.rules[rule.id], from: config.path },
-        now: now(rule, config, genre),
+        your_setting: yourSetting(rule, config),
+        now: now(rule, config, genre, text),
       })),
       how_to_change: {
-        by_command: ['npx chaff relax <rule-id> --why "<理由>"', 'npx chaff strict <rule-id> --why "<理由>"', 'npx chaff off <rule-id> --why "<理由>"'],
-        by_file: "chaff.yaml の rules に <rule-id>: <level> を足す。既定のままのものは書かない。",
+        by_command: ["relax", "strict", "off"].map((command) => `npx chaff ${command} <rule-id> --why "${text.reason}"`),
+        by_file: text.byFile,
       },
     },
     null,
     2,
   );
+};

package/src/render/summary.ts

@@ -1,22 +1,47 @@
 import type { Finding } from "../plugin.ts";
+import type { Texts, UiLanguage } from "../ui.ts";
 
 export type FileOutcome = { readonly path: string; readonly findings: readonly Finding[]; readonly notRun: number };
 
 const count = (findings: readonly Finding[], severity: string): number => findings.filter((finding) => finding.severity === severity).length;
 
-export const tally = (findings: readonly Finding[]): string => {
-  const parts = [
-    count(findings, "error") > 0 ? `エラー ${count(findings, "error")} 件` : undefined,
-    count(findings, "warning") > 0 ? `注意 ${count(findings, "warning")} 件` : undefined,
-    count(findings, "info") > 0 ? `参考 ${count(findings, "info")} 件` : undefined,
-  ].filter((part) => part !== undefined);
-  return parts.length === 0 ? "指摘はありません" : parts.join("、");
+type Severity = "error" | "warning" | "info";
+
+const TEXT: Texts<{
+  readonly counts: Readonly<Record<Severity, (n: number) => string>>;
+  readonly join: string;
+  readonly none: string;
+  readonly files: (seen: number, touched: number) => string;
+}> = {
+  ja: {
+    counts: { error: (n) => `エラー ${n} 件`, warning: (n) => `注意 ${n} 件`, info: (n) => `参考 ${n} 件` },
+    join: "、",
+    none: "指摘はありません",
+    files: (seen, touched) => `${seen} ファイルを見て、${touched} ファイルに指摘がありました`,
+  },
+  en: {
+    counts: {
+      error: (n) => `${n} error${n === 1 ? "" : "s"}`,
+      warning: (n) => `${n} warning${n === 1 ? "" : "s"}`,
+      info: (n) => `${n} note${n === 1 ? "" : "s"}`,
+    },
+    join: ", ",
+    none: "No findings",
+    files: (seen, touched) => `${seen} files checked, ${touched} with findings`,
+  },
+};
+
+const SEVERITIES: readonly Severity[] = ["error", "warning", "info"];
+
+export const tally = (findings: readonly Finding[], ui: UiLanguage): string => {
+  const parts = SEVERITIES.filter((severity) => count(findings, severity) > 0).map((severity) => TEXT[ui].counts[severity](count(findings, severity)));
+  return parts.length === 0 ? TEXT[ui].none : parts.join(TEXT[ui].join);
 };
 
 /** 複数ファイルを見たときの締め。1 ファイルのときは出さない。 */
-export const renderSummary = (outcomes: readonly FileOutcome[]): string[] => {
+export const renderSummary = (outcomes: readonly FileOutcome[], ui: UiLanguage): string[] => {
   if (outcomes.length < 2) return [];
   const all = outcomes.flatMap((outcome) => outcome.findings);
   const touched = outcomes.filter((outcome) => outcome.findings.length > 0).length;
-  return ["", "═".repeat(60), "", `  ${outcomes.length} ファイルを見て、${touched} ファイルに指摘がありました`, `  ${tally(all)}`, ""];
+  return ["", "═".repeat(60), "", `  ${TEXT[ui].files(outcomes.length, touched)}`, `  ${tally(all, ui)}`, ""];
 };

package/src/render/suppressions.ts

@@ -1,4 +1,37 @@
 import type { Suppressed, Suppression } from "../stet.ts";
+import type { Texts, UiLanguage } from "../ui.ts";
+
+const TEXT: Texts<{
+  readonly nudge: string;
+  readonly more: (n: number) => string;
+  readonly count: (n: number) => string;
+  readonly reasons: (list: string) => string;
+  readonly relaxAll: (rule: string) => string;
+  readonly none: string;
+  readonly total: (n: number) => string;
+  readonly reasonless: (n: number) => string;
+}> = {
+  ja: {
+    nudge: "  ← 設定の見直しを検討してください",
+    more: (n) => ` ほか ${n} ファイル`,
+    count: (n) => `${String(n).padStart(3)} 件`,
+    reasons: (list) => `理由: ${list}`,
+    relaxAll: (rule) => `ルールごとゆるめる: npx chaff relax ${rule} --why "..."`,
+    none: "\n  抑制されている指摘はありません。\n",
+    total: (n) => `抑制されている指摘: ${n} 件`,
+    reasonless: (n) => `理由が書かれていない抑制: ${n} 件`,
+  },
+  en: {
+    nudge: "  <- consider changing the setting instead",
+    more: (n) => ` and ${n} more file${n === 1 ? "" : "s"}`,
+    count: (n) => `${String(n).padStart(3)}`,
+    reasons: (list) => `reasons: ${list}`,
+    relaxAll: (rule) => `relax the whole rule: npx chaff relax ${rule} --why "..."`,
+    none: "\n  No findings are silenced.\n",
+    total: (n) => `Silenced findings: ${n}`,
+    reasonless: (n) => `Silenced without a reason: ${n}`,
+  },
+};
 
 export type PerFile = { readonly path: string; readonly suppressed: readonly Suppressed[]; readonly reasonless: readonly Suppression[] };
 
@@ -23,16 +56,17 @@ const groupByRule = (files: readonly PerFile[]): Group[] => {
     .sort((left, right) => right.count - left.count);
 };
 
-const groupLines = (group: Group): string[] => {
-  const nudge = group.count >= NUDGE_AT ? "  ← 設定の見直しを検討してください" : "";
+const groupLines = (group: Group, ui: UiLanguage): string[] => {
+  const text = TEXT[ui];
+  const nudge = group.count >= NUDGE_AT ? text.nudge : "";
   const shown = group.files.slice(0, 3).join(", ");
-  const rest = group.files.length > 3 ? ` ほか ${group.files.length - 3} ファイル` : "";
+  const rest = group.files.length > 3 ? text.more(group.files.length - 3) : "";
   return [
     "",
-    `  ${group.rule.padEnd(26)}${String(group.count).padStart(3)} 件${nudge}`,
+    `  ${group.rule.padEnd(26)}${text.count(group.count)}${nudge}`,
     `      ${shown}${rest}`,
     ...(group.count >= NUDGE_AT && group.reasons.length > 0
-      ? [`      理由: ${group.reasons.slice(0, 2).join(" / ")}`, `      ルールごとゆるめる: npx chaff relax ${group.rule} --why "..."`]
+      ? [`      ${text.reasons(group.reasons.slice(0, 2).join(" / "))}`, `      ${text.relaxAll(group.rule)}`]
       : []),
   ];
 };
@@ -42,16 +76,17 @@ const groupLines = (group: Group): string[] => {
  * 同じ rule を何度も黙らせているなら、それは (b) ではなく (c) のサイン。
  * workflow spec §7.3。
  */
-export const renderSuppressions = (files: readonly PerFile[]): string => {
+export const renderSuppressions = (files: readonly PerFile[], ui: UiLanguage = "ja"): string => {
+  const text = TEXT[ui];
   const groups = groupByRule(files);
   const total = groups.reduce((sum, group) => sum + group.count, 0);
-  if (total === 0) return "\n  抑制されている指摘はありません。\n";
+  if (total === 0) return text.none;
   const reasonless = files.flatMap((file) => file.reasonless.map(() => file.path));
   return [
     "",
-    `  抑制されている指摘: ${total} 件`,
-    ...groups.flatMap(groupLines),
-    ...(reasonless.length > 0 ? ["", `  理由が書かれていない抑制: ${reasonless.length} 件`, `      ${[...new Set(reasonless)].join(", ")}`] : []),
+    `  ${text.total(total)}`,
+    ...groups.flatMap((group) => groupLines(group, ui)),
+    ...(reasonless.length > 0 ? ["", `  ${text.reasonless(reasonless.length)}`, `      ${[...new Set(reasonless)].join(", ")}`] : []),
     "",
   ].join("\n");
 };