chaffjs 0.0.1

package/rules/closing-cliche.yaml

@@ -0,0 +1,30 @@
+id: closing-cliche
+layer: L2
+status: stable
+how_to_find: phrase-match
+word_list: closing-cliche
+where: closing
+severity: warning
+
+name:
+  ja: 定型の結び
+  en: Cliched closing
+
+why:
+  ja: 「いかがでしたか」で終わる記事は、読者に何も残しません。結びは最後の主張の場所です。
+  en: A closing that only thanks the reader leaves nothing behind.
+
+message:
+  ja: 「{matched}」で締めています
+  en: 'Closes with "{matched}"'
+
+how_to_fix:
+  ja: 本文で分かったことのうち、いちばん持ち帰ってほしい 1 つを書いてください。
+  en: Name the one thing you want the reader to take away.
+
+levels:
+  strict: 1
+  normal: 1
+  relaxed: 2
+
+use_for: [blog]

package/rules/empty-intensifier.yaml

@@ -0,0 +1,29 @@
+id: empty-intensifier
+layer: L2
+status: stable
+how_to_find: phrase-match
+word_list: empty-intensifier
+severity: warning
+
+name:
+  ja: 空虚な強調
+  en: Empty intensifier
+
+why:
+  ja: 「非常に重要」は、何がどう重要なのかを言っていません。強調した気になるだけです。
+  en: '"Extremely important" does not say what matters or why. It only feels emphatic.'
+
+message:
+  ja: 「{matched}」は、中身を言わずに強調だけしています
+  en: '"{matched}" emphasises without saying anything'
+
+how_to_fix:
+  ja: 何がどう重要なのかを書いてください。書けないなら、その一文は落とせます。
+  en: Say what matters and why. If you cannot, the sentence can go.
+
+levels:
+  strict: 1
+  normal: 1
+  relaxed: 3
+
+use_for: [blog, business]

package/rules/heading-echo.yaml

@@ -0,0 +1,30 @@
+id: heading-echo
+layer: L1
+status: stable
+how_to_find: heading-echo
+severity: warning
+
+name:
+  ja: 見出しの繰り返し
+  en: Heading echoed
+
+why:
+  ja: 見出しで言ったことを次の文が繰り返すと、読者はそこで何も受け取れません。
+  en: When the first sentence repeats the heading, the reader gains nothing by reading on.
+
+message:
+  ja: 見出し「{heading}」を直後の文がほぼそのまま繰り返しています
+  en: The first sentence repeats the heading "{heading}"
+
+how_to_fix:
+  ja: 見出しが約束したことの中身から書き始めてください。
+  en: Start from what the heading promised, not from the heading itself.
+
+# 見出しの文字 3-gram のうち、直後の文に現れた割合（包含率）。100 分率で持つ。
+# Jaccard ではない理由は detectors/heading-echo.ts を参照。
+levels:
+  strict: 45
+  normal: 60
+  relaxed: 75
+
+use_for: [blog, business]

package/rules/max-sentence-length.yaml

@@ -0,0 +1,28 @@
+id: max-sentence-length
+layer: L1
+status: stable
+how_to_find: sentence-length
+severity: warning
+
+name:
+  ja: 一文が長すぎる
+  en: Sentence too long
+
+why:
+  ja: 長い文は、読んでいるうちに主語を見失います。
+  en: In a long sentence the reader loses the subject before reaching the verb.
+
+message:
+  ja: この文は {count} 文字あります（{limit} 文字まで）
+  en: "This sentence runs {count} words (limit {limit})"
+
+how_to_fix:
+  ja: 接続助詞のところで 2 文に割ってください。それだけで読めるようになります。
+  en: Split it in two at the conjunction.
+
+# 単位は adapter の lengthUnit。日本語は文字、英語は語。spec §7。
+levels:
+  ja: { strict: 70, normal: 100, relaxed: 140 }
+  en: { strict: 18, normal: 25, relaxed: 35 }
+
+use_for: [blog, business]

