chaffjs 0.18.0 → 0.20.0

package/src/api.ts

@@ -0,0 +1,154 @@
+// The plugin API: everything a team's rule or a plugin package may rely on, and nothing else. A detector sees the
+// document only through these shapes, so chaff can change how it reads a document without breaking a plugin. Raise
+// API_VERSION when a change here would break a plugin written against the current one.
+
+/** The plugin API this chaff implements. A plugin says which one it was written for; chaff refuses any other. */
+export const API_VERSION = 1;
+
+/** A place in doc.source: UTF-16 offsets, end exclusive. */
+export type Span = { readonly start: number; readonly end: number };
+
+/** One word as the language adapter read it. pos is a Universal Dependencies UPOS tag (NOUN, VERB, ADP…). */
+export type Token = {
+  readonly span: Span;
+  readonly surface: string;
+  readonly pos: string;
+  readonly lemma?: string;
+  /** How the word is read (katakana for Japanese). Only adapters that can read it give it. */
+  readonly reading?: string;
+  /** Universal Dependencies FEATS the adapter folded in (Voice=Pass). */
+  readonly features?: Readonly<Record<string, string>>;
+};
+
+/** tokens is there only when the rule asked for parts of speech (requires: [pos]) and the adapter could give them. */
+export type Sentence = { readonly span: Span; readonly text: string; readonly tokens?: readonly Token[] };
+
+export type Paragraph = { readonly span: Span; readonly sentences: readonly Sentence[] };
+
+/** A heading and what follows it, up to the next heading. The text before the first heading is a section of depth 0. */
+export type Section = { readonly depth: number; readonly heading: string; readonly span: Span; readonly sentences: readonly Sentence[] };
+
+/** One bulleted or numbered list, with the length of each item in characters. */
+export type List = { readonly span: Span; readonly itemLengths: readonly number[] };
+
+/** One entry of a word list. instead_of is another way to write the same thing, for rules that check a document is consistent. */
+export type LexiconEntry = { readonly pattern: string; readonly instead_of?: string };
+
+export type Lexicon = readonly LexiconEntry[];
+
+export type MarkupHeading = { readonly depth: number; readonly text: string; readonly span: Span };
+
+/** alt is undefined for an HTML <img> with no alt attribute. */
+export type MarkupImage = { readonly alt: string | undefined; readonly span: Span };
+
+export type MarkupLink = { readonly destination: string; readonly span: Span };
+
+/** The document's markup. A plain-text document has markdown: false and no headings, images or links. */
+export type Markup = {
+  readonly markdown: boolean;
+  readonly headings: readonly MarkupHeading[];
+  readonly images: readonly MarkupImage[];
+  readonly links: readonly MarkupLink[];
+  /** The in-page names the writer gave ({#id} on a heading, HTML id and name), sorted. */
+  readonly ids: readonly string[];
+  /** What the reader sees as text: everything outside links. */
+  readonly texts: readonly Span[];
+};
+
+/** What a detector reads. Every span is a place in source. It is frozen: a detector cannot change what other rules see. */
+export type RuleDocument = {
+  readonly path: string;
+  readonly source: string;
+  /** The language the document is checked as: "ja", "en". */
+  readonly language: string;
+  /** What a length counts: characters (ja) or words (en). */
+  readonly lengthUnit: "char" | "word";
+  readonly sentences: readonly Sentence[];
+  readonly paragraphs: readonly Paragraph[];
+  readonly sections: readonly Section[];
+  readonly lists: readonly List[];
+  /** Each list item, wherever it is. */
+  readonly listItems: readonly Span[];
+  /** Each link, as written (`[text](url)`, `<https://…>`). */
+  readonly links: readonly Span[];
+  /** The word lists for the document's language: the adapter's, the team's and the plugins'. */
+  readonly lexicons: Readonly<Record<string, Lexicon>>;
+  readonly markup: Markup;
+};
+
+/** What a detector is given besides the document. lexicon is the rule's word_list for the document's language. */
+export type DetectorOptions = { readonly lexicon: Lexicon | undefined };
+
+/**
+ * One place a rule found. start (and end) are offsets in doc.source. values fill the rule's message: {matched} is
+ * source from start to end unless values gives it.
+ */
+export type Finding = {
+  readonly start: number;
+  readonly end?: number;
+  readonly values?: Readonly<Record<string, string | number>>;
+};
+
+/** A rule's check. It must be pure and deterministic: no files, network, clock or randomness, the same findings every time. */
+export type Detector = (doc: RuleDocument, options: DetectorOptions) => readonly Finding[];
+
+/** Words a reader sees: one string for every language, or one per language ({ ja, en }). */
+export type Text = string | Readonly<Record<string, string>>;
+
+export type Severity = "error" | "warning" | "info";
+
+/**
+ * A rule. In a type: module file only detect is read, and chaff.yaml gives the rest. In a plugin, id, name, why,
+ * how_to_fix and example are required, as they are for a rule in custom_rules.
+ */
+export type RuleSpec = {
+  readonly detect: Detector;
+  readonly id?: string;
+  readonly name?: Text;
+  readonly why?: Text;
+  readonly how_to_fix?: Text;
+  readonly example?: { readonly before: Text; readonly after: Text };
+  readonly message?: Text;
+  readonly level?: Severity;
+  /** The languages the rule checks. Without it, every language. */
+  readonly languages?: readonly string[];
+  /** A word list by name; the detector gets it as options.lexicon. A plugin's own lists are named without the plugin's prefix. */
+  readonly word_list?: string;
+  /** "pos" when the detector reads tokens. Without it, sentences have no tokens. */
+  readonly requires?: readonly "pos"[];
+};
+
+export type Rule = RuleSpec & { readonly apiVersion: number };
+
+/** A rule, stamped with the API version it was written for. */
+export const defineRule = (spec: RuleSpec): Rule => ({ ...spec, apiVersion: API_VERSION });
+
+/** A word list in each language it has words for: { ja: [...], en: [...] }. A string is an entry with only a pattern. */
+export type LexiconSpec = Readonly<Record<string, readonly (string | LexiconEntry)[]>>;
+
+/** A house style a plugin ships: rule levels and options, and the guideline it follows. */
+export type StyleSpec = {
+  readonly id: string;
+  readonly name: Text;
+  readonly summary: Text;
+  readonly source: { readonly title: Text; readonly url: string };
+  readonly rules?: Readonly<Record<string, "strict" | "normal" | "relaxed" | "off">>;
+  readonly options?: Readonly<Record<string, Readonly<Record<string, unknown>>>>;
+};
+
+/**
+ * A plugin package. name is the prefix of every id it ships (name/rule-id); for chaff-plugin-foo it is foo, for
+ * @scope/chaff-plugin-foo it is @scope/foo. A rule is a RuleSpec, or a custom_rules entry without code (type: words,
+ * pattern or tokens).
+ */
+export type PluginSpec = {
+  readonly name: string;
+  readonly rules?: readonly (Rule | RuleSpec | Readonly<Record<string, unknown>>)[];
+  readonly lexicons?: Readonly<Record<string, LexiconSpec>>;
+  readonly styles?: readonly StyleSpec[];
+};
+
+export type Plugin = PluginSpec & { readonly apiVersion: number };
+
+/** A plugin, stamped with the API version it was written for. */
+export const definePlugin = (spec: PluginSpec): Plugin => ({ ...spec, apiVersion: API_VERSION });

