chaffjs 0.7.0 → 0.9.0

package/src/commands/feedback.ts

@@ -0,0 +1,210 @@
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { basename, join } from "node:path";
+import type { Finding, RuleDefinition } from "../plugin.ts";
+import type { Config } from "../config/load.ts";
+import { messageOf } from "../render/text.ts";
+import type { Texts, UiLanguage } from "../ui.ts";
+import { excerptsAround } from "../feedback/excerpt.ts";
+import { feedbackDraft, type FeedbackDraft, type FeedbackKind, type ReportedFinding } from "../feedback/draft.ts";
+
+export const FEEDBACK_FILE = ".chaff-feedback.md";
+const NEW_ISSUE = "https://github.com/isamu/lab/issues/new";
+/** GitHub cuts long titles, and a title can carry document text through a rule's message. */
+export const MAX_TITLE_LENGTH = 120;
+
+export type Checked = {
+  readonly findings: readonly Finding[];
+  readonly rules: readonly RuleDefinition[];
+  readonly language: string;
+  readonly genre: string;
+};
+
+export type FeedbackContext = {
+  readonly cwd: string;
+  readonly ui: UiLanguage;
+  readonly version: string;
+  readonly runtime: string;
+  readonly flag: (argv: readonly string[], name: string) => string | undefined;
+  readonly check: (path: string) => Promise<Checked>;
+  /** The reported rules' own settings in chaff.yaml (one line each), or undefined when none are set. */
+  readonly settingsOf: (ruleIds: readonly string[]) => string | undefined;
+};
+
+const TEXT: Texts<{
+  readonly usage: string;
+  readonly notFound: (path: string) => string;
+  readonly badLine: (lines: number) => string;
+  readonly noMatch: (list: string) => string;
+  readonly several: (list: string) => string;
+  readonly none: string;
+  readonly written: (file: string, lines: string) => string;
+  readonly send: string;
+  readonly link: (file: string) => string;
+  readonly neverSent: string;
+}> = {
+  ja: {
+    usage: [
+      "使い方: chaff feedback <file> --rule <rule-id> [--line N] [--with-config]   誤った指摘を報告する",
+      "        chaff feedback <file> --missed --line N [--with-config]           見逃しを報告する",
+    ].join("\n"),
+    notFound: (path) => `${path} がありません。`,
+    badLine: (lines) => `--line には 1〜${String(lines)} の行番号を書いてください。`,
+    noMatch: (list) => `その指摘が見つかりません。この文書の指摘:\n${list}`,
+    several: (list) => `その rule の指摘がいくつもあります。--line で一つ選んでください:\n${list}`,
+    none: "  （指摘はありません）",
+    written: (file, lines) => `報告の下書きを ${file} に書きました。文書から載せたのは ${lines} だけです。送る前に読んで、要らない所は消してください。`,
+    send: "送るには（どちらか）:",
+    link: (file) => `ブラウザで（開いたページに ${file} の中身を貼ります）:`,
+    neverSent: "chaff は何も送っていません。",
+  },
+  en: {
+    usage: [
+      "usage: chaff feedback <file> --rule <rule-id> [--line N] [--with-config]   report a wrong finding",
+      "       chaff feedback <file> --missed --line N [--with-config]           report something chaff missed",
+    ].join("\n"),
+    notFound: (path) => `${path} does not exist.`,
+    badLine: (lines) => `--line must be a line number from 1 to ${String(lines)}.`,
+    noMatch: (list) => `No such finding. The findings in this document:\n${list}`,
+    several: (list) => `That rule has several findings here. Pick one with --line:\n${list}`,
+    none: "  (no findings)",
+    written: (file, lines) =>
+      `Wrote a draft report to ${file}. From the document it includes only ${lines}. Read it before sending, and delete anything you do not want to share.`,
+    send: "To send it (either):",
+    link: (file) => `In a browser (paste the contents of ${file} into the page):`,
+    neverSent: "chaff has not sent anything.",
+  },
+};
+
+const lineList = (lines: readonly number[], ui: UiLanguage): string =>
+  ui === "ja" ? `${lines.join("、")} 行目の前後` : `the lines around ${lines.join(", ")}`;
+
+/** The findings the person picked: by rule, by line, or both. */
+const chosen = (findings: readonly Finding[], rule: string | undefined, line: number | undefined): Finding[] =>
+  findings.filter((finding) => (rule === undefined || finding.rule === rule) && (line === undefined || finding.line === line));
+
+const describe = (findings: readonly Finding[], none: string): string =>
+  findings.length === 0 ? none : findings.map((finding) => `  ${String(finding.line)}  ${finding.rule}`).join("\n");
+
+/** Pure: the reported rules' own lines of chaff.yaml's rules (a numeric limit wins over a level), or undefined when none is set. */
+export const settingsOf = (config: Pick<Config, "rules" | "limits">, ruleIds: readonly string[]): string | undefined => {
+  const lines = [...new Set(ruleIds)].flatMap((id) => {
+    const limit = config.limits[id];
+    const level = config.rules[id];
+    if (limit !== undefined) return [`  ${id}: ${String(limit)}`];
+    return level === undefined ? [] : [`  ${id}: ${level}`];
+  });
+  return lines.length === 0 ? undefined : ["rules:", ...lines].join("\n");
+};
+
+/** Pure: a title on one line, no longer than GitHub shows. */
+export const titleLine = (title: string): string => {
+  const flat = title.replace(/\s+/gu, " ").trim();
+  return flat.length <= MAX_TITLE_LENGTH ? flat : `${flat.slice(0, MAX_TITLE_LENGTH - 1)}…`;
+};
+
+/** Pure: a string a POSIX shell reads literally — single quotes, with any single quote closed, escaped and reopened. */
+export const shellQuoted = (text: string): string => `'${text.replaceAll("'", "'\\''")}'`;
+
+type Request = {
+  readonly path: string;
+  readonly kind: FeedbackKind;
+  readonly rule: string | undefined;
+  readonly line: number | undefined;
+  readonly withConfig: boolean;
+};
+
+/** What the person asked to report. A wrong finding is picked by rule or line; a miss needs the line. */
+const requestOf = (targets: readonly string[], argv: readonly string[], context: FeedbackContext): Request | undefined => {
+  const [path] = targets;
+  const kind: FeedbackKind = argv.includes("--missed") ? "missed" : "false-positive";
+  const rule = context.flag(argv, "--rule");
+  const lineFlag = context.flag(argv, "--line");
+  const line = lineFlag === undefined ? undefined : Number(lineFlag);
+  const lineMissing = kind === "missed" ? line === undefined : rule === undefined && line === undefined;
+  if (path === undefined || targets.length !== 1 || lineMissing || (line !== undefined && !Number.isInteger(line))) return undefined;
+  return { path, kind, rule, line, withConfig: argv.includes("--with-config") };
+};
+
+const reported = (findings: readonly Finding[], checked: Checked): ReportedFinding[] => {
+  const byId = new Map(checked.rules.map((definition) => [definition.id, definition]));
+  return findings.flatMap((finding) => {
+    const definition = byId.get(finding.rule);
+    return definition === undefined ? [] : [{ rule: finding.rule, line: finding.line, message: messageOf(definition, finding, checked.language) }];
+  });
+};
+
+/** The link carries the title only: the body holds document lines, and a URL ends up in history and logs. */
+const sendInstructions = (title: string, lines: readonly number[], ui: UiLanguage): string => {
+  const text = TEXT[ui];
+  return [
+    "",
+    `  ${text.written(FEEDBACK_FILE, lineList([...new Set(lines)], ui))}`,
+    "",
+    `  ${text.send}`,
+    `    gh issue create -R isamu/lab --title ${shellQuoted(title)} --body-file ${FEEDBACK_FILE}`,
+    `  ${text.link(FEEDBACK_FILE)}`,
+    `    ${NEW_ISSUE}?title=${encodeURIComponent(title)}`,
+    "",
+    `  ${text.neverSent}`,
+    "",
+  ].join("\n");
+};
+
+/** Why the request cannot be drafted, or the findings to report. */
+const pick = (request: Request, checked: Checked, lineCount: number, ui: UiLanguage): { readonly error: string } | { readonly findings: Finding[] } => {
+  const text = TEXT[ui];
+  if (request.line !== undefined && (request.line < 1 || request.line > lineCount)) return { error: text.badLine(lineCount) };
+  const picked = chosen(checked.findings, request.rule, request.line);
+  if (request.kind === "missed") return { findings: picked };
+  if (picked.length === 0) return { error: text.noMatch(describe(checked.findings, text.none)) };
+  // One finding per report: a rule picked alone could otherwise pull excerpts from all over the document.
+  if (picked.length > 1) return { error: text.several(describe(picked, text.none)) };
+  return { findings: picked };
+};
+
+/**
+ * `chaff feedback`: an issue draft from a run on the person's own document. It writes a file and prints how to
+ * send it; it never sends anything itself. Only the lines around the reported spot are copied from the document,
+ * and from chaff.yaml only the reported rules' settings unless --with-config is given.
+ */
+export const runFeedback = async (targets: readonly string[], argv: readonly string[], context: FeedbackContext): Promise<number> => {
+  const text = TEXT[context.ui];
+  const request = requestOf(targets, argv, context);
+  if (request === undefined) {
+    console.error(text.usage);
+    return 1;
+  }
+  if (!existsSync(request.path)) {
+    console.error(text.notFound(request.path));
+    return 1;
+  }
+  const source = readFileSync(request.path, "utf8");
+  const checked = await context.check(request.path);
+  const picked = pick(request, checked, source.split("\n").length, context.ui);
+  if ("error" in picked) {
+    console.error(picked.error);
+    return 1;
+  }
+  const findings = reported(picked.findings, checked);
+  const lines = request.kind === "missed" && request.line !== undefined ? [request.line] : findings.map((finding) => finding.line);
+  const configPath = join(context.cwd, "chaff.yaml");
+  const wholeConfig = request.withConfig && existsSync(configPath) ? readFileSync(configPath, "utf8") : undefined;
+  const draft: FeedbackDraft = feedbackDraft(
+    {
+      kind: request.kind,
+      version: context.version,
+      runtime: context.runtime,
+      fileName: basename(request.path),
+      language: checked.language,
+      genre: checked.genre,
+      findings,
+      line: lines[0] ?? 0,
+      excerpts: excerptsAround(source, lines),
+      config: wholeConfig ?? context.settingsOf(findings.map((finding) => finding.rule)),
+    },
+    context.ui,
+  );
+  writeFileSync(join(context.cwd, FEEDBACK_FILE), draft.body, "utf8");
+  console.log(sendInstructions(titleLine(draft.title), lines, context.ui));
+  return 0;
+};

