chaffjs 0.21.0 → 0.23.0

package/src/cli.ts

@@ -13,9 +13,12 @@ import { runEval } from "./commands/eval.ts";
 import { runTest } from "./commands/test.ts";
 import { GENRES } from "./genre.ts";
 import { resolveGenre } from "./resolve-genre.ts";
-import { runInit } from "./init.ts";
-import { initGenre } from "./commands/init-ask.ts";
-import { targetsOf, withExperimental, withIncludes } from "./cli-args.ts";
+import { runInitCommand } from "./commands/init-command.ts";
+import { runPluginTest } from "./commands/plugin-test.ts";
+import { targetsOf, withIncludes } from "./cli-args.ts";
+import { guidesOfRun, type RunGuide } from "./genre-guide/report.ts";
+import { showRules } from "./commands/rules.ts";
+import { renderGuideBlock } from "./genre-guide/render.ts";
 import { rulesOf } from "./custom/load.ts";
 import { renderCompact } from "./render/compact.ts";
 import { renderExplain } from "./render/explain.ts";
@@ -23,8 +26,6 @@ import { renderFriendly } from "./render/friendly.ts";
 import { renderGenres } from "./render/genres.ts";
 import { loadGenres, presetLevels } from "./genre-load.ts";
 import { fileHeader } from "./file-header.ts";
-import { rulesJson } from "./render/rules-json.ts";
-import { rulesTable } from "./render/rules-table.ts";
 import { renderSarif } from "./render/sarif.ts";
 import { VERSION, VERSION_LINES } from "./version.ts";
 import type { TreeContext } from "./commands/tree.ts";
@@ -38,7 +39,7 @@ import { runConditions, runFeedback, settingsOf, type Checked } from "./commands
 import { homedir } from "node:os";
 import { settingWarnings } from "./config/warnings.ts";
 import { readConfigIn } from "./config/read.ts";
-import { optionLayersOf, settingSourcesOf } from "./config/option-problems.ts";
+import { settingSourcesOf } from "./config/option-problems.ts";
 import { renderSummary, type FileOutcome } from "./render/summary.ts";
 
 import type { Finding, Level, RuleDefinition } from "./plugin.ts";
@@ -117,7 +118,7 @@ const present = (check: SourceCheck, argv: readonly string[]): Inspected => {
     genre,
     outcome: { path, findings: split.fresh, notRun: raw.skipped.length },
     perFile: { path, suppressed: applied.suppressed, reasonless: applied.unusedReasonless, notRun },
-    checked: { findings: split.fresh, rules, language, genre, skipped: raw.skipped },
+    checked: { findings: split.fresh, rules, language, genre, genreFrom: from, skipped: raw.skipped },
     kept: applied.kept,
   };
 };