package/src/baseline.ts

@@ -1,5 +1,6 @@
 import { createHash } from "node:crypto";
 import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { posix, relative, resolve, sep } from "node:path";
 import type { Finding } from "./plugin.ts";
 
 export const BASELINE_FILE = ".chaff-baseline.json";
@@ -13,16 +14,28 @@ export const fingerprint = (path: string, finding: Finding): string => {
   return createHash("sha256").update(body).digest("hex").slice(0, 16);
 };
 
+type PathRules = Pick<typeof posix, "relative" | "resolve" | "sep">;
+const NATIVE: PathRules = { relative, resolve, sep };
+
+/**
+ * baseline が覚えるパス。baseline のフォルダからの相対で、区切りはどの OS でも「/」。
+ * OS の区切りのまま覚えると、macOS で書いた baseline が Windows では何も棚上げしない。
+ */
+export const baselinePath = (path: string, folder: string, rules: PathRules = NATIVE): string =>
+  rules.relative(folder, rules.resolve(folder, path)).split(rules.sep).join("/");
+
 /**
  * findings の fingerprint を順に。一つの文から出た指摘は同じ文を引くので、文と rule の組ごとに一度だけ計算する。
  * 長い文に指摘が多いと、指摘ごとに文を読み直すのでは指摘数と文の長さの積になる。
+ * folder は baseline を置くフォルダ。パスはそこからの相対にしてから数える。
  */
