chaffjs 0.17.0 → 0.18.0

package/src/compare/written-names.ts

@@ -0,0 +1,26 @@
+import type { Atom } from "./atom.ts";
+
+const occurrences = (text: string, needle: string): number => {
+  let count = 0;
+  for (let at = text.indexOf(needle); at !== -1 && needle !== ""; at = text.indexOf(needle, at + needle.length)) count += 1;
+  return count;
+};
+
+const namesPerKey = (atoms: readonly Atom[]): Map<string, number> =>
+  atoms.reduce((counts, atom) => (atom.kind === "name" ? counts.set(atom.key, (counts.get(atom.key) ?? 0) + 1) : counts), new Map<string, number>());
+
+/**
+ * The names among changes that the other document does not write as often as this one names them. The tagger reads
+ * a word as a name by its context (赤松 after から, Scammers before could), so a rewrite can change the tagging without
+ * changing the name; the spelling decides. otherText is the other document's prose spelled as name keys are.
+ */
+export const unwrittenNames = (changes: readonly Atom[], own: readonly Atom[], otherText: string): Atom[] => {
+  const named = namesPerKey(own);
+  const left = new Map<string, number>();
+  return changes.filter((atom) => {
+    if (atom.kind !== "name") return true;
+    const remaining = left.get(atom.key) ?? Math.max(0, (named.get(atom.key) ?? 0) - occurrences(otherText, atom.key));
+    left.set(atom.key, Math.max(0, remaining - 1));
+    return remaining > 0;
+  });
+};

package/src/config/load.ts

@@ -37,6 +37,22 @@ export type Config = {
   /** パスごとの上書き。設定ファイルのある場所からの相対で照合する。 */
   readonly byPath: readonly PathRule[];
   readonly baseDir: string;
+  /** Options set on rules that take them: { rule id: { option: value } }, as written. rule-options.ts checks them against the rules. */
+  readonly options?: Readonly<Record<string, unknown>>;
+  /** options as written when it is not a map. Dropping it silently would leave a team thinking its options apply. */
+  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. */
+  readonly applied?: AppliedStyle | undefined;
+  /** custom_rules as written: the team's own rules. custom/parse.ts reads and checks them. */
+  readonly customRules?: unknown;
+};
+
+export type AppliedStyle = {
+  readonly style: string;
+  readonly levelsFrom: readonly string[];
+  readonly options: Readonly<Record<string, unknown>>;
 };
 
 /** 判定の質が誤検知に直結するので、既定は最上位のモデル。cost は絞り込みで削る。spec §14。 */
