chaffjs 0.0.1

package/src/detect-language.ts

@@ -0,0 +1,28 @@
+/**
+ * core が「どのアダプタを取りに行くか」を決めるためだけの当て推量。spec §17.2。
+ *
+ * アダプタを読み込む前に動く必要があるので、ここは辞書も依存も持てない。
+ * アダプタ側の detect() とは層が違う。あちらは読み込み済みの候補から選ぶための
+ * 権威ある点数で、こちらは何も読み込んでいない状態での見当付け。
+ * 似た計算を両方が持つのは、この順序から来る避けられない重複。
+ *
+ * 呼ぶ側が、コードブロック・インラインコード・URL・front matter を先に落としておくこと。
+ * 技術文書は英語のコードを大量に含むため、落とさないと日本語文書が英語と判定される。
+ */
+const JAPANESE = /[぀-ゟ゠-ヿ一-鿿]/gu;
+const LATIN_LETTER = /[a-z]/giu;
+const COUNTABLE = /\S/gu;
+
+// 共有した /g 正規表現を exec で回すと lastIndex が持ち越されて数え落とす。
+// matchAll は内部で複製するので、その事故が起きない。
+const count = (text: string, pattern: RegExp): number => [...text.matchAll(pattern)].length;
+
+const ratio = (text: string, pattern: RegExp): number => {
+  const total = count(text, COUNTABLE);
+  if (total === 0) return 0;
+  return count(text, pattern) / total;
+};
+
+export const japaneseRatio = (text: string): number => ratio(text, JAPANESE);
+
+export const latinRatio = (text: string): number => ratio(text, LATIN_LETTER);

package/src/detect.ts

@@ -0,0 +1,15 @@
+import { japaneseRatio, latinRatio } from "./detect-language.ts";
+
+export type LanguageGuess = { readonly language: string; readonly confidence: number; readonly from: string };
+
+/**
+ * 技術文書の日本語は英字を大量に含む（コマンド名、識別子、製品名）。
+ * 仮名と漢字が 15% あれば日本語と見る。corpus で測るまでの暫定値。spec §26。
+ */
+const JAPANESE_FLOOR = 0.15;
+
+export const guessLanguage = (source: string): LanguageGuess => {
+  const japanese = japaneseRatio(source);
+  if (japanese >= JAPANESE_FLOOR) return { language: "ja", confidence: japanese, from: "content" };
+  return { language: "en", confidence: latinRatio(source), from: "content" };
+};

package/src/detectors/count-per-section.ts

@@ -0,0 +1,15 @@
+import type { Detector, Finding } from "../plugin.ts";
+
+/** 節あたりの強調の数。bold-density が使う。 */
+export const countPerSection: Detector = (doc, options): Finding[] =>
+  doc.sections
+    .filter((section) => section.strongCount > options.limit)
+    .map((section) => ({
+      rule: "bold-density",
+      severity: "warning",
+      line: 0,
+      column: 0,
+      // 節全体を引くと段落をまたいで読めなくなる。最初の文だけ見せて場所を示す。
+      quote: section.firstSentence?.text.trim() ?? "",
+      values: { count: section.strongCount, limit: options.limit, offset: section.firstSentence?.span.start ?? section.span.start },
+    }));

package/src/detectors/heading-echo.ts

