chaffjs 0.6.0 → 0.8.0

package/src/config/load.ts

@@ -14,12 +14,18 @@ export type Config = {
   readonly aiBackend: BackendName;
   readonly language: string | undefined;
   readonly rules: Readonly<Record<string, Level>>;
+  /** rules に数値で書いた上限。段階の 4 語では足りないときに、その rule の数値を直接決める。段階は normal として扱う。 */
+  readonly limits: Readonly<Record<string, number>>;
+  /** rules に書かれていたが読めなかった値。黙って捨てると、書いた設定が効いていないことに気づけない。 */
+  readonly unreadableRules: readonly { readonly id: string; readonly value: string }[];
   readonly experimental: boolean;
   readonly path: string | undefined;
   readonly aiModel: string;
   readonly confidenceThreshold: number;
   /** チームの言葉。社内でしか通じない語を、チームが自分で並べる。 */
   readonly jargon: readonly string[];
+  /** チームの表記。{ 使わない書き方: 使う書き方 }。「サーバー」ではなく「サーバ」、のように。 */
+  readonly prefer: Readonly<Record<string, string>>;
   /** この種類の文書に無いと困る見出し。チームが自分で決める。 */
   readonly requiredSections: readonly string[];
   /** パスごとの上書き。設定ファイルのある場所からの相対で照合する。 */
@@ -35,12 +41,15 @@ export const EMPTY: Config = {
   genre: undefined,
   language: undefined,
   rules: {},
+  limits: {},
+  unreadableRules: [],
   experimental: false,
   path: undefined,
   aiBackend: DEFAULT_BACKEND,
   aiModel: defaultModel(DEFAULT_BACKEND),
   confidenceThreshold: 0.7,
   jargon: [],
+  prefer: {},
   requiredSections: [],
   byPath: [],
   baseDir: process.cwd(),
@@ -48,11 +57,29 @@ export const EMPTY: Config = {
 
 const isRecord = (value: unknown): value is Record<string, unknown> => typeof value === "object" && value !== null && !Array.isArray(value);
 
+const isLimit = (value: unknown): value is number => typeof value === "number" && Number.isFinite(value) && value > 0;
+
+/** 段階の 4 語はそのまま、数値の上限は normal として読む。上限そのものは limitsOf が持つ。 */
 const rulesOf = (raw: unknown): Record<string, Level> => {
   if (!isRecord(raw)) return {};
-  return Object.entries(raw).reduce<Record<string, Level>>((acc, [id, value]) => (isLevel(value) ? { ...acc, [id]: value } : acc), {});
+  return Object.fromEntries(
+    Object.entries(raw).flatMap(([id, value]): [string, Level][] => {
+      if (isLevel(value)) return [[id, value]];
+      return isLimit(value) ? [[id, "normal"]] : [];
+    }),
+  );
 };
 
+const limitsOf = (raw: unknown): Record<string, number> =>
+  isRecord(raw) ? Object.fromEntries(Object.entries(raw).flatMap(([id, value]): [string, number][] => (isLimit(value) ? [[id, value]] : []))) : {};
+
+const unreadableOf = (raw: unknown): { id: string; value: string }[] =>
+  isRecord(raw)
+    ? Object.entries(raw)
+        .filter(([, value]) => !isLevel(value) && !isLimit(value))
+        .map(([id, value]) => ({ id, value: JSON.stringify(value) ?? String(value) }))
+    : [];
+
 const str = (value: unknown): string | undefined => (typeof value === "string" ? value : undefined);
 
 /** files は 1 つの文字列でも配列でも書ける。 */
@@ -72,6 +99,18 @@ const toPathRule = (raw: unknown): PathRule | undefined => {
 /** 利用者が書く語の並び。空白だけのものは落とす。 */
 const wordsOf = (raw: unknown): string[] => (Array.isArray(raw) ? raw.map((entry) => String(entry).trim()).filter((entry) => entry.length > 0) : []);
 
+/** 両側とも空でない文字列の対だけを読む。同じ語どうし（「サーバ: サーバ」）は何も言えないので捨てる。 */
+const preferOf = (raw: unknown): Record<string, string> =>
+  isRecord(raw)
+    ? Object.fromEntries(
+        Object.entries(raw).flatMap(([avoid, use]): [string, string][] => {
+          const from = avoid.trim();
+          const to = typeof use === "string" ? use.trim() : "";
+          return from !== "" && to !== "" && from !== to ? [[from, to]] : [];
+        }),
+      )
+    : {};
+
 const byPathOf = (raw: unknown): PathRule[] => (Array.isArray(raw) ? raw.map(toPathRule).filter((rule) => rule !== undefined) : []);
 
 /** 設定ファイルが無くても動く。あっても、既定から変えたものだけが書かれている。spec §18。 */
@@ -84,12 +123,15 @@ export const loadConfig = (path: string): Config => {
     genre: str(raw["genre"]),
     language: str(raw["language"]),
     rules: rulesOf(raw["rules"]),
+    limits: limitsOf(raw["rules"]),
+    unreadableRules: unreadableOf(raw["rules"]),
     experimental: raw["experimental"] === true,
     path,
     aiBackend: backend,
     aiModel: str(raw["ai_model"]) ?? defaultModel(backend),
     confidenceThreshold: typeof raw["confidence_threshold"] === "number" ? raw["confidence_threshold"] : 0.7,
     jargon: wordsOf(raw["jargon"]),
+    prefer: preferOf(raw["prefer"]),
     requiredSections: wordsOf(raw["required_sections"]),
     byPath: byPathOf(raw["by_path"]),
     baseDir: dirname(path),

package/src/config/rule-problems.ts

@@ -0,0 +1,43 @@
+import type { Config } from "./load.ts";
+import type { Texts, UiLanguage } from "../ui.ts";
+
+const TEXT: Texts<{
+  readonly unknown: (where: string, id: string) => string;
+  readonly unreadable: (where: string, id: string, value: string) => string;
+  readonly numberOnSemantic: (where: string, id: string) => string;
+}> = {
+  ja: {
+    unknown: (where, id) => `${where}: ${id} というルールはありません（npx chaff rules --json で一覧が出ます）`,
+    unreadable: (where, id, value) => `${where}: ${id} の値 ${value} は読めません（strict / normal / relaxed / off か、正の数）`,
+    numberOnSemantic: (where, id) =>
+      `${where}: ${id} は意味を読む検査なので数値の上限はありません。normal として動きます（strict / normal / relaxed / off で書いてください）`,
+  },
+  en: {
+    unknown: (where, id) => `${where}: there is no rule named ${id} (npx chaff rules --json lists them)`,
+    unreadable: (where, id, value) => `${where}: cannot read ${value} as the level of ${id} (strict / normal / relaxed / off, or a positive number)`,
+    numberOnSemantic: (where, id) => `${where}: ${id} reads meaning and has no numeric limit; it runs as normal (write strict / normal / relaxed / off)`,
+  },
+};
+
+/**
+ * chaff.yaml の rules のうち、効いていないもの。知らない rule 名と、読めない値。
+ * どちらも黙って捨てると、書いた人は設定したつもりで何も変わっていない。打ち間違いがいちばん多い。
+ */
+export const ruleProblems = (
+  config: Pick<Config, "rules" | "limits" | "unreadableRules" | "path">,
+  known: readonly { readonly id: string; readonly layer: string }[],
+  ui: UiLanguage = "ja",
+): string[] => {
+  const text = TEXT[ui];
+  const knownIds = new Set(known.map((rule) => rule.id));
+  const where = config.path ?? "chaff.yaml";
+  const written = [...new Set([...Object.keys(config.rules), ...Object.keys(config.limits), ...config.unreadableRules.map((entry) => entry.id)])];
+  const unknown = written.filter((id) => !knownIds.has(id)).map((id) => text.unknown(where, id));
+  const unreadable = config.unreadableRules.filter((entry) => knownIds.has(entry.id)).map((entry) => text.unreadable(where, entry.id, entry.value));
+  // 意味を読む検査（L4）に閾値は無い。数を書いても normal として動くので、そう言う。
+  const semantic = new Set(known.filter((rule) => rule.layer === "L4").map((rule) => rule.id));
+  const numberOnSemantic = Object.keys(config.limits)
+    .filter((id) => semantic.has(id))
+    .map((id) => text.numberOnSemantic(where, id));
+  return [...unknown, ...unreadable, ...numberOnSemantic];
+};

package/src/config/write.ts

@@ -3,14 +3,39 @@ import { Scalar, YAMLMap, isMap, isScalar, parseDocument, type Document } from "
 import { definedLevels } from "../levels.ts";
 import { localized } from "../render/text.ts";
 import type { Level, RuleDefinition } from "../plugin.ts";
+import { uiLanguageOf, type Texts } from "../ui.ts";
 
-const TEMPLATE = `# chaff.yaml — このチームの文章規範
+const TEXT: Texts<{
+  readonly template: string;
+  readonly noSuchLevel: (id: string, level: string) => string;
+  readonly hasReason: (id: string, previous: string) => string;
+  readonly done: (id: string, level: string, path: string) => string;
+}> = {
+  ja: {
+    template: `# chaff.yaml — このチームの文章規範
 #
 # ここに書くのは「既定から変えたもの」だけです。
 # 値は strict / normal / relaxed / off の 4 つから選びます。数字は要りません。
 
 rules:
-`;
+`,
+    noSuchLevel: (id, level) => `${id} に ${level} はありません。normal と同じ設定です。\n設定は変更しませんでした。`,
+    hasReason: (id, previous) => `${id} には既に理由が書かれています:\n  ${previous}\n値を変えるときは --why で新しい理由を書いてください。`,
+    done: (id, level, path) => `${id} を ${level} にしました（${path}）`,
+  },
+  en: {
+    template: `# chaff.yaml — this team's writing rules
+#
+# Write only what differs from the defaults.
+# A level is one of strict / normal / relaxed / off. No numbers needed.
+
+rules:
+`,
+    noSuchLevel: (id, level) => `${id} has no ${level} level; it is the same as normal.\nThe settings were not changed.`,
+    hasReason: (id, previous) => `${id} already has a reason:\n  ${previous}\nTo change the level, give a new reason with --why.`,
+    done: (id, level, path) => `Set ${id} to ${level} (${path})`,
+  },
+};
 
 export type ChangeOutcome = { readonly ok: boolean; readonly message: string };
 
@@ -24,7 +49,7 @@ const reasonOf = (value: unknown): string | undefined => {
 
 const ruleComment = (rule: RuleDefinition, language: string): string => ` ${localized(rule.name, language)}\n ${localized(rule.why, language)}`;
 
-const load = (path: string): Document => parseDocument(existsSync(path) ? readFileSync(path, "utf8") : TEMPLATE);
+const load = (path: string, language: string): Document => parseDocument(existsSync(path) ? readFileSync(path, "utf8") : TEXT[uiLanguageOf(language)].template);
 
 /**
  * 設定を機械的に書き換えるが、**既存のコメントを壊さない**。
@@ -32,10 +57,9 @@ const load = (path: string): Document => parseDocument(existsSync(path) ? readFi
  * spec §19.4。
  */
 export const applyLevel = (path: string, rule: RuleDefinition, level: Level, why: string | undefined, language: string, who: string): ChangeOutcome => {
-  if (!definedLevels(rule).includes(level)) {
-    return { ok: false, message: `${rule.id} に ${level} はありません。normal と同じ設定です。\n設定は変更しませんでした。` };
-  }
-  const doc = load(path);
+  const text = TEXT[uiLanguageOf(language)];
+  if (!definedLevels(rule).includes(level)) return { ok: false, message: text.noSuchLevel(rule.id, level) };
+  const doc = load(path, language);
   const rules = doc.get("rules");
   const map = isMap(rules) ? rules : new YAMLMap();
   // 人が読んで書き足すファイルなので、必ず block style にする。flow style（{ a: b }）は読めない。
@@ -45,7 +69,7 @@ export const applyLevel = (path: string, rule: RuleDefinition, level: Level, why
   const previous = reasonOf(existing?.value);
   // 古い理由が新しい値に付いたまま残ると、履歴が嘘になる。
   if (previous !== undefined && why === undefined) {
-    return { ok: false, message: `${rule.id} には既に理由が書かれています:\n  ${previous}\n値を変えるときは --why で新しい理由を書いてください。` };
+    return { ok: false, message: text.hasReason(rule.id, previous) };
   }
   // 取り除いて足し直すと、元の rule に付いていた説明コメントが行き場を失って残る。
   // 既にある鍵は、その場で値だけ差し替える。
@@ -59,5 +83,5 @@ export const applyLevel = (path: string, rule: RuleDefinition, level: Level, why
     existing.value = value;
   }
   writeFileSync(path, String(doc), "utf8");
-  return { ok: true, message: `${rule.id} を ${level} にしました（${path}）` };
+  return { ok: true, message: text.done(rule.id, level, path) };
 };

package/src/detectors/index.ts

@@ -14,6 +14,7 @@ import { paragraphLength, paragraphVariance, preambleLength, ruleOfThree, sectio
 import { concreteEvidence, dashDensity, emojiDensity, ngramRepetition, undefinedAcronym } from "./signals.ts";
 import { aiTell, contractionMix, cushionDensity, hedgingDensity, repeatedConjunction, unqualifiedSuperlative } from "./lexicon.ts";
 import { internalJargon, properNounDensity, requiredSections } from "./team.ts";
+import { latinSpacing, preferredTerm } from "./orthography.ts";
 import { danglingReference, duplicateDefinition, numberingGap } from "./structure-tree.ts";
 
 /** rule 定義の how_to_find がここを引く。rule 側は実装を知らない。 */
@@ -54,6 +55,8 @@ export const DETECTORS: Readonly<Record<string, Detector>> = {
   "internal-jargon": internalJargon,
   "required-sections": requiredSections,
   "proper-noun-density": properNounDensity,
+  "preferred-term": preferredTerm,
+  "latin-spacing": latinSpacing,
   "dangling-reference": danglingReference,
   "numbering-gap": numberingGap,
   "duplicate-definition": duplicateDefinition,

package/src/detectors/orthography.ts

@@ -0,0 +1,55 @@
+import type { Detector, Finding, Sentence } from "../plugin.ts";
+import { latinBoundaries, minorityStyle, occurrencesOutside, type SpacingKind } from "../orthography.ts";
+
+/** チームが chaff.yaml の prefer に書いた「使わない書き方」。書いていなければ何も言わない。 */
+export const preferredTerm: Detector = (doc, options): Finding[] => {
+  const pairs = (options.lexicon ?? []).flatMap((entry) => (entry.instead_of === undefined ? [] : [{ avoid: entry.pattern, use: entry.instead_of }]));
+  const hits = doc.sentences.flatMap((sentence) =>
+    pairs.flatMap((pair) => occurrencesOutside(sentence.text, pair.avoid, pair.use).map((at) => ({ sentence, at, pair }))),
+  );
+  if (hits.length === 0 || hits.length < options.limit) return [];
+  return hits.map((hit) => ({
+    rule: "",
+    severity: "warning",
+    line: 0,
+    column: 0,
+    quote: hit.sentence.text.trim(),
+    values: { matched: hit.pair.avoid, preferred: hit.pair.use, count: hits.length, limit: options.limit, offset: hit.sentence.span.start + hit.at },
+  }));
+};
+
+const KIND_NAME: Readonly<Record<SpacingKind, string>> = { letter: "英字", "before-digit": "後ろの数字", "after-digit": "前の数字" };
+const KINDS: readonly SpacingKind[] = ["letter", "before-digit", "after-digit"];
+
+type Located = { readonly sentence: Sentence; readonly offset: number; readonly kind: SpacingKind; readonly spaced: boolean };
+
+/**
+ * 日本語と英字・数字のあいだを、空けるか詰めるか。文書の中で混ざっていたら、少ないほうを指摘する。
+ * どちらが正しいかは決めない。決めるのはチームで、chaff はそろっているかだけを見る。
+ */
+export const latinSpacing: Detector = (doc, options): Finding[] => {
+  const located: Located[] = doc.sentences.flatMap((sentence) => latinBoundaries(sentence.text).map((boundary) => ({ sentence, ...boundary })));
+  return KINDS.flatMap((kind) => {
+    const ofKind = located.filter((entry) => entry.kind === kind);
+    const minority = minorityStyle(ofKind);
+    if (minority === undefined) return [];
+    const odd = ofKind.filter((entry) => entry.spaced === minority);
+    if (odd.length < options.limit) return [];
+    return odd.map((entry) => ({
+      rule: "",
+      severity: "warning",
+      line: 0,
+      column: 0,
+      quote: entry.sentence.text.trim(),
+      values: {
+        kind: KIND_NAME[kind],
+        style: minority ? "空けています" : "詰めています",
+        usual: minority ? "詰める" : "空ける",
+        count: odd.length,
+        of: ofKind.length,
+        limit: options.limit,
+        offset: entry.sentence.span.start + entry.offset,
+      },
+    }));
+  });
+};

package/src/document.ts

@@ -3,6 +3,7 @@ import { gfmTable } from "micromark-extension-gfm-table";
 import { gfmTableFromMarkdown } from "mdast-util-gfm-table";
 import { frontmatter } from "micromark-extension-frontmatter";
 import { frontmatterFromMarkdown } from "mdast-util-frontmatter";
+import { atxHeadingText, headingText } from "./heading-text.ts";
 import { maskSpans } from "./mask.ts";
 import { buildTree, NO_OUTLINE, type Outline } from "./structure/build.ts";
 import { isMarkdownPath } from "./structure/markdown-path.ts";
@@ -130,7 +131,10 @@ const headingsOf = (root: Node, source: string): Heading[] => {
     if (node.type !== "heading") return;
     const span = spanOf(node);
     const depth = typeof node === "object" && "depth" in node && typeof node.depth === "number" ? node.depth : 1;
-    if (span !== undefined) found.push({ depth, text: textOf(node, source).trim(), start: span.start, end: span.end });
+    if (span === undefined) return;
+    // ATX（行頭が #）なら閉じの # も外す。setext の見出しの末尾の # は言葉なので残す。
+    const read = source.startsWith("#", span.start) ? atxHeadingText : headingText;
+    found.push({ depth, text: read(textOf(node, source)), start: span.start, end: span.end });
   });
   return found;
 };
@@ -229,13 +233,23 @@ const listsOf = (root: Node, source: string): BulletList[] => {
 };
 
 /** チームが chaff.yaml に書いたもの。語彙表と同じ器に入れて、detector には出所を見せない。 */
-export type TeamRules = { readonly jargon: readonly string[]; readonly requiredSections: readonly string[] };
+export type TeamRules = {
+  readonly jargon: readonly string[];
+  readonly requiredSections: readonly string[];
+  /** { 使わない書き方: 使う書き方 }。preferred-term が語彙表として読む。 */
+  readonly prefer?: Readonly<Record<string, string>>;
+};
 
 const EMPTY_TEAM: TeamRules = { jargon: [], requiredSections: [] };
 
 /** Config から取り出す。document は Config の形を知らない。 */
-export const teamRules = (config: { readonly jargon: readonly string[]; readonly requiredSections: readonly string[] }): TeamRules => ({
+export const teamRules = (config: {
+  readonly jargon: readonly string[];
+  readonly requiredSections: readonly string[];
+  readonly prefer?: Readonly<Record<string, string>>;
+}): TeamRules => ({
   jargon: config.jargon,
+  prefer: config.prefer ?? {},
   requiredSections: config.requiredSections,
 });
 
@@ -263,7 +277,12 @@ export const buildDocument = (path: string, source: string, adapter: LanguageAda
     listSpans: listItems,
     paragraphs: paragraphsOf(paragraphSpans, sentences, listItems),
     lists: listsOf(root, source),
-    lexicons: { ...adapter.lexicons, "internal-jargon": team.jargon.map((pattern) => ({ pattern })) },
+    lexicons: {
+      ...adapter.lexicons,
+      "internal-jargon": team.jargon.map((pattern) => ({ pattern })),
+      // 使わない書き方を pattern に、使う書き方を instead_of に置く。語彙表の「同じことの別の書き方」と同じ向き。
+      "preferred-term": Object.entries(team.prefer ?? {}).map(([pattern, use]) => ({ pattern, instead_of: use })),
+    },
     requiredSections: team.requiredSections,
     // 構造の rule（参照先が無い・番号の抜け）が読む木。どの rule も読まなければ作らない。何万行の契約書で、他の rule の lint に代金を払わせない。
     get structure(): StructureNode | undefined {

package/src/eval.ts

@@ -35,11 +35,12 @@ const stricterIsHigher = (rule: RuleDefinition): boolean => (rule.levels.strict
 const MULTIPLIERS = [0.5, 0.7, 0.85, 1, 1.25, 1.5, 2, 3];
 
 /** rule 自身が持つ段を基点に掃引する。rule ごとに単位が違うので、倍率で散らす。 */
-const candidates = (rule: RuleDefinition): number[] => {
+const candidates = (rule: RuleDefinition, current: number): number[] => {
   const base = rule.levels.normal ?? 1;
   const fromLevels = [rule.levels.strict, rule.levels.normal, rule.levels.relaxed].filter((value) => value !== undefined);
   const scaled = MULTIPLIERS.map((factor) => Math.max(1, Math.round(base * factor)));
-  return [...new Set([...fromLevels, ...scaled])].sort((left, right) => left - right);
+  // 数値で決めた上限は、段の表に無くても掃引に入れる。入れないと「現在」の行が出ない。
+  return [...new Set([...fromLevels, ...scaled, current])].sort((left, right) => left - right);
 };
 
 const countAt = (docs: readonly ProseDocument[], rule: RuleDefinition, limit: number): Point => {
@@ -84,12 +85,22 @@ const measurable = (rule: RuleDefinition, docs: readonly ProseDocument[], genre:
   return rule.requires.every((need) => meets(need, docs));
 };
 
-export const evaluate = (docs: readonly ProseDocument[], rules: readonly RuleDefinition[], genre: string, language: string): RuleReport[] =>
+/**
+ * limits は chaff.yaml に数値で書いた上限。書いてあれば、それが lint で効いている「現在」の値。
+ * 段の言葉（relaxed など）で書いた設定は、これまでどおり normal の値を「現在」とする。
+ */
+export const evaluate = (
+  docs: readonly ProseDocument[],
+  rules: readonly RuleDefinition[],
+  genre: string,
+  language: string,
+  limits: Readonly<Record<string, number>> = {},
+): RuleReport[] =>
   rules
     .filter((rule) => measurable(rule, docs, genre, language))
     .map((rule) => {
-      const sweep = candidates(rule).map((limit) => countAt(docs, rule, limit));
-      const current = rule.levels.normal ?? 1;
+      const current = limits[rule.id] ?? rule.levels.normal ?? 1;
+      const sweep = candidates(rule, current).map((limit) => countAt(docs, rule, limit));
       return {
         rule: rule.id,
         name: rule.name[language] ?? rule.id,

package/src/genre.ts

@@ -1,4 +1,4 @@
-export type GenreGuess = { readonly genre: string; readonly from: string };
+export type GenreGuess = { readonly genre: string; readonly from: "front-matter" | "path" | "content" };
 
 /**
  * 仕様書・README は「読ませる文章」ではなく「間違えさせない文章」。
@@ -27,11 +27,11 @@ const BY_CONTENT: readonly (readonly [RegExp, string])[] = [
 ];
 
 export const guessGenre = (path: string, source: string, front: string | undefined): GenreGuess | undefined => {
-  if (front !== undefined) return { genre: front, from: "front matter" };
+  if (front !== undefined) return { genre: front, from: "front-matter" };
   const byPath = BY_PATH.find(([pattern]) => pattern.test(path));
-  if (byPath !== undefined) return { genre: byPath[1], from: "パス" };
+  if (byPath !== undefined) return { genre: byPath[1], from: "path" };
   const byContent = BY_CONTENT.find(([pattern]) => pattern.test(source));
-  if (byContent !== undefined) return { genre: byContent[1], from: "内容" };
+  if (byContent !== undefined) return { genre: byContent[1], from: "content" };
   return undefined;
 };
 

package/src/heading-text.ts

@@ -0,0 +1,26 @@
+/**
+ * 見出しの末尾に付けた属性を外した、見出しの言葉。`## ステップ 1 {#step1}` は「ステップ 1」。
+ * kramdown（`{#id}`、`{: .class}`）と pandoc（`{#id .class}`）の書き方。属性は読者に見えないので、
+ * 残すと見出しの言い直しや番号の読み取りが、見えない文字に引きずられる。
+ * 波括弧で終わっていても、中身が `#` `.` `:` で始まらないもの（`## {name} の設定`）は言葉のうち。
+ */
+export const headingText = (raw: string): string => {
+  const trimmed = raw.trim();
+  if (!trimmed.endsWith("}")) return trimmed;
+  const open = trimmed.lastIndexOf("{");
+  if (open === -1) return trimmed;
+  const inner = trimmed.slice(open + 1, -1).trimStart();
+  const isAttributes = inner.startsWith("#") || inner.startsWith(".") || inner.startsWith(":");
+  return isAttributes ? trimmed.slice(0, open).trim() : trimmed;
+};
+
+/**
+ * ATX 見出し（`## 見出し ##`）の言葉。属性を外してから、閉じの `#` を外す。
+ * `## Install ## {#install}` は閉じの `#` の後ろに属性があるので、この順でないと `##` が言葉に残る。
+ * 下線で書く見出し（setext）には使わない。そちらの末尾の `##` は本当に言葉の一部。
+ */
+export const atxHeadingText = (content: string): string => {
+  const withoutAttributes = headingText(content);
+  const closing = withoutAttributes.search(/(?:^|[ \t])#+$/u);
+  return (closing === -1 ? withoutAttributes : withoutAttributes.slice(0, closing)).trim();
+};

package/src/init.ts

@@ -1,7 +1,21 @@
 import { appendFileSync, existsSync, readFileSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
+import type { Texts, UiLanguage } from "./ui.ts";
 
-const CONFIG = (genre: string): string => `# chaff.yaml — このチームの文章規範
+const TEXT: Texts<{
+  readonly config: (genre: string) => string;
+  readonly created: string;
+  readonly appended: (lines: readonly string[]) => string;
+  readonly configNote: string;
+  readonly exists: string;
+  readonly createdHeading: string;
+  readonly genreChosen: (genre: string) => string;
+  readonly genreList: string;
+  readonly next: string;
+  readonly nextCheck: string;
+}> = {
+  ja: {
+    config: (genre) => `# chaff.yaml — このチームの文章規範
 #
 # ここに書くのは「既定から変えたもの」だけです。書かなければ既定で動きます。
 # このファイルを消しても chaff は動きます。
@@ -24,7 +38,53 @@ genre: ${genre}
 
 # 既定から変えたものだけを書く。
 rules:
-`;
+`,
+    created: "作成しました",
+    appended: (lines) => `${lines.join(" と ")} を追記しました`,
+    configNote: "規範の宣言。commit してください",
+    exists: "chaff.yaml は既にあります。変更していません。",
+    createdHeading: "作成しました:",
+    genreChosen: (genre) => `ジャンルは ${genre} にしました。違う場合は chaff.yaml の genre を直してください。`,
+    genreList: "  一覧: npx chaff genres",
+    next: "次:",
+    nextCheck: "  npx chaff .            この場所の Markdown を全部見る",
+  },
+  en: {
+    config: (genre) => `# chaff.yaml — this team's writing rules
+#
+# Write only what differs from the defaults; anything left out uses the default.
+# chaff still runs if this file is deleted.
+#
+# A level is one of four words. No numbers needed.
+#
+#   strict    check closely
+#   normal    the default
+#   relaxed   check loosely
+#   off       do not check
+#
+# Commands change it too, and leave the reason as a comment.
+#
+#   npx chaff relax bold-density --why "figure captions use a lot of bold"
+#   npx chaff explain bold-density        read what the rule is for
+#   npx chaff rules --json                give this to an AI that writes the settings
+
+# The kind of document kept here.
+genre: ${genre}
+
+# Only what differs from the defaults.
+rules:
+`,
+    created: "created",
+    appended: (lines) => `added ${lines.join(" and ")}`,
+    configNote: "the team's rules; commit it",
+    exists: "chaff.yaml already exists. Nothing was changed.",
+    createdHeading: "Created:",
+    genreChosen: (genre) => `The genre is ${genre}. If that is wrong, change genre in chaff.yaml.`,
+    genreList: "  List: npx chaff genres",
+    next: "Next:",
+    nextCheck: "  npx chaff .            check every Markdown file here",
+  },
+};
 
 /** 判定のキャッシュと、鍵を書くファイル。どちらも commit しない。 */
 const GITIGNORE_LINES = [".chaff-cache/", ".env*"];
@@ -38,31 +98,30 @@ const writeIfAbsent = (path: string, body: string, note: string): Written | unde
 };
 
 /** 判定のキャッシュと .env は commit しない。init が .gitignore に足す。 */
-const ensureGitignore = (dir: string): Written | undefined => {
+const ensureGitignore = (dir: string, text: (typeof TEXT)["ja"]): Written | undefined => {
   const path = join(dir, ".gitignore");
-  if (!existsSync(path)) return writeIfAbsent(path, `${GITIGNORE_LINES.join("\n")}\n`, "作成しました");
+  if (!existsSync(path)) return writeIfAbsent(path, `${GITIGNORE_LINES.join("\n")}\n`, text.created);
   const body = readFileSync(path, "utf8");
   const missing = GITIGNORE_LINES.filter((line) => !body.split("\n").includes(line));
   if (missing.length === 0) return undefined;
   appendFileSync(path, `${missing.join("\n")}\n`, "utf8");
-  return { path, note: `${missing.join(" と ")} を追記しました` };
+  return { path, note: text.appended(missing) };
 };
 
-export const runInit = (dir: string, genre: string): string[] => {
-  const made = [writeIfAbsent(join(dir, "chaff.yaml"), CONFIG(genre), "規範の宣言。commit してください"), ensureGitignore(dir)].filter(
-    (entry) => entry !== undefined,
-  );
-  if (made.length === 0) return ["chaff.yaml は既にあります。変更していません。"];
+export const runInit = (dir: string, genre: string, ui: UiLanguage = "ja"): string[] => {
+  const text = TEXT[ui];
+  const made = [writeIfAbsent(join(dir, "chaff.yaml"), text.config(genre), text.configNote), ensureGitignore(dir, text)].filter((entry) => entry !== undefined);
+  if (made.length === 0) return [text.exists];
   return [
     "",
-    "作成しました:",
+    text.createdHeading,
     ...made.map((entry) => `  ${entry.path}  ${entry.note}`),
     "",
-    `ジャンルは ${genre} にしました。違う場合は chaff.yaml の genre を直してください。`,
-    "  一覧: npx chaff genres",
+    text.genreChosen(genre),
+    text.genreList,
     "",
-    "次:",
-    "  npx chaff .            この場所の Markdown を全部見る",
+    text.next,
+    text.nextCheck,
     "",
   ];
 };