package/src/commands/skill.ts

@@ -0,0 +1,74 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import type { Texts, UiLanguage } from "../ui.ts";
+
+/** The skill ships in the package, beside rules/. Two levels up from src/commands or dist/commands. */
+export const SKILL_SOURCE = join(dirname(fileURLToPath(import.meta.url)), "..", "..", "skills", "chaff", "SKILL.md");
+
+/** Where Claude Code reads a skill: this folder's .claude/skills, or the user's. */
+export const skillTarget = (root: string): string => join(root, ".claude", "skills", "chaff", "SKILL.md");
+
+export type SkillOutcome = { readonly status: "written" | "updated" | "same" | "kept"; readonly path: string };
+
+/**
+ * Writes the skill. A file that is already there and differs may have been edited by hand, so it is replaced
+ * only with `force`; the same file is left alone.
+ */
+export const installSkill = (skill: string, target: string, force: boolean): SkillOutcome => {
+  if (existsSync(target)) {
+    const current = readFileSync(target, "utf8");
+    if (current === skill) return { status: "same", path: target };
+    if (!force) return { status: "kept", path: target };
+    writeFileSync(target, skill, "utf8");
+    return { status: "updated", path: target };
+  }
+  mkdirSync(dirname(target), { recursive: true });
+  writeFileSync(target, skill, "utf8");
+  return { status: "written", path: target };
+};
+
+const TEXT: Texts<Readonly<Record<SkillOutcome["status"], (path: string) => string>>> = {
+  ja: {
+    written: (path) => `Claude Code の skill を書きました: ${path}\nClaude Code を開き直すと /chaff で使えます。`,
+    updated: (path) => `skill を新しい版に置き換えました: ${path}`,
+    same: (path) => `skill は既に最新です: ${path}`,
+    kept: (path) => `${path} は手で直されているかもしれないので、置き換えていません。\n置き換えるときは --force を付けてください。`,
+  },
+  en: {
+    written: (path) => `Wrote the Claude Code skill: ${path}\nReopen Claude Code and it is available as /chaff.`,
+    updated: (path) => `Replaced the skill with the new version: ${path}`,
+    same: (path) => `The skill is up to date: ${path}`,
+    kept: (path) => `${path} may have been edited by hand, so it was not replaced.\nAdd --force to replace it.`,
+  },
+};
+
+const FAILED: Texts<(path: string, why: string) => string> = {
+  ja: (path, why) => `skill を ${path} に書けませんでした: ${why}`,
+  en: (path, why) => `Could not write the skill to ${path}: ${why}`,
+};
+
+/** The outcome, or why the file system refused. */
+const attempt = (install: () => SkillOutcome): SkillOutcome | { readonly failure: string } => {
+  try {
+    return install();
+  } catch (err) {
+    return { failure: err instanceof Error ? err.message : String(err) };
+  }
+};
+
+export type SkillContext = { readonly cwd: string; readonly home: string; readonly ui: UiLanguage };
+
+/** `chaff skill [--global] [--force]`: installs or updates the skill. Exit 1 when a differing file was kept. */
+export const runSkill = (argv: readonly string[], context: SkillContext): number => {
+  const target = skillTarget(argv.includes("--global") ? context.home : context.cwd);
+  const outcome = attempt(() => installSkill(readFileSync(SKILL_SOURCE, "utf8"), target, argv.includes("--force")));
+  if ("failure" in outcome) {
+    console.error(FAILED[context.ui](target, outcome.failure));
+    return 1;
+  }
+  const say = TEXT[context.ui][outcome.status](outcome.path);
+  if (outcome.status === "kept") console.error(say);
+  else console.log(say);
+  return outcome.status === "kept" ? 1 : 0;
+};