@@ -0,0 +1,40 @@
+import type { Detector, Finding } from "../plugin.ts";
+
+/** 見出しが短すぎると、偶然の一致で 100% になる。これ未満の見出しは見ない。 */
+const MIN_GRAMS = 4;
+
+/**
+ * 文字 3-gram で測る。
+ * 語 n-gram にすると wordSplit capability が要り、L1（言語を問わず動く）から外れる。
+ */
+const trigrams = (text: string): Set<string> => {
+  const clean = [...text.replace(/\s+/gu, "")];
+  return new Set(clean.slice(0, Math.max(0, clean.length - 2)).map((__char, index) => clean.slice(index, index + 3).join("")));
+};
+
+/**
+ * Jaccard ではなく包含率を使う。
+ *
+ * この rule が測りたいのは「見出しのどれだけが繰り返されたか」であって、
+ * 両者がどれだけ似ているかではない。見出しを丸ごと含んだうえで説明を続ける文は、
+ * 文が長いというだけで Jaccard が下がってしまい、いちばん典型的な反復を取り逃す。
+ * （「## キャッシュの仕組み」→「キャッシュの仕組みについて説明します。」で Jaccard 44%）
+ */
+const containment = (heading: Set<string>, sentence: Set<string>): number => {
+  if (heading.size < MIN_GRAMS || sentence.size === 0) return 0;
+  return [...heading].filter((gram) => sentence.has(gram)).length / heading.size;
+};
+
+export const headingEcho: Detector = (doc, options): Finding[] =>
+  doc.sections
+    .filter((section) => section.heading.length > 0 && section.firstSentence !== undefined)
+    .map((section) => ({ section, overlap: Math.round(containment(trigrams(section.heading), trigrams(section.firstSentence?.text ?? "")) * 100) }))
+    .filter(({ overlap }) => overlap >= options.limit)
+    .map(({ section, overlap }) => ({
+      rule: "heading-echo",
+      severity: "warning",
+      line: 0,
+      column: 0,
+      quote: section.firstSentence?.text.trim() ?? "",
+      values: { heading: section.heading, count: overlap, limit: options.limit, offset: section.firstSentence?.span.start ?? section.span.start },
+    }));

package/src/detectors/index.ts

@@ -0,0 +1,17 @@
+import type { Detector } from "../plugin.ts";
+import { countPerSection } from "./count-per-section.ts";
+import { sentenceLength } from "./sentence-length.ts";
+import { headingEcho } from "./heading-echo.ts";
+import { repeatedHead } from "./repeated-head.ts";
+import { sentenceRhythm } from "./sentence-rhythm.ts";
+import { phraseMatch } from "./phrase-match.ts";
+
+/** rule 定義の how_to_find がここを引く。rule 側は実装を知らない。 */
+export const DETECTORS: Readonly<Record<string, Detector>> = {
+  "count-per-section": countPerSection,
+  "sentence-length": sentenceLength,
+  "heading-echo": headingEcho,
+  "repeated-head": repeatedHead,
+  "sentence-rhythm": sentenceRhythm,
+  "phrase-match": phraseMatch,
+};

package/src/detectors/phrase-match.ts

@@ -0,0 +1,41 @@
+import type { Detector, Finding, ProseDocument, Sentence } from "../plugin.ts";
+
+/** 冒頭は先頭 2 段落ぶん。「どの記事にも当てはまる書き出し」は冒頭にあるときだけ問題。 */
+const OPENING_SENTENCES = 4;
+
+/**
+ * 見る範囲を絞る。同じ語でも、どこにあるかで意味が変わる。
+ * 「まとめると」は結びなら定型だが、本文の途中なら普通の接続。
+ */
+const inScope = (doc: ProseDocument, where: string | undefined): readonly Sentence[] => {
+  if (where === "opening") return doc.sentences.slice(0, OPENING_SENTENCES);
+  if (where === "closing") return doc.sections.at(-1)?.sentences ?? [];
+  return doc.sentences;
+};
+
+type Hit = { readonly sentence: Sentence; readonly matched: string };
+
+const hitsIn = (sentences: readonly Sentence[], patterns: readonly string[]): Hit[] =>
+  sentences.flatMap((sentence) => {
+    const matched = patterns.find((pattern) => sentence.text.toLowerCase().includes(pattern.toLowerCase()));
+    return matched === undefined ? [] : [{ sentence, matched }];
+  });
+
+/**
+ * 語彙表との照合。detector は共通で、語彙だけが言語別に差し替わる。spec §11。
+ * これが L2 の全体像で、新しい言語は語彙表を書くだけで動く。
+ */
+export const phraseMatch: Detector = (doc, options): Finding[] => {
+  const patterns = (options.lexicon ?? []).map((entry) => entry.pattern);
+  if (patterns.length === 0) return [];
+  const hits = hitsIn(inScope(doc, options.where), patterns);
+  if (hits.length < options.limit) return [];
+  return hits.map((hit) => ({
+    rule: "",
+    severity: "warning",
+    line: 0,
+    column: 0,
+    quote: hit.sentence.text.trim(),
+    values: { matched: hit.matched, count: hits.length, limit: options.limit, offset: hit.sentence.span.start },
+  }));
+};