package/rules/padded-intro.yaml

@@ -0,0 +1,30 @@
+id: padded-intro
+layer: L2
+status: stable
+how_to_find: phrase-match
+word_list: padded-intro
+where: opening
+severity: warning
+
+name:
+  ja: 水増しの導入
+  en: Padded opening
+
+why:
+  ja: どの記事にも当てはまる書き出しは、読者に次を読む理由を与えません。
+  en: An opening that fits any article gives the reader no reason to continue.
+
+message:
+  ja: 「{matched}」は、どの記事にも当てはまる書き出しです
+  en: '"{matched}" is an opening that fits any article'
+
+how_to_fix:
+  ja: 具体的な状況か、この記事だけの主張から始めてください。
+  en: Start from a concrete situation, or from the claim only this piece makes.
+
+levels:
+  strict: 1
+  normal: 1
+  relaxed: 2
+
+use_for: [blog]

package/rules/repeated-sentence-head.yaml

@@ -0,0 +1,28 @@
+id: repeated-sentence-head
+layer: L1
+status: stable
+how_to_find: repeated-head
+severity: warning
+
+name:
+  ja: 同じ書き出しの連続
+  en: Repeated sentence opening
+
+why:
+  ja: 同じ書き出しが続くと、読者は文の切れ目を見失って読み飛ばします。
+  en: Identical openings blur the boundary between sentences.
+
+message:
+  ja: 「{head}」で始まる文が {count} 続いています（{limit} まで）
+  en: '{count} sentences in a row open with "{head}" (limit {limit})'
+
+how_to_fix:
+  ja: 語順を変えるか、1 文を前の文に繋げてください。
+  en: Reorder, or fold one sentence into the one before it.
+
+levels:
+  strict: 2
+  normal: 3
+  relaxed: 4
+
+use_for: [blog, business]

package/rules/sentence-rhythm.yaml

@@ -0,0 +1,30 @@
+id: sentence-rhythm
+# 「AI 生成は文の長さが揃う」は未検証の仮説。corpus 評価まで既定では動かさない。spec §26-4。
+status: experimental
+layer: L1
+how_to_find: sentence-rhythm
+severity: warning
+
+name:
+  ja: 文の長さが単調
+  en: Monotonous sentence rhythm
+
+why:
+  ja: どの文も同じ長さだと、読者は途中で読むリズムを失います。
+  en: When every sentence is the same length, the reader loses the rhythm.
+
+message:
+  ja: 文の長さのばらつきが {count}%（{limit}% 以上ほしい）
+  en: "Sentence length varies by only {count}% (want {limit}%)"
+
+how_to_fix:
+  ja: 短い文をいくつか混ぜてください。1 文を 2 つに割るだけで変わります。
+  en: Mix in short sentences. Splitting one in two is enough.
+
+# 文長の変動係数を 100 分率で持つ。下回ったら指摘する。
+levels:
+  strict: 35
+  normal: 30
+  relaxed: 20
+
+use_for: [blog]

package/src/adapter-load.ts

@@ -0,0 +1,31 @@
+import type { LanguageAdapter } from "./plugin.ts";
+
+const ADAPTER_PACKAGE: Readonly<Record<string, string>> = { ja: "@chaffjs/lang-ja", en: "@chaffjs/lang-en" };
+
+const isAdapter = (value: unknown): value is LanguageAdapter => {
+  if (typeof value !== "object" || value === null) return false;
+  const record: Record<string, unknown> = { ...value };
+  return record["kind"] === "language" && typeof record["id"] === "string" && typeof record["segment"] === "function";
+};
+
+const pickExport = (module: object): unknown => {
+  const record: Record<string, unknown> = { ...module };
+  return isAdapter(record["adapter"]) ? record["adapter"] : record["default"];
+};
+
+export const packageFor = (language: string): string | undefined => ADAPTER_PACKAGE[language];
+
+/**
+ * アダプタは「必要になったものだけ」を実行時に解決する。spec §17.2。
+ * core だけで起動し、文字種で言語を当ててから、その言語のアダプタを読む。
+ * 全言語を静的に import すると、使わない言語のぶんまで npx の初回取得が膨らむ。
+ */
+export const loadAdapter = async (language: string): Promise<LanguageAdapter> => {
+  const specifier = packageFor(language);
+  if (specifier === undefined) throw new Error(`no adapter for language "${language}"`);
+  const module: unknown = await import(specifier);
+  if (typeof module !== "object" || module === null) throw new Error(`${specifier} did not export a module`);
+  const candidate = pickExport(module);
+  if (!isAdapter(candidate)) throw new Error(`${specifier} does not export a LanguageAdapter`);
+  return candidate;
+};