package/src/commands/test.ts

@@ -14,6 +14,7 @@ import { MACHINE_BANNER, renderPlan, renderSemantic } from "../render/semantic.t
 import type { Config } from "../config/load.ts";
 import type { Finding, RuleDefinition } from "../plugin.ts";
 import type { Failure } from "../backends/types.ts";
+import { profileFor } from "../profile/for-file.ts";
 
 export type TestContext = {
   readonly config: Config;
@@ -35,7 +36,7 @@ const judgeAll = async (
       const source = await readFile(path, "utf8");
       const language = applyByPath(config.byPath, config.baseDir, path).language ?? config.language ?? guessLanguage(source).language;
       const adapter = await loadAdapter(language);
-      const doc = buildDocument(path, source, adapter, teamRules(config));
+      const doc = buildDocument(path, source, adapter, teamRules(config), profileFor(config, path, source, language));
       const { genre } = resolveGenre(path, source, config);
       const rules = loadRules(language);
       return { path, outcome: await runSemantic(doc, rules, checks, config.rules, genre, options), rules, language };
@@ -55,7 +56,7 @@ const dryRun = async (
       const source = await readFile(path, "utf8");
       const language = applyByPath(config.byPath, config.baseDir, path).language ?? config.language ?? guessLanguage(source).language;
       const adapter = await loadAdapter(language);
-      const doc = buildDocument(path, source, adapter, teamRules(config));
+      const doc = buildDocument(path, source, adapter, teamRules(config), profileFor(config, path, source, language));
       const { genre } = resolveGenre(path, source, config);
       return { path, jobs: planSemantic(doc, loadRules(language), checks, config.rules, genre), sentences: doc.sentences.length };
     }),

package/src/commands/tree.ts

@@ -1,21 +1,42 @@
 import { readFile } from "node:fs/promises";
 import { loadAdapter } from "../adapter-load.ts";
 import { applyByPath } from "../config/by-path.ts";
+import { profileFor } from "../profile/for-file.ts";
 import { guessLanguage } from "../detect.ts";
 import { isMarkdownPath } from "../structure/markdown-path.ts";
 import { buildStructure } from "../structure/of.ts";
 import { toSexp } from "../structure/sexp.ts";
 import type { Config } from "../config/load.ts";
 import type { StructureNode } from "../plugin.ts";
+import type { Texts, UiLanguage } from "../ui.ts";
 
 export type TreeContext = {
   readonly config: Config;
   readonly flag: (argv: readonly string[], name: string) => string | undefined;
+  /** The language chaff speaks in here. Japanese when left out. */
+  readonly ui?: UiLanguage;
 };
 
-const FORMATS = ["sexp", "json"];
+const TEXT: Texts<{
+  readonly usage: string;
+  readonly unreadable: (path: string, why: string) => string;
+  readonly noStructure: (path: string, language: string) => string;
+}> = {
+  ja: {
+    usage: "使い方: chaff tree <file>... [--format sexp|json] [--language ja|en|…]",
+    unreadable: (path, why) => `${path} を読めませんでした: ${why}`,
+    noStructure: (path, language) => `${path}: 言語 ${language} のパッケージは文書の構造を読めません（structure がありません）`,
+  },
+  en: {
+    usage: "usage: chaff tree <file>... [--format sexp|json] [--language ja|en|…]",
+    unreadable: (path, why) => `Could not read ${path}: ${why}`,
+    noStructure: (path, language) => `${path}: the ${language} package cannot read a document's structure (it has no structure)`,
+  },
+};
 
-const USAGE = "使い方: chaff tree <file>... [--format sexp|json] [--language ja|en|…]";
+export const treeText = (context: TreeContext): (typeof TEXT)["ja"] => TEXT[context.ui ?? "ja"];
+
+const FORMATS = ["sexp", "json"];
 
 /** 値を取るフラグ。その次の引数は値で、対象のファイルではない。 */
 const VALUED = ["--format", "--language"];
@@ -23,11 +44,11 @@ const VALUED = ["--format", "--language"];
 export const treeTargets = (argv: readonly string[]): string[] =>
   argv.slice(1).filter((arg, index, all) => !arg.startsWith("--") && !VALUED.includes(all[index - 1] ?? ""));
 
-export const readSource = async (path: string): Promise<string | undefined> => {
+export const readSource = async (path: string, context: TreeContext): Promise<string | undefined> => {
   try {
     return await readFile(path, "utf8");
   } catch (err) {
-    console.error(`${path} を読めませんでした: ${err instanceof Error ? err.message : String(err)}`);
+    console.error(treeText(context).unreadable(path, err instanceof Error ? err.message : String(err)));
     return undefined;
   }
 };
@@ -49,17 +70,18 @@ export type SourceTree = { readonly source: string; readonly tree: StructureNode
  * chaff tree と chaff cite が同じ木を見るように、ここを一つにしておく。
  */
 export const readTree = async (path: string, argv: readonly string[], context: TreeContext): Promise<SourceTree | undefined> => {
-  const source = await readSource(path);
+  const source = await readSource(path, context);
   if (source === undefined) return undefined;
   const language = treeLanguage(path, source, argv, context);
   const adapter = await loadAdapter(language);
   if (adapter.structure === undefined) {
-    console.error(`${path}: 言語 ${language} のパッケージは文書の構造を読めません（structure がありません）`);
+    console.error(treeText(context).noStructure(path, language));
     return undefined;
   }
   // 日本語は形態素で数量と日付を読む。解析器が無ければ単位の表で読むので、木は作れる。
   await adapter.prepare?.({ pos: true });
-  return { source, tree: buildStructure({ path, source, language, markdown: isMarkdownPath(path) }, adapter.structure) };
+  const profile = profileFor(context.config, path, source, language);
+  return { source, tree: buildStructure({ path, source, language, markdown: isMarkdownPath(path), profile }, adapter.structure) };
 };
 
 const printTree = async (path: string, argv: readonly string[], context: TreeContext): Promise<boolean> => {
@@ -86,7 +108,7 @@ export const inOrder = async (paths: readonly string[], each: (path: string) =>
 export const runTree = async (paths: readonly string[], argv: readonly string[], context: TreeContext): Promise<number> => {
   const format = context.flag(argv, "--format") ?? "sexp";
   if (paths.length === 0 || !FORMATS.includes(format)) {
-    console.error(USAGE);
+    console.error(treeText(context).usage);
     return 1;
   }
   const printed = await inOrder(paths, (path) => printTree(path, argv, context));

package/src/config/by-path.ts

@@ -1,6 +1,11 @@
 import { relative, sep } from "node:path";
 
-export type PathRule = { readonly files: readonly string[]; readonly genre: string | undefined; readonly language: string | undefined };
+export type PathRule = {
+  readonly files: readonly string[];
+  readonly genre: string | undefined;
+  readonly language: string | undefined;
+  readonly profile?: string | undefined;
+};
 
 /**
  * glob を正規表現にする。使うのは 3 つだけ。
@@ -36,12 +41,15 @@ export const matches = (glob: string, base: string, path: string): boolean => to
  * 後に書いたものが勝つ。上から順に当て、最後に当たったものを使う。
  * 「全体はこう、ここだけは違う」と書けるようにするため。
  */
-export const applyByPath = (rules: readonly PathRule[], base: string, path: string): { genre?: string; language?: string } =>
-  rules.reduce<{ genre?: string; language?: string }>((acc, rule) => {
+type PathSettings = { genre?: string; language?: string; profile?: string };
+
+export const applyByPath = (rules: readonly PathRule[], base: string, path: string): PathSettings =>
+  rules.reduce<PathSettings>((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 }),
+      ...(rule.profile === undefined ? {} : { profile: rule.profile }),
     };
   }, {});

package/src/config/load.ts

@@ -11,6 +11,8 @@ export const CONFIG_FILE = "chaff.yaml";
 
 export type Config = {
   readonly genre: string | undefined;
+  /** 文書の種類（profiles/*.yaml の id）。none なら内容からも選ばない。 */
+  readonly profile: string | undefined;
   readonly aiBackend: BackendName;
   readonly language: string | undefined;
   readonly rules: Readonly<Record<string, Level>>;
@@ -39,6 +41,7 @@ const DEFAULT_BACKEND: BackendName = "anthropic";
 
 export const EMPTY: Config = {
   genre: undefined,
+  profile: undefined,
   language: undefined,
   rules: {},
   limits: {},
@@ -93,7 +96,7 @@ const toPathRule = (raw: unknown): PathRule | 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"]) };
+  return { files: globs, genre: str(raw["genre"]), language: str(raw["language"]), profile: str(raw["profile"]) };
 };
 
 /** 利用者が書く語の並び。空白だけのものは落とす。 */
@@ -121,6 +124,7 @@ export const loadConfig = (path: string): Config => {
   const backend: BackendName = isBackend(declared) ? declared : DEFAULT_BACKEND;
   return {
     genre: str(raw["genre"]),
+    profile: str(raw["profile"]),
     language: str(raw["language"]),
     rules: rulesOf(raw["rules"]),
     limits: limitsOf(raw["rules"]),

package/src/config/rule-problems.ts

@@ -1,4 +1,23 @@
 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 名と、読めない値。
@@ -7,18 +26,18 @@ import type { Config } from "./load.ts";
 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) => `${where}: ${id} というルールはありません（npx chaff rules --json で一覧が出ます）`);
-  const unreadable = config.unreadableRules
-    .filter((entry) => knownIds.has(entry.id))
-    .map((entry) => `${where}: ${entry.id} の値 ${entry.value} は読めません（strict / normal / relaxed / off か、正の数）`);
+  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) => `${where}: ${id} は意味を読む検査なので数値の上限はありません。normal として動きます（strict / normal / relaxed / off で書いてください）`);
+    .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/char-shape.ts

@@ -1,4 +1,5 @@
-import type { Detector, Finding, Sentence } from "../plugin.ts";
+import type { Detector, DocumentProfile, Finding, Sentence } from "../plugin.ts";
+import { maskAddresses } from "../address-chain.ts";
 import { proseText } from "../measure.ts";
 
 /**
@@ -7,8 +8,8 @@ import { proseText } from "../measure.ts";
  */
 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), "");
+const longestKanji = (sentence: Sentence, profile: DocumentProfile | undefined): string =>
+  [...maskAddresses(proseText(sentence), profile).matchAll(KANJI_RUN)].reduce((longest, match) => (match[0].length > longest.length ? match[0] : longest), "");
 
 /**
  * 漢字が続くと、どこで語が切れるのか読み手が探すことになる。
@@ -16,7 +17,7 @@ const longestKanji = (sentence: Sentence): string =>
  */
 export const kanjiRun: Detector = (doc, options): Finding[] =>
   doc.sentences
-    .map((sentence) => ({ sentence, run: longestKanji(sentence) }))
+    .map((sentence) => ({ sentence, run: longestKanji(sentence, doc.profile) }))
     .filter(({ run }) => run.length > options.limit)
     .map(({ sentence, run }) => ({
       rule: "max-kanji-continuous",