package/src/detectors/repeated-head.ts

@@ -0,0 +1,29 @@
+import type { Detector, Finding, Sentence } from "../plugin.ts";
+
+const HEAD_CHARS = 6;
+
+const headOf = (sentence: Sentence): string => sentence.text.trim().replace(/\s+/gu, "").slice(0, HEAD_CHARS);
+
+type Run = { readonly head: string; readonly members: readonly Sentence[] };
+
+const runsOf = (sentences: readonly Sentence[]): Run[] =>
+  sentences.reduce<Run[]>((acc, sentence) => {
+    const head = headOf(sentence);
+    const last = acc.at(-1);
+    if (last !== undefined && last.head === head && head.length === HEAD_CHARS) {
+      return [...acc.slice(0, -1), { head, members: [...last.members, sentence] }];
+    }
+    return [...acc, { head, members: [sentence] }];
+  }, []);
+
+export const repeatedHead: Detector = (doc, options): Finding[] =>
+  runsOf(doc.sentences)
+    .filter((run) => run.members.length > options.limit)
+    .map((run) => ({
+      rule: "repeated-sentence-head",
+      severity: "warning",
+      line: 0,
+      column: 0,
+      quote: run.members.map((sentence) => sentence.text.trim()).join(" "),
+      values: { head: run.head, count: run.members.length, limit: options.limit, offset: run.members[0]?.span.start ?? 0 },
+    }));

package/src/detectors/sentence-length.ts

@@ -0,0 +1,21 @@
+import type { Detector, Finding, ProseDocument, Sentence } from "../plugin.ts";
+
+/** 日本語は文字、英語は語。単位は adapter が宣言する。spec §7。 */
+const measure = (doc: ProseDocument, sentence: Sentence): number => {
+  const text = sentence.text.trim();
+  if (doc.lengthUnit === "char") return text.length;
+  return text.split(/\s+/u).filter((word) => word.length > 0).length;
+};
+
+export const sentenceLength: Detector = (doc, options): Finding[] =>
+  doc.sentences
+    .map((sentence) => ({ sentence, size: measure(doc, sentence) }))
+    .filter(({ size }) => size > options.limit)
+    .map(({ sentence, size }) => ({
+      rule: "max-sentence-length",
+      severity: "warning",
+      line: 0,
+      column: 0,
+      quote: sentence.text.trim(),
+      values: { count: size, limit: options.limit, offset: sentence.span.start },
+    }));

package/src/detectors/sentence-rhythm.ts

@@ -0,0 +1,28 @@
+import type { Detector, Finding } from "../plugin.ts";
+
+/** 文が少ないと変動係数は当てにならない。ここを下回る文書は見ない。 */
+const MIN_SENTENCES = 8;
+
+const coefficientOfVariation = (sizes: readonly number[]): number => {
+  const mean = sizes.reduce((sum, size) => sum + size, 0) / sizes.length;
+  if (mean === 0) return 0;
+  const variance = sizes.reduce((sum, size) => sum + (size - mean) ** 2, 0) / sizes.length;
+  return Math.sqrt(variance) / mean;
+};
+
+export const sentenceRhythm: Detector = (doc, options): Finding[] => {
+  const sizes = doc.sentences.map((sentence) => sentence.text.trim().length);
+  if (sizes.length < MIN_SENTENCES) return [];
+  const spread = Math.round(coefficientOfVariation(sizes) * 100);
+  if (spread >= options.limit) return [];
+  return [
+    {
+      rule: "sentence-rhythm",
+      severity: "warning",
+      line: 0,
+      column: 0,
+      quote: doc.sentences[0]?.text.trim() ?? "",
+      values: { count: spread, limit: options.limit, offset: doc.sentences[0]?.span.start ?? 0 },
+    },
+  ];
+};