package/src/baseline.ts

@@ -0,0 +1,51 @@
+import { createHash } from "node:crypto";
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import type { Finding } from "./plugin.ts";
+
+export const BASELINE_FILE = ".chaff-baseline.json";
+
+/**
+ * 行番号ではなく内容で同定する。前後に段落を 1 つ足しただけで棚上げが全部剥がれると、
+ * baseline は使い物にならない。workflow spec §8。
+ */
+export const fingerprint = (path: string, finding: Finding): string => {
+  const body = [path, finding.rule, finding.quote.replace(/\s+/gu, " ").trim()].join(" ");
+  return createHash("sha256").update(body).digest("hex").slice(0, 16);
+};
+
+export type Baseline = { readonly version: 1; readonly created: string; readonly entries: readonly string[] };
+
+const isBaseline = (value: unknown): value is Baseline =>
+  typeof value === "object" &&
+  value !== null &&
+  "entries" in value &&
+  Array.isArray(value.entries) &&
+  value.entries.every((entry) => typeof entry === "string");
+
+export const readBaseline = (path: string): Baseline | undefined => {
+  if (!existsSync(path)) return undefined;
+  const raw: unknown = JSON.parse(readFileSync(path, "utf8"));
+  return isBaseline(raw) ? raw : undefined;
+};
+
+export const writeBaseline = (path: string, entries: readonly string[]): void => {
+  const sorted = [...entries].sort((left, right) => left.localeCompare(right, "en"));
+  const body = { version: 1, created: new Date().toISOString().slice(0, 10), entries: sorted };
+  writeFileSync(path, `${JSON.stringify(body, null, 2)}\n`, "utf8");
+};
+
+export type Split = { readonly fresh: readonly Finding[]; readonly shelved: number };
+
+/** baseline にあるものは報告しない。新しく増えたものだけを出す。 */
+export const splitByBaseline = (path: string, findings: readonly Finding[], baseline: Baseline | undefined): Split => {
+  if (baseline === undefined) return { fresh: findings, shelved: 0 };
+  const known = new Set(baseline.entries);
+  const fresh = findings.filter((finding) => !known.has(fingerprint(path, finding)));
+  return { fresh, shelved: findings.length - fresh.length };
+};
+
+/** 直った分だけを落とす。増える方向には動かさない。 */
+export const prune = (previous: Baseline, stillPresent: readonly string[]): string[] => {
+  const present = new Set(stillPresent);
+  return previous.entries.filter((entry) => present.has(entry));
+};

package/src/cli.ts