-export const fingerprints = (path: string, findings: readonly Finding[]): string[] => {
+export const fingerprints = (path: string, findings: readonly Finding[], folder: string): string[] => {
+  const key = baselinePath(path, folder);
   const known = new Map<string, Map<string, string>>();
   return findings.map((finding) => {
     const byRule = known.get(finding.quote) ?? new Map<string, string>();
     known.set(finding.quote, byRule);
-    const found = byRule.get(finding.rule) ?? fingerprint(path, finding);
+    const found = byRule.get(finding.rule) ?? fingerprint(key, finding);
     byRule.set(finding.rule, found);
     return found;
   });
@@ -52,10 +65,10 @@ export const writeBaseline = (path: string, entries: readonly string[]): void =>
 export type Split = { readonly fresh: readonly Finding[]; readonly shelved: number };
 
 /** baseline にあるものは報告しない。新しく増えたものだけを出す。 */
-export const splitByBaseline = (path: string, findings: readonly Finding[], baseline: Baseline | undefined): Split => {
+export const splitByBaseline = (path: string, findings: readonly Finding[], baseline: Baseline | undefined, folder: string): Split => {
   if (baseline === undefined) return { fresh: findings, shelved: 0 };
   const known = new Set(baseline.entries);
-  const prints = fingerprints(path, findings);
+  const prints = fingerprints(path, findings, folder);
   const fresh = findings.filter((_, index) => !known.has(prints[index] ?? ""));
   return { fresh, shelved: findings.length - fresh.length };
 };

package/src/check-source.ts

@@ -0,0 +1,75 @@
+import { loadAdapter } from "./adapter-load.ts";
+import { applyByPath } from "./config/by-path.ts";
+import type { Config } from "./config/load.ts";
+import { optionLayersOf } from "./config/option-problems.ts";
+import { limitsFor } from "./config/style.ts";
+import { rulesOf } from "./custom/load.ts";
+import { guessLanguage } from "./detect.ts";
+import { buildDocument, teamRules } from "./document.ts";
+import type { CrossDetector, ProseDocument, RuleDefinition } from "./plugin.ts";
+import { profileFor } from "./profile/for-file.ts";
+import { resolveGenre, type ResolvedGenre } from "./resolve-genre.ts";
+import { neededBy, runRulesWith, type RunContext, type RunResult } from "./run.ts";
+import { runCrossRules } from "./cross-run.ts";
+import { CROSS_DETECTORS } from "./detectors/index.ts";
+import { applySuppressions, type Applied } from "./stet.ts";
+
+/** A document's language when nothing names one for this run: its by_path entry, chaff.yaml's language, then a guess from the text. */
+export const documentLanguage = (path: string, source: string, config: Config): string =>
+  applyByPath(config.byPath, config.baseDir, path).language ?? config.language ?? guessLanguage(source).language;
+
+/** What this run chose over the settings: a language and a genre, when given, and whether experimental rules run. */
+export type CheckChoice = { readonly language?: string | undefined; readonly genre?: string | undefined; readonly experimental: boolean };
+
+/** One document linted: the rules that ran and why others did not, before and after stet silenced some. */
+export type SourceCheck = {
+  readonly language: string;
+  readonly genre: ResolvedGenre;
+  readonly rules: readonly RuleDefinition[];
+  readonly doc: ProseDocument;
+  /** What the rules ran with. The pass over several documents runs with it too. */
+  readonly context: RunContext;
+  readonly raw: RunResult;
+  readonly applied: Applied;
+};
+
+/** Lints one text as `chaff <file>` does. The file need not exist: `chaff grade` checks a model's output from memory. */
+export const checkSource = async (path: string, source: string, config: Config, choice: CheckChoice): Promise<SourceCheck> => {
+  const language = choice.language ?? documentLanguage(path, source, config);
+  const adapter = await loadAdapter(language);
+  const genre = resolveGenre(path, source, config, choice.genre);
+  const rules = rulesOf(language, config);
+  await adapter.prepare?.(neededBy(rules, config.rules, choice.experimental, genre.genre, language));
+  const doc = buildDocument(path, source, adapter, teamRules(config, language), profileFor(config, path, source, language, genre.genre));
+  const context: RunContext = {
+    settings: config.rules,
+    experimental: choice.experimental,
+    genre: genre.genre,
+    limits: limitsFor(config, language),
+    optionLayers: optionLayersOf(config),
+    detectors: config.extensions?.detectors ?? {},
+  };
+  const raw = runRulesWith(doc, rules, context);
+  return { language, genre, rules, doc, context, raw, applied: suppressedIn(source, doc, raw) };
+};
+
+/** stet で黙らせたものは、ここで落とす。stet は text（読んだままの本文）から読む。 */
+const suppressedIn = (text: string, doc: ProseDocument, raw: RunResult): Applied =>
+  applySuppressions(
+    text,
+    raw.findings,
+    doc.sections.map((section) => section.span),
+  );
+
+/**
+ * The checks of one run's documents, with the rules that compare documents run over all of them (cross-run.ts), and
+ * stet applied to their findings in the file each lands in. A run of one document comes back as it is.
+ */
+export const crossChecked = (checks: readonly SourceCheck[], detectors: Readonly<Record<string, CrossDetector>> = CROSS_DETECTORS): SourceCheck[] => {
+  if (checks.length < 2) return [...checks];
+  const results = runCrossRules(checks, detectors);
+  return checks.map((check, index) => {
+    const raw = results[index] ?? check.raw;
+    return raw === check.raw ? check : { ...check, raw, applied: suppressedIn(check.doc.source, check.doc, raw) };
+  });
+};

package/src/checks.ts

@@ -1,5 +1,5 @@
-import { existsSync, readFileSync } from "node:fs";
-import { parse } from "yaml";
+import { existsSync } from "node:fs";
+import { readYamlFile } from "./config/yaml-file.ts";
 import type { Level, Severity } from "./plugin.ts";
 
 export const CHECKS_FILE = "checks.yaml";
@@ -61,7 +61,7 @@ const toCheck = (raw: unknown, index: number, source: string): UserCheck | undef
 
 export const loadChecks = (path: string): UserCheck[] => {
   if (!existsSync(path)) return [];
-  const raw: unknown = parse(readFileSync(path, "utf8"));
+  const raw: unknown = readYamlFile(path);
   if (!isRecord(raw) || !Array.isArray(raw["checks"])) return [];
   return raw["checks"].map((entry, index) => toCheck(entry, index, path)).filter((entry) => entry !== undefined);
 };

package/src/cli-args.ts

@@ -2,7 +2,7 @@
  * Options of the commands that take files to check, whose value is the next argument. That value is not a file.
  * `--why` (relax), `--format` and `--language` (tree) belong to commands that read their own arguments.
  */
-const VALUE_FLAGS: ReadonlySet<string> = new Set(["--sarif", "--genre", "--rule", "--line"]);
+const VALUE_FLAGS: ReadonlySet<string> = new Set(["--sarif", "--genre", "--rule", "--line", "--include"]);
 
 /** The arguments that name what to check: everything that is neither an option nor an option's value. */
 export const targetsOf = (args: readonly string[]): string[] =>
@@ -13,3 +13,9 @@ export const withExperimental = <T extends { readonly experimental: boolean }>(c
   ...config,
   experimental: config.experimental || args.includes("--experimental"),
 });
+
+/** The settings with each --include <glob> added to chaff.yaml's include: the command line widens a directory walk as chaff.yaml can. */
+export const withIncludes = <T extends { readonly include?: readonly string[] | undefined }>(config: T, args: readonly string[]): T => {
+  const given = args.flatMap((arg, index) => (index > 0 && args[index - 1] === "--include" && !arg.startsWith("--") ? [arg] : []));
+  return given.length === 0 ? config : { ...config, include: [...(config.include ?? []), ...given] };
+};

package/src/cli-text.ts

@@ -5,6 +5,17 @@ import { counted, formFor } from "./render/plural.ts";
 import type { GenreSetting } from "./genre-check.ts";
 import type { ProfileSetting } from "./profile/check.ts";
 
+/** What a folder walk looked for, and how to look for more. Markdown always; include adds file-name globs. */
+const lookedForJa = (include: readonly string[]): string => {
+  const also = include.length > 0 ? `と ${include.join(" ")}` : "";
+  return `  探したもの: Markdown（.md .markdown .mdx）${also}。ほかのファイルも検査するには、chaff.yaml に include: ["*.yaml"] と書くか、--include "*.yaml" を付けてください。`;
+};
+
+const lookedForEn = (include: readonly string[]): string => {
+  const also = include.length > 0 ? ` and ${include.join(", ")}` : "";
+  return `  Looked for Markdown (.md, .markdown, .mdx)${also}. To check other files too, add include: ["*.yaml"] to chaff.yaml, or pass --include "*.yaml".`;
+};
+
 /** Where a file's genre came from, as the header names it. */
 export type GenreSource = "--genre" | "by_path" | "config" | "default" | "front-matter" | "path" | "content";
 
@@ -22,11 +33,17 @@ const USAGE_JA = `chaff — 文章の読みにくいところを見つけます
   chaff tree <file> [--format sexp|json]  文書を番地の付いた木にする（条・項・定義・参照）
   chaff cite <原文> <引用.json>           回答の引用（番地と引用文）が原文にあるかを確かめる
   chaff compare <前> <後>                書き換えで事実（数・日付・URL・コード・名前・引用…）が落ちても足されてもいないかを確かめる
+  chaff facts <file>                     compare が照合する事実を、書き直す前の控えとして一覧にする
+  chaff outline <file> [<後>]            見出しの構成と形（見出しの数・節の平均の長さ・箇条書きの割合・太字）を測る。2 つなら前と後を並べる
+  chaff grade <items.jsonl> [--out <results.jsonl>] [--json]
+                                 AI の出力を JSONL でまとめて採点する（指摘の率・事実・引用・合否。何も送らない）
+  chaff fix-plan <file> [--json]         指摘をルールごとにまとめ、直す方向と確かめのコマンドを、書き直す人や AI 向けの計画にする（何も送らない）
   chaff rules                    ルールの一覧を、グループごとに表で出す（いまの段階つき）
   chaff rules --json             いまの設定とルールの説明を JSON で出す（AI に渡す用）
   chaff baseline <dir>           いまある指摘を棚上げする（既存の repo に入れるとき）
   chaff suppressions <dir>       stet で黙らせている指摘を数える
   chaff relax|strict|off <rule> [--why "理由"]
+  chaff enable <rule> [--why "理由"]  試験中のルールを 1 つだけ動かす（chaff.yaml の rules に <rule>: normal と書く）
   chaff skill [--global]         Claude Code の skill を入れる（.claude/skills/chaff/、--global で ~/.claude/）
   chaff feedback <file> --rule <rule> [--line N] | --missed --line N
                                  誤った指摘・見逃しの報告の下書きを作る（何も送らない。--with-config で chaff.yaml 全体も載せる）
@@ -38,6 +55,7 @@ const USAGE_JA = `chaff — 文章の読みにくいところを見つけます
   --watch           保存のたびに見直し、変わったところだけ出す
   --dry-run         test で、何を AI に送るかだけを見る（API を呼びません）
   --sarif <path>    指摘を SARIF で書き出す（GitHub の PR の行に出すため）
+  --include <glob>  フォルダを見るとき、Markdown のほかにこのファイルも検査する（--include "*.yaml"。chaff.yaml の include と同じ）
 
 この箇所だけ黙らせる:  <!-- stet: rule-id — 理由 -->
 
@@ -58,11 +76,17 @@ const USAGE_EN = `chaff — finds what makes writing hard to read. It never rewr
   chaff tree <file> [--format sexp|json]  the document as a tree of addresses (sections, clauses, definitions, references)
   chaff cite <source> <quotes.json>       check that quoted passages (address and text) are in the source
   chaff compare <before> <after>          check that a rewrite dropped no fact and added none (numbers, dates, URLs, code, names, quotations…)
+  chaff facts <file>                      list the facts compare checks, as an inventory to keep before a rewrite
+  chaff outline <file> [<after>]          measure the outline and its shape (headings, average section length, text in lists, bold); two files side by side
+  chaff grade <items.jsonl> [--out <results.jsonl>] [--json]
+                                 grade a JSONL file of model outputs (finding rates, facts, quotations, pass or fail; sends nothing)
+  chaff fix-plan <file> [--json]          a plan for whoever rewrites the file, a person or an AI: findings by rule, how to rewrite each, the checks to run after (sends nothing)
   chaff rules                    the rules as a table, by group, with the level each runs at now
   chaff rules --json             the current settings and what each rule is, as JSON (to give to an AI)
   chaff baseline <dir>           shelve today's findings (when adding chaff to an existing repository)
   chaff suppressions <dir>       count the findings silenced with stet
   chaff relax|strict|off <rule> [--why "reason"]
+  chaff enable <rule> [--why "reason"]  turn on one experimental rule alone (writes <rule>: normal under rules in chaff.yaml)
   chaff skill [--global]         install the Claude Code skill (.claude/skills/chaff/; --global for ~/.claude/)
   chaff feedback <file> --rule <rule> [--line N] | --missed --line N
                                  draft a report of a wrong or missed finding (sends nothing; --with-config adds all of chaff.yaml)
@@ -74,6 +98,7 @@ const USAGE_EN = `chaff — finds what makes writing hard to read. It never rewr
   --watch           re-check on every save and print only what changed
   --dry-run         with test, show what would be sent to the AI (no API call)
   --sarif <path>    write the findings as SARIF (for comments on a GitHub PR)
+  --include <glob>  in a folder, check these files besides Markdown (--include "*.yaml"; as include in chaff.yaml)
 
 Silence one spot:  <!-- stet: rule-id — reason -->
 
@@ -87,8 +112,9 @@ export type CliText = {
   readonly header: (path: string, genre: string, language: string, from: string, shelved: number, hushed: number) => string;
   readonly suggested: (name: string, genre: string) => string;
   readonly suggestedNote: (name: string, genre: string, used: string) => string;
-  readonly noMarkdown: (targets: string) => string;
-  readonly noMarkdownHere: string;
+  /** Nothing to check among targets; include: the globs looked for besides Markdown. Says how to look for more. */
+  readonly noMarkdown: (targets: string, include: readonly string[]) => string;
+  readonly noMarkdownHere: (include: readonly string[]) => string;
   readonly noAdapter: (language: string) => string;
   readonly unknownGenre: (genre: string, where: string, known: readonly string[]) => string;
   readonly genreWhere: (where: GenreSetting, files: readonly string[]) => string;
@@ -104,7 +130,6 @@ export type CliText = {
   readonly watching: (files: number, findings: number) => string;
   readonly watchHint: string;
   readonly baselineDone: (files: number, entries: number, file: string) => readonly string[];
-  readonly unit: (ruleId: string, language: string) => string;
 };
 
 export const CLI_TEXT: Texts<CliText> = {
@@ -127,8 +152,8 @@ export const CLI_TEXT: Texts<CliText> = {
     suggested: (name, genre) => `   ${name}のようです。--genre ${genre} を試せます`,
     suggestedNote: (name, genre, used) =>
       `  ジャンルを決めていないので、${used} として見ました。${name}なら、--genre ${genre} でその種類の書き方に合わせて見ます（npx chaffjs genres で一覧）。`,
-    noMarkdown: (targets) => `Markdown が 1 つも見つかりませんでした: ${targets}`,
-    noMarkdownHere: "Markdown が 1 つも見つかりませんでした。",
+    noMarkdown: (targets, include) => `検査するファイルが 1 つも見つかりませんでした: ${targets}\n${lookedForJa(include)}`,
+    noMarkdownHere: (include) => `検査するファイルが 1 つも見つかりませんでした。\n${lookedForJa(include)}`,
     noAdapter: (language) => `言語 "${language}" のアダプタがありません。`,
     unknownGenre: (genre, where, known) =>
       `ジャンル "${genre}" はありません（${where}）。使えるのは ${known.join("、")} です。npx chaff genres で一覧が出ます。`,
@@ -159,11 +184,6 @@ export const CLI_TEXT: Texts<CliText> = {
       `  ${file} を commit してください。`,
       "",
     ],
-    unit: (ruleId, language) => {
-      if (ruleId === "bold-density") return "1000 字あたりの箇所数";
-      if (ruleId !== "max-sentence-length") return "回";
-      return language === "ja" ? "文字" : "語";
-    },
   },
   en: {
     usage: USAGE_EN,
@@ -182,8 +202,8 @@ export const CLI_TEXT: Texts<CliText> = {
     suggested: (name, genre) => `   Looks like: ${name}. Try --genre ${genre}`,
     suggestedNote: (name, genre, used) =>
       `  No genre was set, so this was checked as ${used}. If it is ${name}, --genre ${genre} checks it the way that kind is written (npx chaffjs genres lists them).`,
-    noMarkdown: (targets) => `No Markdown files found: ${targets}`,
-    noMarkdownHere: "No Markdown files found.",
+    noMarkdown: (targets, include) => `No files to check found: ${targets}\n${lookedForEn(include)}`,
+    noMarkdownHere: (include) => `No files to check found.\n${lookedForEn(include)}`,
     noAdapter: (language) => `No language package for "${language}".`,
     unknownGenre: (genre, where, known) => `There is no genre "${genre}" (${where}). The genres are ${known.join(", ")}. npx chaff genres lists them.`,
     genreWhere: (where, files) => {
@@ -213,10 +233,5 @@ export const CLI_TEXT: Texts<CliText> = {
       `  Commit ${file}.`,
       "",
     ],
-    unit: (ruleId, language) => {
-      if (ruleId === "bold-density") return "places per 1000 characters";
-      if (ruleId !== "max-sentence-length") return "times";
-      return language === "ja" ? "characters" : "words";
-    },
   },
 };