package/src/document.ts

@@ -0,0 +1,154 @@
+import { fromMarkdown } from "mdast-util-from-markdown";
+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 { maskSpans } from "./mask.ts";
+import type { LanguageAdapter, ProseDocument, Section, Sentence, Span } from "./plugin.ts";
+
+type Place = { readonly offset?: number | undefined };
+type Node = {
+  readonly type: string;
+  readonly position?: { readonly start: Place; readonly end: Place } | undefined;
+  readonly children?: readonly Node[] | undefined;
+};
+
+/** 本文として数えないもの。コードは文章ではなく、表は文章の形をしていない。 */
+const NOT_PROSE = new Set(["code", "inlineCode", "html", "yaml", "toml", "table", "thematicBreak", "definition", "image", "imageReference"]);
+
+const spanOf = (node: Node): Span | undefined => {
+  const start = node.position?.start.offset;
+  const end = node.position?.end.offset;
+  return start === undefined || end === undefined ? undefined : { start, end };
+};
+
+const walk = (node: Node, visit: (node: Node) => void): void => {
+  visit(node);
+  (node.children ?? []).forEach((child) => walk(child, visit));
+};
+
+const parse = (source: string): Node =>
+  fromMarkdown(source, { extensions: [gfmTable(), frontmatter(["yaml"])], mdastExtensions: [gfmTableFromMarkdown(), frontmatterFromMarkdown(["yaml"])] });
+
+/** link は `[text](url)` の外側だけを覆う。表示される文字は本文なので残す。 */
+const linkChrome = (node: Node): Span[] => {
+  const whole = spanOf(node);
+  const first = node.children?.[0];
+  const last = node.children?.at(-1);
+  const inner = first === undefined || last === undefined ? undefined : { start: spanOf(first)?.start, end: spanOf(last)?.end };
+  if (whole === undefined || inner?.start === undefined || inner.end === undefined) return whole === undefined ? [] : [whole];
+  return [
+    { start: whole.start, end: inner.start },
+    { start: inner.end, end: whole.end },
+  ];
+};
+
+const collectMasks = (root: Node): Span[] => {
+  const spans: Span[] = [];
+  walk(root, (node) => {
+    if (node.type === "link" || node.type === "linkReference") {
+      spans.push(...linkChrome(node));
+      return;
+    }
+    if (!NOT_PROSE.has(node.type) && node.type !== "heading") return;
+    const span = spanOf(node);
+    if (span !== undefined) spans.push(span);
+  });
+  return spans;
+};
+
+const textOf = (node: Node, source: string): string => {
+  const parts: string[] = [];
+  walk(node, (child) => {
+    if (child.type !== "text" && child.type !== "inlineCode") return;
+    const span = spanOf(child);
+    if (span !== undefined) parts.push(source.slice(span.start, span.end));
+  });
+  return parts.join("");
+};
+
+type Heading = { readonly depth: number; readonly text: string; readonly start: number; readonly end: number };
+
+const headingsOf = (root: Node, source: string): Heading[] => {
+  const found: Heading[] = [];
+  walk(root, (node) => {
+    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 });
+  });
+  return found;
+};
+
+const strongSpans = (root: Node): Span[] => {
+  const found: Span[] = [];
+  walk(root, (node) => {
+    if (node.type !== "strong") return;
+    const span = spanOf(node);
+    if (span !== undefined) found.push(span);
+  });
+  return found;
+};
+
+const within = (span: Span, from: number, to: number): boolean => span.start >= from && span.start < to;
+
+const paragraphSpans = (root: Node): Span[] => {
+  const found: Span[] = [];
+  walk(root, (node) => {
+    if (node.type !== "paragraph") return;
+    const span = spanOf(node);
+    if (span !== undefined) found.push(span);
+  });
+  return found;
+};
+
+/**
+ * 文の分割は**段落ごと**に行う。
+ *
+ * 文書全体を一度に渡すと、句点で終わらない行（「条件:」のような見出し的な行）が、
+ * 覆った表やコードブロックを越えて次の句点まで飲み込む。段落は文が跨がない境界なので、
+ * ここで切れば構造的に起きない。
+ */
+const sentencesOf = (prose: string, paragraphs: readonly Span[], adapter: LanguageAdapter): Sentence[] =>
+  paragraphs.flatMap((paragraph) =>
+    adapter
+      .segment(prose.slice(paragraph.start, paragraph.end))
+      .sentences.filter((sentence) => sentence.text.trim().length > 0)
+      .map((sentence) => ({
+        span: { start: paragraph.start + sentence.span.start, end: paragraph.start + sentence.span.end },
+        text: sentence.text,
+      })),
+  );
+
+const sectionsOf = (headings: readonly Heading[], sentences: readonly Sentence[], strongs: readonly Span[], length: number): Section[] => {
+  const bounds = headings.map((heading, index) => ({ heading, from: heading.end, to: headings[index + 1]?.start ?? length }));
+  const lead = { heading: { depth: 0, text: "", start: 0, end: 0 }, from: 0, to: headings[0]?.start ?? length };
+  return [lead, ...bounds]
+    .filter((bound) => bound.to > bound.from)
+    .map(({ heading, from, to }) => {
+      const inside = sentences.filter((sentence) => within(sentence.span, from, to));
+      return {
+        depth: heading.depth,
+        heading: heading.text,
+        span: { start: from, end: to },
+        sentences: inside,
+        strongCount: strongs.filter((span) => within(span, from, to)).length,
+        firstSentence: inside[0],
+      };
+    });
+};
+
+export const buildDocument = (path: string, source: string, adapter: LanguageAdapter): ProseDocument => {
+  const root = parse(source);
+  const prose = maskSpans(source, collectMasks(root));
+  const sentences = sentencesOf(prose, paragraphSpans(root), adapter);
+  return {
+    path,
+    source,
+    language: adapter.id,
+    lengthUnit: adapter.capabilities.lengthUnit,
+    sections: sectionsOf(headingsOf(root, source), sentences, strongSpans(root), source.length),
+    sentences,
+    lexicons: adapter.lexicons,
+  };
+};