@@ -0,0 +1,259 @@
+import { readFile } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { loadAdapter, packageFor } from "./adapter-load.ts";
+import { CONFIG_FILE, EMPTY, loadConfig, type Config } from "./config/load.ts";
+import { applyLevel } from "./config/write.ts";
+import { buildDocument } from "./document.ts";
+import { guessLanguage } from "./detect.ts";
+import { collectTargets } from "./files.ts";
+import { BASELINE_FILE, fingerprint, readBaseline, splitByBaseline, writeBaseline } from "./baseline.ts";
+import { applySuppressions } from "./stet.ts";
+import { renderSuppressions, type PerFile } from "./render/suppressions.ts";
+import { clock, describeChange, snapshotOf, watchPaths, type Snapshot } from "./watch.ts";
+import { frontMatterGenre, guessGenre } from "./genre.ts";
+import { GENRES, runInit } from "./init.ts";
+import { loadRules } from "./rule-load.ts";
+import { renderCompact } from "./render/compact.ts";
+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 type { Level, RuleDefinition } from "./plugin.ts";
+
+const USAGE = `chaff — 文章の読みにくいところを見つけます。文章は書き換えません。
+
+  chaff <file|dir|glob>...       検査する（設定も API key も要りません）
+  chaff .                        この場所の Markdown を全部
+  chaff init                     chaff.yaml を作る
+  chaff explain <rule>           そのルールの意図と根拠を読む
+  chaff genres                   ジャンルの一覧
+  chaff rules --json             いまの設定を JSON で出す（AI に渡す用）
+  chaff baseline <dir>           いまある指摘を棚上げする（既存の repo に入れるとき）
+  chaff suppressions <dir>       stet で黙らせている指摘を数える
+  chaff relax|strict|off <rule> [--why "理由"]
+
+  --compact         エンジニア向けの 1 行形式
+  --experimental    試験中の rule も動かす
+  --show-baseline   棚上げした分も含めて全部見る
+  --watch           保存のたびに見直し、変わったところだけ出す
+
+この箇所だけ黙らせる:  <!-- stet: rule-id — 理由 -->
+
+値は strict / normal / relaxed / off の 4 つから選びます。
+`;
+
+const readConfig = (): Config => (existsSync(join(process.cwd(), CONFIG_FILE)) ? loadConfig(join(process.cwd(), CONFIG_FILE)) : EMPTY);
+
+const resolveGenre = (path: string, source: string, config: Config): { genre: string; from: string } => {
+  if (config.genre !== undefined) return { genre: config.genre, from: CONFIG_FILE };
+  const guess = guessGenre(path, source, frontMatterGenre(source));
+  return guess === undefined ? { genre: "blog/tech", from: "既定" } : { genre: guess.genre, from: guess.from };
+};
+
+const findRule = (rules: readonly RuleDefinition[], id: string | undefined): RuleDefinition | undefined => rules.find((rule) => rule.id === id);
+
+const changeSetting = (command: Level, ruleId: string | undefined, why: string | undefined): number => {
+  const config = readConfig();
+  const rule = findRule(loadRules(config.language ?? "ja"), ruleId);
+  if (rule === undefined) {
+    console.error(`${ruleId ?? "(名前なし)"} というルールはありません。npx chaff rules --json で一覧が出ます。`);
+    return 1;
+  }
+  const outcome = applyLevel(join(process.cwd(), CONFIG_FILE), rule, command, why, config.language ?? "ja", process.env["USER"] ?? "unknown");
+  console.log(outcome.message);
+  return outcome.ok ? 0 : 1;
+};
+
+const flag = (argv: readonly string[], name: string): string | undefined => {
+  const at = argv.indexOf(name);
+  return at === -1 ? undefined : argv[at + 1];
+};
+
+type Inspected = { readonly text: string; readonly outcome: FileOutcome; readonly perFile: PerFile; readonly all: readonly string[] };
+
+const headerFor = (path: string, genre: string, from: string, language: string, shelved: number, hushed: number): string => {
+  const shelf = shelved > 0 ? `   棚上げ ${shelved} 件` : "";
+  const stet = hushed > 0 ? `   stet ${hushed} 件` : "";
+  return `${path}   ${genre} \u00b7 ${language === "ja" ? "日本語" : "英語"}   ジャンルは${from}から${shelf}${stet}`;
+};
+
+const inspect = async (path: string, config: Config, argv: readonly string[]): Promise<Inspected> => {
+  const source = await readFile(path, "utf8");
+  const language = config.language ?? guessLanguage(source).language;
+  const 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);
+  // 応答は 3 つ。stet で黙らせたものは、ここで落とす。
+  const applied = applySuppressions(
+    source,
+    raw.findings,
+    doc.sections.map((section) => section.span),
+  );
+  const baseline = argv.includes("--show-baseline") ? undefined : readBaseline(join(process.cwd(), BASELINE_FILE));
+  const split = splitByBaseline(path, applied.kept, baseline);
+  const result = { ...raw, findings: split.fresh };
+  const header = headerFor(path, genre, from, language, split.shelved, applied.suppressed.length);
+  const text = argv.includes("--compact") ? renderCompact(header, result, rules, language) : renderFriendly(header, result, rules, language);
+  return {
+    text,
+    outcome: { path, findings: split.fresh, notRun: raw.skipped.length },
+    perFile: { path, suppressed: applied.suppressed, reasonless: applied.unusedReasonless },
+    all: applied.kept.map((finding) => fingerprint(path, finding)),
+  };
+};
+
+const lint = async (targets: readonly string[], argv: readonly string[]): Promise<number> => {
+  const paths = collectTargets(targets);
+  if (paths.length === 0) {
+    // 0 件を成功にすると「CI は通っているが何も検証していない」状態が続く。§14。
+    console.error(`Markdown が 1 つも見つかりませんでした: ${targets.join(", ")}`);
+    return 1;
+  }
+  const config = readConfig();
+  const language = config.language ?? "ja";
+  if (packageFor(language) === undefined) {
+    console.error(`言語 "${language}" のアダプタがありません。`);
+    return 1;
+  }
+  const results = await Promise.all(paths.map((path) => inspect(path, config, argv)));
+  results.filter((result) => result.outcome.findings.length > 0 || paths.length === 1).forEach((result) => console.log(result.text));
+  renderSummary(results.map((result) => result.outcome)).forEach((line) => console.log(line));
+  return results.some((result) => result.outcome.findings.some((finding) => finding.severity === "error")) ? 1 : 0;
+};
+
+/**
+ * 書いている最中は、全件を出し直されても何が変わったのか分からない。
+ * 差分だけを出す。workflow spec §11。
+ */
+const runWatch = async (targets: readonly string[], argv: readonly string[]): Promise<number> => {
+  const paths = collectTargets(targets);
+  if (paths.length === 0) {
+    console.error(`Markdown が 1 つも見つかりませんでした: ${targets.join(", ")}`);
+    return 1;
+  }
+  const config = readConfig();
+  const seen = new Map<string, Snapshot>();
+  const once = async (path: string, first: boolean): Promise<void> => {
+    const result = await inspect(path, config, argv);
+    const after = snapshotOf(result.outcome.findings);
+    const before = seen.get(path) ?? {};
+    seen.set(path, after);
+    if (first) return;
+    const change = describeChange(before, after);
+    console.log(`${clock()}  ${path}  ${change ?? "変わりませんでした"}`);
+  };
+  await Promise.all(paths.map((path) => once(path, true)));
+  const totals = [...seen.values()].reduce((sum, snapshot) => sum + Object.values(snapshot).reduce((inner, count) => inner + count, 0), 0);
+  console.log(`\n  ${paths.length} ファイルを見ています。いまの指摘は ${totals} 件です。`);
+  console.log("  保存するたびに、変わったところだけ出します。止めるには Ctrl-C。\n");
+  const stop = watchPaths(paths, (path) => void once(path, false));
+  process.on("SIGINT", () => {
+    stop();
+    process.exit(0);
+  });
+  return new Promise(() => undefined);
+};
+
+const explain = (ruleId: string | undefined): number => {
+  const config = readConfig();
+  const language = config.language ?? "ja";
+  const rules = loadRules(language);
+  const rule = findRule(rules, ruleId);
+  if (rule === undefined) {
+    const list = rules.map((entry) => `  ${entry.id}`).join("\n");
+    console.error(`${ruleId ?? "(名前なし)"} というルールはありません。\n一覧:\n${list}`);
+    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)));
+  return 0;
+};
+
+/** 閾値の単位。explain で「4 とは何の 4 か」を示すため。 */
+const unitOf = (ruleId: string, language: string): string => {
+  if (ruleId !== "max-sentence-length") return "回";
+  return language === "ja" ? "文字" : "語";
+};
+
+const runBaseline = async (targets: readonly string[], argv: readonly string[]): Promise<number> => {
+  const paths = collectTargets(targets.length > 0 ? targets : ["."]);
+  if (paths.length === 0) {
+    console.error("Markdown が 1 つも見つかりませんでした。");
+    return 1;
+  }
+  const config = readConfig();
+  const results = await Promise.all(paths.map((path) => inspect(path, config, [...argv, "--show-baseline"])));
+  const entries = results.flatMap((result) => result.all);
+  const file = join(process.cwd(), BASELINE_FILE);
+  writeBaseline(file, entries);
+  console.log(
+    [
+      "",
+      `  ${paths.length} ファイルを走査しました。`,
+      "",
+      `  ${entries.length} 件の指摘を ${BASELINE_FILE} に記録しました。`,
+      "  以後、これらは報告されません。新しく増えたものだけが出ます。",
+      "",
+      `  ${BASELINE_FILE} を commit してください。`,
+      "",
+    ].join("\n"),
+  );
+  return 0;
+};
+
+const runSuppressions = async (targets: readonly string[], argv: readonly string[]): Promise<number> => {
+  const paths = collectTargets(targets.length > 0 ? targets : ["."]);
+  const config = readConfig();
+  const results = await Promise.all(paths.map((path) => inspect(path, config, [...argv, "--show-baseline"])));
+  console.log(renderSuppressions(results.map((result) => result.perFile)));
+  return 0;
+};
+
+type Handler = (argv: readonly string[]) => number | Promise<number>;
+
+/** `--` で始まらない引数。対象のパス。 */
+const positional = (argv: readonly string[]): string[] => argv.slice(1).filter((arg) => !arg.startsWith("--"));
+
+const showRules = (): number => {
+  const config = readConfig();
+  const language = config.language ?? "ja";
+  console.log(rulesJson(loadRules(language), config, language, config.genre ?? "blog/tech"));
+  return 0;
+};
+
+const showGenres = (): number => {
+  console.log(["", "  使えるジャンル:", ...GENRES.map((genre) => `    ${genre}`), "", "  chaff.yaml の genre に書くか、--genre で指定します。", ""].join("\n"));
+  return 0;
+};
+
+/** 分岐を数珠つなぎにせず表にする。足すときに main を太らせない。 */
+const HANDLERS: Readonly<Record<string, Handler>> = {
+  init: (argv) => {
+    runInit(process.cwd(), flag(argv, "--genre") ?? "blog/tech").forEach((line) => console.log(line));
+    return 0;
+  },
+  genres: showGenres,
+  rules: showRules,
+  explain: (argv) => explain(argv[1]),
+  baseline: (argv) => runBaseline(positional(argv), argv),
+  suppressions: (argv) => runSuppressions(positional(argv), argv),
+  relax: (argv) => changeSetting("relaxed", argv[1], flag(argv, "--why")),
+  strict: (argv) => changeSetting("strict", argv[1], flag(argv, "--why")),
+  off: (argv) => changeSetting("off", argv[1], flag(argv, "--why")),
+};
+
+export const main = async (argv: readonly string[]): Promise<number> => {
+  const first = argv[0];
+  if (first === undefined || first === "--help" || first === "-h") {
+    console.log(USAGE);
+    return first === undefined ? 1 : 0;
+  }
+  const handler = HANDLERS[first];
+  if (handler !== undefined) return handler(argv);
+  const targets = (first === "lint" ? argv.slice(1) : argv).filter((arg) => !arg.startsWith("--"));
+  return argv.includes("--watch") ? runWatch(targets, argv) : lint(targets, argv);
+};