@@ -132,7 +133,7 @@ const inspectRun = async (paths: readonly string[], config: Config, argv: readon
  * 指摘を PR の変更行に出すための出口。--sarif <path> を書いたときだけ作る。
  * 端末の出力は変えない。CI で上げるためのファイルが増えるだけ。
  */
-const writeSarif = (results: readonly Inspected[], argv: readonly string[], config: Config): void => {
+const writeSarif = (results: readonly Inspected[], argv: readonly string[], config: Config, guides: readonly RunGuide[]): void => {
   const path = flag(argv, "--sarif");
   if (path === undefined) return;
   // 文言はファイルの言語で描く。by_path で 1 つの repo に 2 言語が混ざるため。
@@ -141,7 +142,7 @@ const writeSarif = (results: readonly Inspected[], argv: readonly string[], conf
   );
   const notRun = results.flatMap((result) => result.checked.skipped.map((entry) => ({ path: result.outcome.path, rule: entry.rule, why: entry.why })));
   mkdirSync(dirname(path), { recursive: true });
-  writeFileSync(path, renderSarif(located, VERSION, notRun), "utf8");
+  writeFileSync(path, renderSarif(located, VERSION, notRun, guides), "utf8");
   console.log(hostText(config).sarifWritten(path, located.length));
 };
 
@@ -169,7 +170,13 @@ const lint = async (targets: readonly string[], argv: readonly string[], config:
   }
   warnRuleProblems(config, language);
   const results = await inspectRun(paths, config, argv);
-  writeSarif(results, argv, config);
+  const guides = guidesOfRun(
+    results.map((result) => result.checked),
+    config,
+    argv,
+  );
+  writeSarif(results, argv, config, guides);
+  if (!argv.includes("--compact")) guides.forEach((entry) => console.log(renderGuideBlock(entry.guide, entry.language).join("\n")));
   results.filter((result) => result.outcome.findings.length > 0 || paths.length === 1).forEach((result) => console.log(result.text));
   renderSummary(
     results.map((result) => result.outcome),
@@ -255,17 +262,6 @@ type Handler = (argv: readonly string[], config: Config) => number | Promise<num
 /** `--` で始まらない引数。対象のパス。 */
 const positional = (argv: readonly string[]): string[] => targetsOf(argv.slice(1));
 
-/** `rules --json` for an AI to read; `rules` alone, a table for a person. */
-const showRules = (argv: readonly string[], written: Config): number => {
-  const config = withExperimental(written, argv);
-  const language = config.language ?? hostLanguage(undefined, process.env);
-  warnRuleProblems(config, language);
-  const genre = flag(argv, "--genre") ?? config.genre ?? "blog/tech";
-  const rules = rulesOf(language, config);
-  console.log(argv.includes("--json") ? rulesJson(rules, config, language, genre, optionLayersOf(config)) : rulesTable(rules, config, language, genre));
-  return 0;
-};
-
 const showGenres = (config: Config): number => {
   console.log(renderGenres(loadGenres(), hostLanguage(config.language, process.env)));
   return 0;
@@ -282,19 +278,15 @@ const measureContext = (argv: readonly string[], config: Config): { config: Conf
 
 /** 分岐を数珠つなぎにせず表にする。足すときに main を太らせない。 */
 const HANDLERS: Readonly<Record<string, Handler>> = {
-  init: async (argv, config) => {
-    const ui = hostLanguage(config.language, process.env);
-    const chosen = await initGenre(flag(argv, "--genre"), ui, process.cwd());
-    if ("error" in chosen) console.error(chosen.error);
-    else runInit(process.cwd(), chosen.genre, ui).forEach((line) => console.log(line));
-    return "error" in chosen ? 1 : 0;
-  },
+  init: (argv, config) => runInitCommand((name) => flag(argv, name), argv.includes("--plugin"), hostLanguage(config.language, process.env), process.cwd()),
   genres: (_argv, config) => showGenres(config),
-  rules: showRules,
+  rules: (argv, config) => showRules(argv, config, { flag, warn: warnRuleProblems }),
   explain: (argv, config) => explain(config, argv[1], flag(argv, "--genre")),
   eval: (argv, config) => runEval(positional(argv), argv, { ...measureContext(argv, config), flag }),
   ...Object.fromEntries(Object.entries(DOCUMENT_COMMANDS).map(([name, run]): [string, Handler] => [name, (argv, config) => run(argv, treeContext(config))])),
   test: (argv, config) => runTest(positional(argv), argv, { ...measureContext(argv, config), inspect }),
+  "plugin-test": (argv, config) =>
+    runPluginTest(positional(argv)[0], { ui: hostLanguage(config.language, process.env), check: async (...args) => (await inspect(...args)).checked }),
   "fix-plan": (argv, config) =>
     runFixPlan(fixPlanTargets(argv), argv, { ...treeContext(config), check: async (path) => (await inspectAll(config, argv)(path)).checked }),
   baseline: (argv, config) => runBaseline(positional(argv), argv, config),

package/src/commands/feedback.ts

@@ -9,6 +9,7 @@ import { excerptsAround } from "../feedback/excerpt.ts";
 import { feedbackDraft, type FeedbackDraft, type FeedbackKind, type ReportedFinding } from "../feedback/draft.ts";
 import { notRunAmong } from "../not-run.ts";
 import type { Skipped } from "../run.ts";
+import type { GenreSource } from "../cli-text.ts";
 
 export const FEEDBACK_FILE = ".chaff-feedback.md";
 const NEW_ISSUE = "https://github.com/isamu/lab/issues/new";
@@ -20,6 +21,8 @@ export type Checked = {
   readonly rules: readonly RuleDefinition[];
   readonly language: string;
   readonly genre: string;
+  /** Where the genre came from: set (--genre, chaff.yaml, by_path, front matter), guessed or defaulted. */
+  readonly genreFrom: GenreSource;
   /** The rules this check did not run, and why. */
   readonly skipped: readonly Skipped[];
   /** How the check was run, as the reader of a report would repeat it (runConditions). */

package/src/commands/fix-plan.ts

@@ -8,6 +8,9 @@ import { chosenDepthOf } from "../fix-plan/chosen-depth.ts";
 import type { Checked } from "./feedback.ts";
 import { readDocument } from "./read-document.ts";
 import type { TreeContext } from "./tree.ts";
+import { genreWasSet, reportedGuide, type ReportedGuide } from "../genre-guide/report.ts";
+import { showsGuide } from "../cli-args.ts";
+import type { Config } from "../config/load.ts";
 
 /** Options whose value is the next argument. That value is not a file. */
 const VALUED: ReadonlySet<string> = new Set(["--language", "--genre", "--depth"]);
@@ -24,6 +27,10 @@ export type FixPlanContext = TreeContext & {
   readonly check: (path: string) => Promise<Omit<Checked, "conditions">>;
 };
 
+/** The genre's guide, the plan's first section; none when the genre was not set or the guide is off. */
+const guideOf = (checked: Omit<Checked, "conditions">, config: Config, argv: readonly string[]): ReportedGuide | undefined =>
+  genreWasSet(checked.genreFrom) && showsGuide(argv) ? reportedGuide(config, checked.genre, checked.language, checked.rules) : undefined;
+
 /**
  * An instruction document for whoever rewrites the file: the findings grouped by rule, each rule's rewrite direction,
  * the document-level signals, the structure targets from human articles, a recommended mode and the checks to run after. Deterministic; sends nothing anywhere.
@@ -61,6 +68,7 @@ export const runFixPlan = async (targets: readonly string[], argv: readonly stri
     structure: structureOf(prose.doc),
     phrases: prose.doc.lexicons["ai-tell"] ?? [],
     chosenDepth: depth.chosen,
+    guide: guideOf(checked, context.config, argv),
   });
   console.log(argv.includes("--json") ? renderFixPlanJson(plan) : renderFixPlanMarkdown(plan));
   return 0;

package/src/commands/init-command.ts

@@ -0,0 +1,13 @@
+import { runInit } from "../init.ts";
+import type { UiLanguage } from "../ui.ts";
+import { initGenre } from "./init-ask.ts";
+import { runInitPlugin } from "./plugin-init.ts";
+
+/** chaff init: chaff.yaml for a project, or with --plugin, a rule pack to start from. flag reads an option's value. */
+export const runInitCommand = async (flag: (name: string) => string | undefined, plugin: boolean, ui: UiLanguage, dir: string): Promise<number> => {
+  if (plugin) return runInitPlugin(dir, flag("--plugin"), ui);
+  const chosen = await initGenre(flag("--genre"), ui, dir);
+  if ("error" in chosen) console.error(chosen.error);
+  else runInit(dir, chosen.genre, ui).forEach((line) => console.log(line));
+  return "error" in chosen ? 1 : 0;
+};

package/src/commands/plugin-init.ts

@@ -0,0 +1,150 @@
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { API_VERSION } from "../api.ts";
+import { VERSION } from "../version.ts";
+import type { Texts, UiLanguage } from "../ui.ts";
+
+// chaff init --plugin <name>: a rule pack to start from, written in YAML alone. One rule, its word list in Japanese and
+// English, and a test command (chaff plugin-test) that checks each rule's example against the rule.
+
+/** A pack's own name: lowercase letters, digits and hyphens, optionally under a scope (@team/house). */
+const PACK_NAME = /^(?:(@[a-z0-9][a-z0-9._-]*)\/)?([a-z][a-z0-9-]*)$/u;
+
+export type PackName = { readonly scope: string | undefined; readonly name: string };
+
+/** The name as written after --plugin, or undefined when it cannot be a plugin's name. "chaff-plugin-" in front is allowed and dropped. */
+export const packNameOf = (written: string | undefined): PackName | undefined => {
+  const match = PACK_NAME.exec((written ?? "").replace(/(^|\/)chaff-plugin-/u, "$1"));
+  if (match === null) return undefined;
+  const [, scope, name] = match;
+  return name === undefined ? undefined : { scope, name };
+};
+
+/** The package's name and the folder it is made in: chaff-plugin-house, or @team/chaff-plugin-house in chaff-plugin-house. */
+export const packageOf = (pack: PackName): { readonly packageName: string; readonly folder: string } => ({
+  packageName: pack.scope === undefined ? `chaff-plugin-${pack.name}` : `${pack.scope}/chaff-plugin-${pack.name}`,
+  folder: `chaff-plugin-${pack.name}`,
+});
+
+const RULE = `# One rule of the pack. It is written as a rule under custom_rules in chaff.yaml is; see
+# https://isamu.github.io/lab/en/guide/adding-rules for every field.
+id: avoid-words
+type: words
+# The words come from lexicons/<language>/avoid-words.yaml, in the document's language.
+word_list: avoid-words
+name: { ja: チームで使わない言葉, en: A word the team does not use }
+why:
+  ja: このチームでは、同じものを決まった言葉で呼びます。別の言葉が混ざると、読む人は別のものかと迷います。
+  en: The team calls each thing by one word. Another word makes a reader wonder whether it is another thing.
+how_to_fix: { ja: チームの言葉に置き換えます。, en: Use the team's word. }
+message:
+  ja: 「{matched}」ではなく「{preferred}」と書きます
+  en: 'Write "{preferred}", not "{matched}"'
+level: warning
+example:
+  ja: { before: 弊社の新しい窓口をご案内します。, after: 当社の新しい窓口をご案内します。 }
+  en: { before: We utilize the new form for every request., after: We use the new form for every request. }
+rewrite:
+  depth: light
+  ja:
+    direction: 指された言葉だけを、チームの言葉に置き換えます。
+    pairs:
+      - { before: 弊社の新しい窓口をご案内します。, after: 当社の新しい窓口をご案内します。 }
+      - { before: 弊社では毎月点検しています。, after: 当社では毎月点検しています。 }
+    keep: [文のほかの部分]
+    avoid: [言葉と一緒に文の意味を変える]
+  en:
+    direction: Replace only the flagged word with the team's word.
+    pairs:
+      - { before: We utilize the new form for every request., after: We use the new form for every request. }
+      - { before: Utilize the search box first., after: Use the search box first. }
+    keep: [the rest of the sentence]
+    avoid: [changing what the sentence says along with the word]
+`;
+
+const LEXICON_JA = `# 使わない言葉（pattern）と、使う言葉（rewrite）。
+- { pattern: 弊社, rewrite: 当社 }
+`;
+
+const LEXICON_EN = `# The word not to use (pattern) and the word to use (rewrite).
+- { pattern: utilize, rewrite: use }
+`;
+
+const packageJson = (packageName: string): string =>
+  `${JSON.stringify(
+    {
+      name: packageName,
+      version: "0.1.0",
+      description: "Rules for chaff, written in YAML.",
+      files: ["rules", "lexicons", "styles"],
+      chaff: { apiVersion: API_VERSION },
+      scripts: { test: "chaffjs plugin-test ." },
+      peerDependencies: { chaffjs: `>=${VERSION}` },
+    },
+    null,
+    2,
+  )}\n`;
+
+const FILES = (packageName: string): Readonly<Record<string, string>> => ({
+  "package.json": packageJson(packageName),
+  "rules/avoid-words.yaml": RULE,
+  "lexicons/ja/avoid-words.yaml": LEXICON_JA,
+  "lexicons/en/avoid-words.yaml": LEXICON_EN,
+});
+
+const TEXT: Texts<{
+  readonly badName: (written: string) => string;
+  readonly exists: (folder: string) => string;
+  readonly made: (folder: string, packageName: string) => string;
+  readonly next: (folder: string, name: string) => readonly string[];
+}> = {
+  ja: {
+    badName: (written) => `--plugin ${written}: プラグインの名前は英小文字・数字・ハイフンで書きます（house、@team/house）`,
+    exists: (folder) => `${folder} はもうあります。上書きしないので、別の名前にするか消してから実行してください`,
+    made: (folder, packageName) => `${folder}/ に YAML だけのルールの束 ${packageName} を作りました。`,
+    next: (folder, name) => [
+      "",
+      "次に:",
+      `  cd ${folder} && npx chaffjs plugin-test .    ルールの例をルールにかけて確かめる`,
+      `  chaff.yaml に plugins: [./${folder}] と書くと、${name}/avoid-words として動きます`,
+      "",
+    ],
+  },
+  en: {
+    badName: (written) => `--plugin ${written}: a plugin's name is lowercase letters, digits and hyphens (house, @team/house)`,
+    exists: (folder) => `${folder} already exists. Nothing is overwritten; choose another name or remove it first`,
+    made: (folder, packageName) => `Made the YAML rule pack ${packageName} in ${folder}/.`,
+    next: (folder, name) => [
+      "",
+      "Next:",
+      `  cd ${folder} && npx chaffjs plugin-test .    check each rule against its own example`,
+      `  add plugins: [./${folder}] to chaff.yaml and it runs as ${name}/avoid-words`,
+      "",
+    ],
+  },
+};
+
+/** Makes the pack in dir. Lines to print, and whether it was made; nothing is written when the folder is already there. */
+export const initPlugin = (dir: string, written: string | undefined, ui: UiLanguage): { readonly ok: boolean; readonly lines: readonly string[] } => {
+  const text = TEXT[ui];
+  const pack = packNameOf(written);
+  if (pack === undefined) return { ok: false, lines: [text.badName(written ?? "")] };
+  const { packageName, folder } = packageOf(pack);
+  if (existsSync(join(dir, folder))) return { ok: false, lines: [text.exists(folder)] };
+  Object.entries(FILES(packageName)).forEach(([path, body]) => {
+    mkdirSync(dirname(join(dir, folder, path)), { recursive: true });
+    writeFileSync(join(dir, folder, path), body, "utf8");
+  });
+  const name = pack.scope === undefined ? pack.name : `${pack.scope}/${pack.name}`;
+  return {
+    ok: true,
+    lines: [text.made(folder, packageName), ...Object.keys(FILES(packageName)).map((path) => `  ${folder}/${path}`), ...text.next(folder, name)],
+  };
+};
+
+/** chaff init --plugin <name>: makes the pack in dir and says what it made, or why it did not. */
+export const runInitPlugin = (dir: string, written: string | undefined, ui: UiLanguage): number => {
+  const made = initPlugin(dir, written, ui);
+  made.lines.forEach((line) => (made.ok ? console.log(line) : console.error(line)));
+  return made.ok ? 0 : 1;
+};

package/src/commands/plugin-test.ts

@@ -0,0 +1,111 @@
+import { mkdtempSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join, resolve } from "node:path";
+import { EMPTY, type Config } from "../config/load.ts";
+import { withExtensions } from "../extension/load.ts";
+import { extensionProblems } from "../extension/problem-text.ts";
+import { loadGenres } from "../genre-load.ts";
+import type { RuleDefinition } from "../plugin.ts";
+import type { Skipped } from "../run.ts";
+import type { Texts, UiLanguage } from "../ui.ts";
+import type { Checked } from "./feedback.ts";
+
+// chaff plugin-test [folder]: loads a plugin as chaff.yaml would, then runs each of its rules on the rule's own example,
+// in every language the example is written in. The before must give the rule a finding and the after must give it
+// none. A rule that does not run there (no word list for the language) fails, with the reason.
+
+export type PluginTestContext = {
+  readonly ui: UiLanguage;
+  /** Lints one file with these settings, as chaff on the command line does. */
+  readonly check: (path: string, config: Config, argv: readonly string[]) => Promise<Pick<Checked, "findings" | "skipped">>;
+};
+
+type Outcome = { readonly rule: string; readonly language: string; readonly failure: string | undefined };
+
+const TEXT: Texts<{
+  readonly noRules: (dir: string) => string;
+  readonly beforeQuiet: string;
+  readonly afterFlagged: (count: number) => string;
+  readonly notRun: (why: string) => string;
+  readonly noExample: string;
+  readonly summary: (passed: number, total: number) => string;
+}> = {
+  ja: {
+    noRules: (dir) => `${dir} にルールがありません。`,
+    beforeQuiet: "例の before で指摘が出ません",
+    afterFlagged: (count) => `例の after で指摘が ${String(count)} 件出ます`,
+    notRun: (why) => `動きません（${why}）`,
+    noExample: "例がありません",
+    summary: (passed, total) => `${String(total)} 件のうち ${String(passed)} 件が通りました。`,
+  },
+  en: {
+    noRules: (dir) => `${dir} has no rules.`,
+    beforeQuiet: "the example's before gets no finding",
+    afterFlagged: (count) => `the example's after gets ${String(count)} ${count === 1 ? "finding" : "findings"}`,
+    notRun: (why) => `it does not run (${why})`,
+    noExample: "it has no example",
+    summary: (passed, total) => `${String(passed)} of ${String(total)} passed.`,
+  },
+};
+
+/** The first genre the rule is for: the example runs where the rule does. */
+const genreFor = (rule: RuleDefinition): string => {
+  const genres = loadGenres().genres.map((genre) => genre.id);
+  return genres.find((genre) => rule.use_for.some((target) => genre === target || genre.startsWith(`${target}/`))) ?? genres[0] ?? "business/report";
+};
+
+const skippedWhy = (skipped: readonly Skipped[], rule: string): string | undefined => skipped.find((entry) => entry.rule === rule)?.why;
+
+/** One rule in one language: before flagged, after clean. */
+const testExample = async (rule: RuleDefinition, language: string, config: Config, context: PluginTestContext): Promise<Outcome> => {
+  const text = TEXT[context.ui];
+  const example = rule.guide?.examples[language];
+  if (example === undefined) return { rule: rule.id, language, failure: text.noExample };
+  const dir = mkdtempSync(join(tmpdir(), "chaff-plugin-test-"));
+  const argv = ["--language", language, "--genre", genreFor(rule)];
+  const run = async (name: string, body: string): Promise<Pick<Checked, "findings" | "skipped">> => {
+    writeFileSync(join(dir, name), `${body.trimEnd()}\n`, "utf8");
+    return context.check(join(dir, name), config, argv);
+  };
+  const before = await run("before.md", example.before);
+  const why = skippedWhy(before.skipped, rule.id);
+  if (why !== undefined) return { rule: rule.id, language, failure: text.notRun(why) };
+  if (!before.findings.some((finding) => finding.rule === rule.id)) return { rule: rule.id, language, failure: text.beforeQuiet };
+  const after = (await run("after.md", example.after)).findings.filter((finding) => finding.rule === rule.id).length;
+  return { rule: rule.id, language, failure: after === 0 ? undefined : text.afterFlagged(after) };
+};
+
+const lineOf = (outcome: Outcome): string =>
+  outcome.failure === undefined ? `  ✓ ${outcome.rule} (${outcome.language})` : `  ✗ ${outcome.rule} (${outcome.language}): ${outcome.failure}`;
+
+/** The languages a rule's example is written in, or the rule's languages when it has none, so a missing example is said. */
+const languagesOf = (rule: RuleDefinition): readonly string[] => {
+  const written = Object.keys(rule.guide?.examples ?? {});
+  return written.length > 0 ? written : (rule.languages ?? ["ja", "en"]);
+};
+
+/** Exit 0 when every rule passes on every example; 1 when the plugin cannot be loaded or a rule fails. */
+export const runPluginTest = async (folder: string | undefined, context: PluginTestContext): Promise<number> => {
+  const text = TEXT[context.ui];
+  const dir = resolve(folder ?? ".");
+  const config = await withExtensions({ ...EMPTY, plugins: [dir], baseDir: dir, path: dir });
+  const problems = extensionProblems(config, context.ui);
+  if (problems.length > 0) {
+    problems.forEach((problem) => console.error(problem));
+    return 1;
+  }
+  const rules = config.extensions?.rules ?? [];
+  if (rules.length === 0) {
+    console.error(text.noRules(dir));
+    return 1;
+  }
+  const cases = rules.flatMap((rule) => languagesOf(rule).map((language) => ({ rule, language })));
+  const outcomes = await cases.reduce<Promise<Outcome[]>>(
+    async (done, entry) => [...(await done), await testExample(entry.rule, entry.language, config, context)],
+    Promise.resolve([]),
+  );
+  outcomes.map(lineOf).forEach((line) => console.log(line));
+  const passed = outcomes.filter((outcome) => outcome.failure === undefined).length;
+  console.log(`\n${text.summary(passed, outcomes.length)}`);
+  return passed === outcomes.length ? 0 : 1;
+};

package/src/commands/rules.ts

@@ -0,0 +1,34 @@
+import { showsGuide, withExperimental } from "../cli-args.ts";
+import type { Config } from "../config/load.ts";
+import { optionLayersOf } from "../config/option-problems.ts";
+import { rulesOf } from "../custom/load.ts";
+import { reportedGuide } from "../genre-guide/report.ts";
+import { rulesJson } from "../render/rules-json.ts";
+import { rulesTable } from "../render/rules-table.ts";
+import { hostLanguage } from "../ui.ts";
+
+/** The genre the rules are shown for when none is set. */
+const SHOWN_GENRE = "blog/tech";
+
+export type RulesContext = {
+  readonly flag: (argv: readonly string[], name: string) => string | undefined;
+  /** Says once, on stderr, what in the settings has no effect. */
+  readonly warn: (config: Config, language: string) => void;
+};
+
+/** `rules --json` for an AI to read, with the guide of a genre that was set; `rules` alone, a table for a person. */
+export const showRules = (argv: readonly string[], written: Config, context: RulesContext): number => {
+  const config = withExperimental(written, argv);
+  const language = config.language ?? hostLanguage(undefined, process.env);
+  context.warn(config, language);
+  const setGenre = context.flag(argv, "--genre") ?? config.genre;
+  const genre = setGenre ?? SHOWN_GENRE;
+  const rules = rulesOf(language, config);
+  if (!argv.includes("--json")) {
+    console.log(rulesTable(rules, config, language, genre));
+    return 0;
+  }
+  const guide = setGenre !== undefined && showsGuide(argv) ? reportedGuide(config, genre, language, rules) : undefined;
+  console.log(rulesJson(rules, config, language, genre, optionLayersOf(config), guide));
+  return 0;
+};

package/src/config/load.ts

@@ -7,6 +7,7 @@ import type { Level } from "../plugin.ts";
 import type { PathRule } from "./by-path.ts";
 import type { Extensions } from "../extension/load.ts";
 import type { StyleLimits } from "../style-parse.ts";
+import type { GuideLayer } from "../genre-guide/layer.ts";
 
 export const CONFIG_FILE = "chaff.yaml";
 
@@ -46,7 +47,7 @@ export type Config = {
   readonly unreadableOptions?: string | undefined;
   /** The house style chaff.yaml names (styles/*.yaml), as written. A value that is not a name is kept printed, to be reported. */
   readonly style?: string | undefined;
-  /** The style once applied (config/style.ts): its id, the rules whose level it decided, and its options. */
+  /** The style once applied (config/style.ts): its id, the rules whose level it decided, its options and its guide. */
   readonly applied?: AppliedStyle | undefined;
   /** custom_rules as written: the team's own rules. custom/parse.ts reads and checks them. */
   readonly customRules?: unknown;
@@ -54,6 +55,8 @@ export type Config = {
   readonly grade?: unknown;
   /** fix_plan as written: the depth chaff fix-plan rewrites to (fix-plan/chosen-depth.ts reads and checks it). */
   readonly fixPlan?: unknown;
+  /** guide as written: the team's changes to the genre guides, or off (genre-guide/of-config.ts reads it). */
+  readonly guide?: unknown;
   /** plugins as written: package names and paths. extension/plugin-load.ts reads and checks them. */
   readonly plugins?: unknown;
   /** The code chaff.yaml names, once loaded (extension/load.ts). Reading chaff.yaml does not load it. */
@@ -66,6 +69,8 @@ export type AppliedStyle = {
   readonly options: Readonly<Record<string, unknown>>;
   /** The style's numbers, by rule and language, for the rules whose level it decided. */
   readonly limits: StyleLimits;
+  /** The style's changes to the genre guides, when it has any. */
+  readonly guide?: GuideLayer | undefined;
 };
 
 /** 判定の質が誤検知に直結するので、既定は最上位のモデル。cost は絞り込みで削る。spec §14。 */
@@ -200,6 +205,7 @@ export const loadConfig = (path: string): Config => {
     customRules: raw["custom_rules"],
     grade: raw["grade"],
     fixPlan: raw["fix_plan"],
+    guide: raw["guide"],
     plugins: raw["plugins"],
   };
 };

package/src/config/style.ts

@@ -22,7 +22,7 @@ export const withStyle = (config: Config, styles: readonly StyleDefinition[]): C
   return {
     ...config,
     rules: { ...style.rules, ...config.rules },
-    applied: { style: style.id, levelsFrom: fromStyle, options: style.options, limits },
+    applied: { style: style.id, levelsFrom: fromStyle, options: style.options, limits, guide: style.guide },
   };
 };
 

package/src/config/warnings.ts

@@ -4,10 +4,12 @@ import type { UiLanguage } from "../ui.ts";
 import { ruleProblems } from "./rule-problems.ts";
 import { nameProblems } from "./name-problems.ts";
 import { configOptionProblems } from "./option-problems.ts";
+import { configGuideProblems } from "../genre-guide/of-config.ts";
 
-/** Everything in chaff.yaml that has no effect: unknown rules or levels, unreadable names, options that do not apply. Said before the results. */
+/** Everything in chaff.yaml that has no effect: unknown rules or levels, unreadable names, options that do not apply, guides that cannot be read. Said before the results. */
 export const settingWarnings = (config: Config, rules: readonly RuleDefinition[], ui: UiLanguage): string[] => [
   ...ruleProblems(config, rules, ui),
   ...nameProblems(config, ui),
   ...configOptionProblems(config, rules, ui),
+  ...configGuideProblems(config, ui),
 ];

package/src/custom/problems.ts

@@ -5,7 +5,7 @@ import { customRulesOf } from "./load.ts";
 import { MAX_PATTERN_LENGTH, MAX_REPEATS, type RegexRefusal } from "./regex-safety.ts";
 import { POS_WRITTEN_NAMES } from "./token-pattern.ts";
 import type { ModulePathRefusal } from "./module-path.ts";
-import { fieldProblemSentence, type FieldKind, type FieldProblem } from "../rule-fields.ts";
+import { FIELD_KINDS, fieldProblemSentence, type FieldKind, type FieldProblem } from "../rule-fields.ts";
 
 /** Each problem's sentence, with {at}, {written}, {field}, {index}, {refusal} and {names} filled in from the problem. */
 type Text = {
@@ -111,8 +111,6 @@ const valuesOf = (problem: CustomProblem, text: Text, scope: string): Readonly<R
   names: POS_WRITTEN_NAMES.join(" / "),
 });
 
-const FIELD_KINDS: ReadonlySet<string> = new Set<FieldKind>(["bad-depth", "bad-group", "bad-use-for", "bad-summary", "bad-example"]);
-
 const isFieldProblem = (problem: CustomProblem): problem is FieldProblem & { readonly at: string } => FIELD_KINDS.has(problem.kind);
 
 /** One problem as a sentence. scope names the list the rule is in: custom_rules, or a plugin's rules. */

package/src/detectors/amount-for-count.ts

@@ -0,0 +1,90 @@
+import type { Detector, Finding, Lexicon, Token } from "../plugin.ts";
+import { endsNounPhrase } from "./agreement-slip.ts";
+import { isPartOfLongerWord } from "./doubled-word.ts";
+
+/**
+ * 量を言う語を、数えられる名詞の複数に付けた所（less errors、less customer complaints）。語は語彙表 amount-quantifier が言う。
+ * 前が名詞か数なら「引く」の less（revenue less costs、$500 less fees）なので読まない。
+ */
+
+export type AmountLists = {
+  /** 量を言う語（less）と、数を言う語（fewer, rewrite）。 */
+  readonly quantifiers: Lexicon;
+  /** 複数の形でも数えない名詞。単数と複数が同じ綴りの語（series）と、金額を言う複数（earnings）。 */
+  readonly uncounted: ReadonlySet<string>;
+  /** 名詞にならない be / have の形。名詞句がそこで終わる。 */
+  readonly finite: ReadonlySet<string>;
+};
+
+export type AmountSlip = { readonly quantifier: Token; readonly noun: Token; readonly rewrite: string };
+
+const UPPER_START = /^\p{Lu}/u;
+
+/** 前に立てば、量の語が限定詞として読める品詞。名詞・数・記号の後ろは「引く」の less。 */
+const OPENS_PHRASE = new Set(["VERB", "AUX", "ADP", "CCONJ", "SCONJ", "ADV", "PART"]);
+const OPENING_MARK = new Set(["(", "[", "{", '"', "'", "“", "‘"]);
+
+const lower = (token: Token): string => token.surface.toLowerCase();
+
+/** 解析器は三人称の動詞を複数の名詞と読むことがある（The parser reports less errors の reports）。 */
+const mayBeVerb = (token: Token): boolean => token.pos === "NOUN" && token.features?.["AlsoVerb"] === "Yes" && token.features["Number"] === "Plur";
+
+const opensPhrase = (previous: Token | undefined): boolean =>
+  previous === undefined || OPENS_PHRASE.has(previous.pos) || OPENING_MARK.has(previous.surface) || mayBeVerb(previous);
+
+const isCommonNoun = (token: Token | undefined): token is Token =>
+  token?.pos === "NOUN" && token.features?.["Guess"] !== "Yes" && !UPPER_START.test(token.surface);
+
+const isPlural = (token: Token): boolean => token.features?.["Number"] === "Plur";
+
+/** 複数の形がはっきりした、数えられる普通名詞。形から当てた語（stimuli）と、数えない語は読まない。 */
+const isCountedPlural = (noun: Token | undefined, uncounted: ReadonlySet<string>): noun is Token =>
+  isCommonNoun(noun) && isPlural(noun) && !uncounted.has(lower(noun));
+
+/** less の後ろの名詞の頭。単数の名詞を一つ重ねた語（less customer complaints）は、その後ろの語。 */
+const headAt = (tokens: readonly Token[], at: number): number => {
+  const next = tokens[at + 1];
+  return isCommonNoun(next) && !isPlural(next) ? at + 2 : at + 1;
+};
+
+const slipAt = (source: string, tokens: readonly Token[], at: number, lists: AmountLists): AmountSlip | undefined => {
+  const quantifier = tokens[at];
+  const entry = quantifier === undefined ? undefined : lists.quantifiers.find((candidate) => candidate.pattern.toLowerCase() === lower(quantifier));
+  if (quantifier?.pos !== "ADJ" || entry === undefined || !opensPhrase(tokens[at - 1])) return undefined;
+  const head = headAt(tokens, at);
+  const noun = tokens[head];
+  if (!isCountedPlural(noun, lists.uncounted) || !endsNounPhrase(tokens[head + 1], lists.finite) || isPartOfLongerWord(source, quantifier, noun))
+    return undefined;
+  return { quantifier, noun, rewrite: entry.rewrite ?? "" };
+};
+
+export const amountSlipsIn = (source: string, tokens: readonly Token[], lists: AmountLists): AmountSlip[] =>
+  tokens.flatMap((_, at) => slipAt(source, tokens, at, lists) ?? []);
+
+const patternsOf = (lexicon: Lexicon): string[] => lexicon.map((entry) => entry.pattern.toLowerCase());
+
+const listsOf = (lexicons: Readonly<Record<string, Lexicon>>): AmountLists => {
+  const words = lexicons["amount-quantifier"] ?? [];
+  return {
+    quantifiers: words.filter((entry) => entry.group === "quantifier"),
+    uncounted: new Set([...patternsOf(lexicons["invariant-noun"] ?? []), ...patternsOf(words.filter((entry) => entry.group === "amount"))]),
+    finite: new Set(patternsOf(lexicons["finite-auxiliary"] ?? [])),
+  };
+};
+
+export const amountForCount: Detector = (doc): Finding[] => {
+  const lists = listsOf(doc.lexicons);
+  return doc.sentences.flatMap((sentence) =>
+    amountSlipsIn(doc.source, sentence.tokens ?? [], lists).map((slip): Finding => {
+      const rest = doc.source.slice(slip.quantifier.span.end, slip.noun.span.end).replace(/\s+/gu, " ");
+      return {
+        rule: "",
+        severity: "warning",
+        line: 0,
+        column: 0,
+        quote: sentence.text.trim(),
+        values: { word: `${slip.quantifier.surface}${rest}`, suggestion: `${slip.rewrite}${rest}`, offset: slip.quantifier.span.start },
+      };
+    }),
+  );
+};