package/src/files.ts

@@ -0,0 +1,34 @@
+import { globSync, statSync } from "node:fs";
+import { join, relative, sep } from "node:path";
+
+const MARKDOWN = [".md", ".markdown", ".mdx"];
+
+/** 走査から外す。ここを通すと node_modules の README を延々と検査することになる。 */
+const SKIP = ["node_modules", "dist", "build", "coverage", ".git", ".chaff-cache"];
+
+const isMarkdown = (path: string): boolean => MARKDOWN.some((ext) => path.toLowerCase().endsWith(ext));
+
+const isSkipped = (path: string): boolean => path.split(sep).some((part) => SKIP.includes(part));
+
+const expand = (target: string): string[] => {
+  const stat = statSync(target, { throwIfNoEntry: false });
+  if (stat === undefined) return globSync(target).filter(isMarkdown);
+  if (stat.isFile()) return [target];
+  return globSync(join(target, "**", "*.{md,markdown,mdx}"));
+};
+
+/**
+ * 与えられたファイル・ディレクトリ・glob を、検査する Markdown の一覧にする。
+ * 0 件は成功にしない（§14）。glob が何にもマッチしないまま CI が緑になると、
+ * 「通っているが何も検証していない」状態が延々と続く。
+ */
+/**
+ * ロケールを明示する。既定のロケールに任せると、同じ入力でも機械によって順序が変わる。
+ * 指摘の並びは CI のログにも baseline にも入るので、順序が揺れてはいけない。
+ */
+export const byPath = (left: string, right: string): number => left.localeCompare(right, "en");
+
+export const collectTargets = (targets: readonly string[]): string[] => {
+  const found = targets.flatMap(expand).filter((path) => !isSkipped(path));
+  return [...new Set(found)].sort((left, right) => byPath(relative(".", left), relative(".", right)));
+};

package/src/genre.ts