@@ -144,6 +160,7 @@ export const loadConfig = (path: string): Config => {
   const declared: unknown = raw["ai_backend"];
   const backend: BackendName = isBackend(declared) ? declared : DEFAULT_BACKEND;
   const names = namesOf(raw["names"]);
+  const options: unknown = raw["options"];
   return {
     genre: str(raw["genre"]),
     profile: str(raw["profile"]),
@@ -163,5 +180,9 @@ export const loadConfig = (path: string): Config => {
     unreadableNames: names.unreadable,
     byPath: byPathOf(raw["by_path"]),
     baseDir: dirname(path),
+    options: isRecord(options) ? options : {},
+    unreadableOptions: options === undefined || options === null || isRecord(options) ? undefined : printed(options),
+    style: raw["style"] === undefined || raw["style"] === null ? undefined : (str(raw["style"]) ?? printed(raw["style"])),
+    customRules: raw["custom_rules"],
   };
 };

package/src/config/option-problems.ts

@@ -0,0 +1,70 @@
+import { CONFIG_FILE, type Config } from "./load.ts";
+import type { RuleDefinition, RuleOption } from "../plugin.ts";
+import { optionProblems, type OptionLayer, type OptionProblem } from "../rule-options.ts";
+import { styleLevelSource, styleSource } from "./style.ts";
+import type { Texts, UiLanguage } from "../ui.ts";
+
+/** Where chaff.yaml's options come from, for settleOptions: the file itself. */
+export const configOptionLayer = (config: Pick<Config, "options">): OptionLayer => ({
+  from: CONFIG_FILE,
+  values: config.options ?? {},
+});
+
+/** Where a rule's settings come from, for explain: the option layers, and the style when it set the level. */
+export const settingSourcesOf = (
+  config: Pick<Config, "options" | "applied">,
+  ruleId: string,
+): { optionLayers: OptionLayer[]; levelFrom: string | undefined } => ({
+  optionLayers: optionLayersOf(config),
+  levelFrom: styleLevelSource(config, ruleId),
+});
+
+/** Every place options come from, strongest first: chaff.yaml, then its style. */
+export const optionLayersOf = (config: Pick<Config, "options" | "applied">): OptionLayer[] => [
+  configOptionLayer(config),
+  ...(config.applied === undefined ? [] : [{ from: styleSource(config.applied.style), values: config.applied.options }]),
+];
+
+type ProblemText = {
+  readonly notAMap: (where: string, value: string) => string;
+  readonly problem: (where: string, problem: OptionProblem) => string;
+};
+
+const TEXT: Texts<ProblemText> = {
+  ja: {
+    notAMap: (where, value) => `${where}: options の ${value} は読めません。ルールの名前の下に、オプションの名前と値を並べてください`,
+    problem: (where, problem) => {
+      if (problem.kind === "unknown-rule") return `${where}: options の ${problem.rule} というルールはありません（npx chaff rules --json で一覧が出ます）`;
+      if (problem.kind === "no-options") return `${where}: ${problem.rule} にはオプションがありません。options に書いても何も変わりません`;
+      if (problem.kind === "not-a-map") return `${where}: options の ${problem.rule} の下には、オプションの名前と値を並べてください`;
+      if (problem.kind === "unknown-option")
+        return `${where}: ${problem.rule} に ${problem.option} というオプションはありません（使えるのは ${problem.known.join(" / ")}）`;
+      return `${where}: ${problem.rule} の ${problem.option} の値 ${problem.value} は読めません（${problem.expected}）。既定のまま動きます`;
+    },
+  },
+  en: {
+    notAMap: (where, value) => `${where}: cannot read ${value} under options. Under each rule's name, list option names and values`,
+    problem: (where, problem) => {
+      if (problem.kind === "unknown-rule") return `${where}: there is no rule named ${problem.rule} under options (npx chaff rules --json lists them)`;
+      if (problem.kind === "no-options") return `${where}: ${problem.rule} takes no options, so writing some changes nothing`;
+      if (problem.kind === "not-a-map") return `${where}: under options, ${problem.rule} needs option names and values`;
+      if (problem.kind === "unknown-option") return `${where}: ${problem.rule} has no option ${problem.option} (it takes ${problem.known.join(" / ")})`;
+      return `${where}: cannot read ${problem.value} as ${problem.rule}'s ${problem.option} (${problem.expected}); it stays at its default`;
+    },
+  },
+};
+
+const optionsByRule = (rules: readonly RuleDefinition[]): Record<string, Readonly<Record<string, RuleOption>>> =>
+  Object.fromEntries(rules.map((rule) => [rule.id, rule.options ?? {}]));
+
+/** chaff.yaml's options that change nothing. Said on every run, like an unknown rule under rules: silence would look like it applied. */
+export const configOptionProblems = (
+  config: Pick<Config, "options" | "unreadableOptions" | "path">,
+  rules: readonly RuleDefinition[],
+  ui: UiLanguage,
+): string[] => {
+  const text = TEXT[ui];
+  const where = config.path ?? "chaff.yaml";
+  if (config.unreadableOptions !== undefined) return [text.notAMap(where, config.unreadableOptions)];
+  return optionProblems(configOptionLayer(config), optionsByRule(rules)).map((problem) => text.problem(where, problem));
+};

package/src/config/read.ts

@@ -0,0 +1,8 @@
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { CONFIG_FILE, EMPTY, loadConfig, type Config } from "./load.ts";
+import { withStyle } from "./style.ts";
+import { loadStyles } from "../style-load.ts";
+
+/** The chaff.yaml in dir with its style applied, or the defaults when there is none. */
+export const readConfigIn = (dir: string): Config => (existsSync(join(dir, CONFIG_FILE)) ? withStyle(loadConfig(join(dir, CONFIG_FILE)), loadStyles()) : EMPTY);

package/src/config/rule-problems.ts

@@ -1,21 +1,27 @@
 import type { Config } from "./load.ts";
+import type { RuleDefinition } from "../plugin.ts";
 import type { Texts, UiLanguage } from "../ui.ts";
 
 const TEXT: Texts<{
   readonly unknown: (where: string, id: string) => string;
   readonly unreadable: (where: string, id: string, value: string) => string;
   readonly numberOnSemantic: (where: string, id: string) => string;
+  readonly numberOnSeverity: (where: string, id: string) => string;
 }> = {
   ja: {
     unknown: (where, id) => `${where}: ${id} というルールはありません（npx chaff rules --json で一覧が出ます）`,
     unreadable: (where, id, value) => `${where}: ${id} の値 ${value} は読めません（strict / normal / relaxed / off か、正の数）`,
     numberOnSemantic: (where, id) =>
       `${where}: ${id} は意味を読む検査なので数値の上限はありません。normal として動きます（strict / normal / relaxed / off で書いてください）`,
+    numberOnSeverity: (where, id) =>
+      `${where}: ${id} には数の上限がありません。normal として動きます（段階は指摘の重さを変えます。relaxed で一段軽く、off で止まります）`,
   },
   en: {
     unknown: (where, id) => `${where}: there is no rule named ${id} (npx chaff rules --json lists them)`,
     unreadable: (where, id, value) => `${where}: cannot read ${value} as the level of ${id} (strict / normal / relaxed / off, or a positive number)`,
     numberOnSemantic: (where, id) => `${where}: ${id} reads meaning and has no numeric limit; it runs as normal (write strict / normal / relaxed / off)`,
+    numberOnSeverity: (where, id) =>
+      `${where}: ${id} has no numeric limit; it runs as normal (its levels set how a finding is marked: relaxed lowers it a step, off stops it)`,
   },
 };
 
@@ -25,7 +31,7 @@ const TEXT: Texts<{
  */
 export const ruleProblems = (
   config: Pick<Config, "rules" | "limits" | "unreadableRules" | "path">,
-  known: readonly { readonly id: string; readonly layer: string }[],
+  known: readonly Pick<RuleDefinition, "id" | "layer" | "level_sets">[],
   ui: UiLanguage = "ja",
 ): string[] => {
   const text = TEXT[ui];
@@ -39,5 +45,9 @@ export const ruleProblems = (
   const numberOnSemantic = Object.keys(config.limits)
     .filter((id) => semantic.has(id))
     .map((id) => text.numberOnSemantic(where, id));
-  return [...unknown, ...unreadable, ...numberOnSemantic];
+  const nothingToCount = new Set(known.filter((rule) => rule.layer !== "L4" && rule.level_sets === "severity").map((rule) => rule.id));
+  const numberOnSeverity = Object.keys(config.limits)
+    .filter((id) => nothingToCount.has(id))
+    .map((id) => text.numberOnSeverity(where, id));
+  return [...unknown, ...unreadable, ...numberOnSemantic, ...numberOnSeverity];
 };

package/src/config/style.ts

@@ -0,0 +1,42 @@
+import type { Config } from "./load.ts";
+import type { StyleDefinition } from "../style-parse.ts";
+import type { Texts, UiLanguage } from "../ui.ts";
+
+/** How a style is named where a setting's source is shown (rules --json, explain). */
+export const styleSource = (id: string): string => `style: ${id}`;
+
+/** Where a rule's level came from when the style set it; undefined when chaff.yaml, the genre or the default did. */
+export const styleLevelSource = (config: Pick<Config, "applied">, ruleId: string): string | undefined =>
+  config.applied?.levelsFrom.includes(ruleId) === true ? styleSource(config.applied.style) : undefined;
+
+/**
+ * chaff.yaml with its style applied. A style's levels sit under chaff.yaml's own rules and over the genre's preset, since
+ * they join rules (which run.ts already puts over the preset). Its options become a layer under chaff.yaml's options.
+ * Without a style, or with one chaff does not have (settingProblems stops the run on that), the config is unchanged.
+ */
+export const withStyle = (config: Config, styles: readonly StyleDefinition[]): Config => {
+  const style = styles.find((entry) => entry.id === config.style);
+  if (style === undefined) return config;
+  const fromStyle = Object.keys(style.rules).filter((id) => config.rules[id] === undefined && config.limits[id] === undefined);
+  return {
+    ...config,
+    rules: { ...style.rules, ...config.rules },
+    applied: { style: style.id, levelsFrom: fromStyle, options: style.options },
+  };
+};
+
+const TEXT: Texts<{ readonly unknown: (where: string, style: string, known: string) => string }> = {
+  ja: {
+    unknown: (where, style, known) => `${where}: style: ${style} というスタイルはありません。使えるのは ${known} です`,
+  },
+  en: {
+    unknown: (where, style, known) => `${where}: there is no style named ${style}. The styles are ${known}`,
+  },
+};
+
+/** A style chaff does not have. It stops the run, like an unknown genre: running without it would check less than was asked. */
+export const styleProblems = (config: Pick<Config, "style" | "path">, styles: readonly StyleDefinition[], ui: UiLanguage): string[] => {
+  const written = config.style;
+  if (written === undefined || styles.some((style) => style.id === written)) return [];
+  return [`chaff: ${TEXT[ui].unknown(config.path ?? "chaff.yaml", written, styles.map((style) => style.id).join(", "))}`];
+};

package/src/config/warnings.ts

@@ -0,0 +1,13 @@
+import type { Config } from "./load.ts";
+import type { RuleDefinition } from "../plugin.ts";
+import type { UiLanguage } from "../ui.ts";
+import { ruleProblems } from "./rule-problems.ts";
+import { nameProblems } from "./name-problems.ts";
+import { configOptionProblems } from "./option-problems.ts";
+
+/** Everything in chaff.yaml that has no effect: unknown rules or levels, unreadable names, options that do not apply. 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),
+];

package/src/config/write.ts

@@ -1,7 +1,8 @@
 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 { definedLevels, severityAt } from "../levels.ts";
+import { SEVERITY_NAME, withArticle } from "../render/severity-name.ts";
+import { readableText } from "../render/text.ts";
 import type { Level, RuleDefinition } from "../plugin.ts";
 import { uiLanguageOf, type Texts } from "../ui.ts";
 
@@ -10,6 +11,7 @@ const TEXT: Texts<{
   readonly noSuchLevel: (id: string, level: string) => string;
   readonly hasReason: (id: string, previous: string) => string;
   readonly done: (id: string, level: string, path: string) => string;
+  readonly severityMoved: (from: string, to: string) => string;
 }> = {
   ja: {
     template: `# chaff.yaml — このチームの文章規範
@@ -22,6 +24,7 @@ rules:
     noSuchLevel: (id, level) => `${id} に ${level} はありません。normal と同じ設定です。\n設定は変更しませんでした。`,
     hasReason: (id, previous) => `${id} には既に理由が書かれています:\n  ${previous}\n値を変えるときは --why で新しい理由を書いてください。`,
     done: (id, level, path) => `${id} を ${level} にしました（${path}）`,
+    severityMoved: (from, to) => `このルールに数の上限はありません。指摘は消えず、${from} ではなく ${to} として出ます。`,
   },
   en: {
     template: `# chaff.yaml — this team's writing rules
@@ -34,6 +37,7 @@ rules:
     noSuchLevel: (id, level) => `${id} has no ${level} level; it is the same as normal.\nThe settings were not changed.`,
     hasReason: (id, previous) => `${id} already has a reason:\n  ${previous}\nTo change the level, give a new reason with --why.`,
     done: (id, level, path) => `Set ${id} to ${level} (${path})`,
+    severityMoved: (from, to) => `This rule has no numeric limit: its findings still show, as ${withArticle(to)} instead of ${withArticle(from)}.`,
   },
 };
 
@@ -47,7 +51,8 @@ const reasonOf = (value: unknown): string | undefined => {
   return text.length === 0 ? undefined : text;
 };
 
-const ruleComment = (rule: RuleDefinition, language: string): string => ` ${localized(rule.name, language)}\n ${localized(rule.why, language)}`;
+const ruleComment = (rule: RuleDefinition, language: string): string =>
+  ` ${readableText(rule, rule.name, language)}\n ${readableText(rule, rule.why, language)}`;
 
 const load = (path: string, language: string): Document => parseDocument(existsSync(path) ? readFileSync(path, "utf8") : TEXT[uiLanguageOf(language)].template);
 
@@ -83,5 +88,14 @@ export const applyLevel = (path: string, rule: RuleDefinition, level: Level, why
     existing.value = value;
   }
   writeFileSync(path, String(doc), "utf8");
-  return { ok: true, message: text.done(rule.id, level, path) };
+  return { ok: true, message: [text.done(rule.id, level, path), ...severityNote(rule, level, language)].join("\n") };
+};
+
+/** relax on a rule with nothing to count keeps its findings and lowers them; say so, or the change looks like it did nothing. */
+const severityNote = (rule: RuleDefinition, level: Level, language: string): string[] => {
+  if (level === "off") return [];
+  const [from, to] = [severityAt(rule, "normal"), severityAt(rule, level)];
+  if (from === to) return [];
+  const ui = uiLanguageOf(language);
+  return [TEXT[ui].severityMoved(SEVERITY_NAME[ui][from], SEVERITY_NAME[ui][to])];
 };

package/src/custom/bounded-match.ts

@@ -0,0 +1,58 @@
+import { createContext, Script } from "node:vm";
+
+// A team's regular expression, run with a time limit. regex-safety.ts refuses the shapes known to run away before a pattern
+// is used; no reading of the pattern can prove every shape safe, so this is the backstop. V8 can interrupt a regular
+// expression only through vm's timeout, so the matching runs in a vm context.
+
+/** How long one rule's pattern may take over one document. Far above what a sane pattern needs on any real document. */
+export const PATTERN_BUDGET_MS = 1000;
+
+/** A pattern that did not finish within its budget. run.ts lists the rule as not run, with this as the reason. */
+export class PatternTimeout extends Error {
+  readonly budget_ms: number;
+  constructor(budgetMs: number) {
+    super(`the pattern did not finish within ${String(budgetMs)} ms`);
+    this.name = "PatternTimeout";
+    this.budget_ms = budgetMs;
+  }
+}
+
+/** Each text's matches: where it starts and what it matched. Empty matches are left out. */
+export type TextMatches = readonly (readonly { readonly index: number; readonly text: string }[])[];
+
+const SCRIPT = new Script(
+  `texts.map((text) => [...text.matchAll(new RegExp(source, flags))].filter((m) => m[0] !== "").map((m) => ({ index: m.index, text: m[0] })))`,
+);
+
+const isTimeout = (error: unknown): boolean => typeof error === "object" && error !== null && "code" in error && error.code === "ERR_SCRIPT_EXECUTION_TIMEOUT";
+
+const isMatches = (value: unknown): value is TextMatches =>
+  Array.isArray(value) &&
+  value.every(
+    (entry: unknown) =>
+      Array.isArray(entry) &&
+      entry.every(
+        (match: unknown) =>
+          typeof match === "object" &&
+          match !== null &&
+          "index" in match &&
+          typeof match.index === "number" &&
+          "text" in match &&
+          typeof match.text === "string",
+      ),
+  );
+
+/** Every match of the pattern (flags without g) in each text, or PatternTimeout when the whole run takes longer than budgetMs. */
+export const boundedMatches = (source: string, flags: string, texts: readonly string[], budgetMs: number = PATTERN_BUDGET_MS): TextMatches => {
+  const context = createContext({ texts: [...texts], source, flags: `g${flags}` });
+  try {
+    const result: unknown = SCRIPT.runInContext(context, { timeout: budgetMs });
+    // The result is built in another context; copy it through JSON so it holds plain values of this one.
+    const plain: unknown = JSON.parse(JSON.stringify(result));
+    if (!isMatches(plain)) throw new Error("chaff: the pattern's matches came back in an unexpected shape");
+    return plain;
+  } catch (error) {
+    if (isTimeout(error)) throw new PatternTimeout(budgetMs);
+    throw error;
+  }
+};

package/src/custom/load.ts

@@ -0,0 +1,15 @@
+import type { Config } from "../config/load.ts";
+import type { RuleDefinition } from "../plugin.ts";
+import { loadRules } from "../rule-load.ts";
+import { loadGenres } from "../genre-load.ts";
+import { parseCustomRules, type CustomRules } from "./parse.ts";
+
+/** The team's custom_rules as rules, with what could not be read. A team's rule applies to every genre, like the team's words. */
+export const customRulesOf = (config: Pick<Config, "customRules">): CustomRules =>
+  parseCustomRules(config.customRules, {
+    builtIn: new Set(loadRules("en").map((rule) => rule.id)),
+    useFor: loadGenres().groups.map((group) => group.id),
+  });
+
+/** Every rule a run knows for a language: chaff's own, then the team's. Where the team's cannot be read, settingProblems stops the run. */
+export const rulesOf = (language: string, config: Pick<Config, "customRules">): RuleDefinition[] => [...loadRules(language), ...customRulesOf(config).rules];