package/src/config/load.ts

@@ -0,0 +1,38 @@
+import { readFileSync } from "node:fs";
+import { parse } from "yaml";
+import { isLevel } from "../levels.ts";
+import type { Level } from "../plugin.ts";
+
+export const CONFIG_FILE = "chaff.yaml";
+
+export type Config = {
+  readonly genre: string | undefined;
+  readonly language: string | undefined;
+  readonly rules: Readonly<Record<string, Level>>;
+  readonly experimental: boolean;
+  readonly path: string | undefined;
+};
+
+export const EMPTY: Config = { genre: undefined, language: undefined, rules: {}, experimental: false, path: undefined };
+
+const isRecord = (value: unknown): value is Record<string, unknown> => typeof value === "object" && value !== null && !Array.isArray(value);
+
+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), {});
+};
+
+const str = (value: unknown): string | undefined => (typeof value === "string" ? value : undefined);
+
+/** 設定ファイルが無くても動く。あっても、既定から変えたものだけが書かれている。spec §18。 */
+export const loadConfig = (path: string): Config => {
+  const raw: unknown = parse(readFileSync(path, "utf8"));
+  if (!isRecord(raw)) return { ...EMPTY, path };
+  return {
+    genre: str(raw["genre"]),
+    language: str(raw["language"]),
+    rules: rulesOf(raw["rules"]),
+    experimental: raw["experimental"] === true,
+    path,
+  };
+};