@@ -0,0 +1,36 @@
+export type GenreGuess = { readonly genre: string; readonly from: string };
+
+const BY_PATH: readonly (readonly [RegExp, string])[] = [
+  [/(^|\/)(proposals?|teian)\//iu, "business/proposal"],
+  [/(^|\/)(minutes|gijiroku)\//iu, "business/meeting-notes"],
+  [/(^|\/)(press|pr)\//iu, "business/press-release"],
+  [/(^|\/)(reports?)\//iu, "business/report"],
+  [/(^|\/)(blog|posts?|articles?)\//iu, "blog/tech"],
+  [/(^|\/)docs?\//iu, "blog/tech"],
+];
+
+/**
+ * 見出しと行頭に限る。本文中の言及では判定しない。
+ * 「決定事項」という語を説明している文書を議事録と判定してしまうため。
+ */
+const BY_CONTENT: readonly (readonly [RegExp, string])[] = [
+  [/^#{1,6}\s.*(?:報道関係者各位|For Immediate Release)/mu, "business/press-release"],
+  [/^(?:#{1,6}\s)?(?:出席者|決定事項|Attendees)\s*$/mu, "business/meeting-notes"],
+  [/^(?:拝啓|お世話になっております)/mu, "business/report"],
+];
+
+export const guessGenre = (path: string, source: string, front: string | undefined): GenreGuess | undefined => {
+  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: "パス" };
+  const byContent = BY_CONTENT.find(([pattern]) => pattern.test(source));
+  if (byContent !== undefined) return { genre: byContent[1], from: "内容" };
+  return undefined;
+};
+
+/** front matter の genre / type を拾う。失敗しても落とさない。 */
+export const frontMatterGenre = (source: string): string | undefined => {
+  const match = /^---\n([\s\S]*?)\n---/u.exec(source);
+  const line = match?.[1] === undefined ? undefined : /^(?:genre|type):\s*(\S+)\s*$/mu.exec(match[1]);
+  return line?.[1];
+};

package/src/index.ts

@@ -0,0 +1,4 @@
+export type { AdapterCapabilities, LanguageAdapter, LengthUnit, Segmentation, Sentence, Span, Token } from "./plugin.ts";
+export type { LanguageGuess } from "./detect.ts";
+export { guessLanguage } from "./detect.ts";
+export { loadAdapter, packageFor } from "./adapter-load.ts";

package/src/init.ts

@@ -0,0 +1,76 @@
+import { appendFileSync, existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+
+const CONFIG = (genre: string): string => `# chaff.yaml — このチームの文章規範
+#
+# ここに書くのは「既定から変えたもの」だけです。書かなければ既定で動きます。
+# このファイルを消しても chaff は動きます。
+#
+# 値は 4 つの言葉から選びます。数字を書く必要はありません。
+#
+#   strict    きびしく見る
+#   normal    ふつう（既定）
+#   relaxed   ゆるく見る
+#   off       見ない
+#
+# コマンドでも変更できます。理由がコメントとして自動で残ります。
+#
+#   npx chaff relax bold-density --why "図の説明で太字を多用するため"
+#   npx chaff explain bold-density        そのルールの意図を読む
+#   npx chaff rules --json                AI に設定を書かせるときに渡す
+
+# この場所に置く文書の種類。
+genre: ${genre}
+
+# 既定から変えたものだけを書く。
+rules:
+`;
+
+const GITIGNORE_LINE = ".chaff-cache/";
+
+type Written = { readonly path: string; readonly note: string };
+
+const writeIfAbsent = (path: string, body: string, note: string): Written | undefined => {
+  if (existsSync(path)) return undefined;
+  writeFileSync(path, body, "utf8");
+  return { path, note };
+};
+
+/** judge のキャッシュは commit しない。init が .gitignore に足す。 */
+const ensureGitignore = (dir: string): Written | undefined => {
+  const path = join(dir, ".gitignore");
+  if (!existsSync(path)) return writeIfAbsent(path, `${GITIGNORE_LINE}\n`, "作成しました");
+  if (readFileSync(path, "utf8").includes(GITIGNORE_LINE)) return undefined;
+  appendFileSync(path, `${GITIGNORE_LINE}\n`, "utf8");
+  return { path, note: `${GITIGNORE_LINE} を追記しました` };
+};
+
+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 は既にあります。変更していません。"];
+  return [
+    "",
+    "作成しました:",
+    ...made.map((entry) => `  ${entry.path}  ${entry.note}`),
+    "",
+    `ジャンルは ${genre} にしました。違う場合は chaff.yaml の genre を直してください。`,
+    "  一覧: npx chaff genres",
+    "",
+    "次:",
+    "  npx chaff .            この場所の Markdown を全部見る",
+    "",
+  ];
+};
+
+export const GENRES: readonly string[] = [
+  "blog/tech",
+  "blog/essay",
+  "blog/owned-media",
+  "business/proposal",
+  "business/report",
+  "business/email",
+  "business/press-release",
+  "business/meeting-notes",
+];

package/src/levels.ts

@@ -0,0 +1,27 @@
+import type { Level, RuleDefinition } from "./plugin.ts";
+
+export const LEVELS: readonly Level[] = ["strict", "normal", "relaxed", "off"];
+
+export const isLevel = (value: unknown): value is Level => typeof value === "string" && LEVELS.some((level) => level === value);
+
+export type Resolved = { readonly level: Level; readonly limit: number; readonly fellBackToNormal: boolean };
+
+/**
+ * 4 語を数値にする。spec §18.1。
+ *
+ * 意味のある段が 2 つしかない rule がある（padded-intro は strict と normal が同値）。
+ * そういう rule は levels に 2 つだけ書き、未定義の段は normal に落ちる。
+ * 落ちたことを呼ぶ側に伝えるのは、`chaff strict` が「変えたつもりで変わっていない」
+ * 状態を作らないようにするため。
+ */
+export const resolve = (rule: RuleDefinition, level: Level): Resolved => {
+  if (level === "off") return { level, limit: 0, fellBackToNormal: false };
+  const direct = rule.levels[level];
+  if (direct !== undefined) return { level, limit: direct, fellBackToNormal: false };
+  const normal = rule.levels.normal;
+  if (normal === undefined) throw new Error(`rule "${rule.id}" has no normal level`);
+  return { level: "normal", limit: normal, fellBackToNormal: true };
+};
+
+/** その rule が実際に区別できる段だけを返す。CLI の案内に使う。 */
+export const definedLevels = (rule: RuleDefinition): Level[] => LEVELS.filter((level) => level === "off" || rule.levels[level] !== undefined);

package/src/mask.ts

@@ -0,0 +1,33 @@
+import type { Span } from "./plugin.ts";
+
+/**
+ * 非 prose（コードブロック・インラインコード・表・見出し・URL）を、
+ * **同じ長さの空白**で覆う。改行は残す。
+ *
+ * 切り出して繋ぐのではなく覆うのは、オフセットを元文字列と一致させ続けるため。
+ * 行・列の計算も、引用して見せる範囲も、これで元の位置のまま使える。
+ */
+const blankOut = (text: string): string => text.replace(/[^\n]/gu, " ");
+
+const merge = (spans: readonly Span[]): Span[] =>
+  [...spans]
+    .sort((left, right) => left.start - right.start)
+    .reduce<Span[]>((acc, span) => {
+      const last = acc.at(-1);
+      if (last !== undefined && span.start <= last.end) {
+        return [...acc.slice(0, -1), { start: last.start, end: Math.max(last.end, span.end) }];
+      }
+      return [...acc, span];
+    }, []);
+
+export const maskSpans = (source: string, spans: readonly Span[]): string => {
+  const merged = merge(spans);
+  const { parts, cursor } = merged.reduce<{ parts: string[]; cursor: number }>(
+    (acc, span) => ({
+      parts: [...acc.parts, source.slice(acc.cursor, span.start), blankOut(source.slice(span.start, span.end))],
+      cursor: span.end,
+    }),
+    { parts: [], cursor: 0 },
+  );
+  return [...parts, source.slice(cursor)].join("");
+};