package/src/config/write.ts

@@ -0,0 +1,63 @@
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { Scalar, YAMLMap, isMap, isScalar, parseDocument, type Document } from "yaml";
+import { definedLevels } from "../levels.ts";
+import { localized } from "../render/text.ts";
+import type { Level, RuleDefinition } from "../plugin.ts";
+
+const TEMPLATE = `# chaff.yaml — このチームの文章規範
+#
+# ここに書くのは「既定から変えたもの」だけです。
+# 値は strict / normal / relaxed / off の 4 つから選びます。数字は要りません。
+
+rules:
+`;
+
+export type ChangeOutcome = { readonly ok: boolean; readonly message: string };
+
+const today = (): string => new Date().toISOString().slice(0, 10);
+
+const reasonOf = (value: unknown): string | undefined => {
+  if (!isScalar(value) || typeof value.comment !== "string") return undefined;
+  const text = value.comment.trim();
+  return text.length === 0 ? undefined : text;
+};
+
+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);
+
+/**
+ * 設定を機械的に書き換えるが、**既存のコメントを壊さない**。
+ * 設定ファイルがチームの規範そのものである以上、コメントが失われることは規範が失われること。
+ * 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 rules = doc.get("rules");
+  const map = isMap(rules) ? rules : new YAMLMap();
+  // 人が読んで書き足すファイルなので、必ず block style にする。flow style（{ a: b }）は読めない。
+  map.flow = false;
+  if (!isMap(rules)) doc.set("rules", map);
+  const existing = map.items.find((pair) => String(pair.key) === rule.id);
+  const previous = reasonOf(existing?.value);
+  // 古い理由が新しい値に付いたまま残ると、履歴が嘘になる。
+  if (previous !== undefined && why === undefined) {
+    return { ok: false, message: `${rule.id} には既に理由が書かれています:\n  ${previous}\n値を変えるときは --why で新しい理由を書いてください。` };
+  }
+  // 取り除いて足し直すと、元の rule に付いていた説明コメントが行き場を失って残る。
+  // 既にある鍵は、その場で値だけ差し替える。
+  const value = new Scalar(level);
+  if (why !== undefined) value.comment = ` ${today()} ${why} / ${who}`;
+  if (existing === undefined) {
+    map.items = [...map.items, doc.createPair(rule.id, value)];
+    const added = map.items.at(-1);
+    if (added !== undefined && isScalar(added.key)) added.key.commentBefore = ruleComment(rule, language);
+  } else {
+    existing.value = value;
+  }
+  writeFileSync(path, String(doc), "utf8");
+  return { ok: true, message: `${rule.id} を ${level} にしました（${path}）` };
+};