rulebookguard 0.5.1 → 0.6.0

package/README.md

@@ -41,7 +41,7 @@ language: es # default: en; language of the text that rulebookguard generates
 
 `schema` and `testGlobs` are required (`testGlobs: []` is valid but finds no tags). Unknown fields are rejected.
 
-`language` (`en` or `es`) sets the language of the text rulebookguard writes for you, such as the template of `new`. Rule content is free text and is never checked for language, so rules can be written in any language whatever this setting says. `language` needs rulebookguard 0.1.1 or later; older versions reject it as an unknown field. The JSON Schemas ship with the package under `rulebookguard/schemas/v1/`.
+`language` (`en` or `es`) sets the language of the text rulebookguard writes for you: the template of `new`, the hook context, the site, and every message printed once the config is loaded (lint findings, errors, warnings and headers, also the `message` of `--json` output). Lint codes, JSON keys and values such as `active` stay in English, and so do `--help`, argument errors and the findings of an invalid config file, which come before the config is read. Rule content is free text and is never checked for language, so rules can be written in any language whatever this setting says. `language` needs rulebookguard 0.1.1 or later; older versions reject it as an unknown field. The JSON Schemas ship with the package under `rulebookguard/schemas/v1/`.
 
 Inside a git work tree, files are listed with `git ls-files --cached --others --exclude-standard`, so anything in `.gitignore` (`dist/`, `coverage/`, caches) is never matched by anchors or test globs; files inside submodules are listed too. A submodule path that is a symlink, or that resolves outside the rulebook root, is skipped. A test file that is a symlink is scanned for `@rule` tags only when its target lies inside the rulebook root. If one submodule cannot be listed, commands print `warning: could not list files of submodule "<path>" (<reason>); skipping it.` and keep the rest of the git listing. Outside git, or when the rulebook root itself is git-ignored, the whole tree is walked, skipping only `.git` and `node_modules`. If git fails (for example, git is missing from `PATH` or the repository has dubious ownership), commands print one warning on stderr and walk the tree instead.
 
@@ -184,7 +184,7 @@ $ rulebookguard list --context clients --status active
 R-CLI-001 [active] A client document number is unique per country.
 ```
 
-Exits 1 for an unknown context and 2 for an invalid status.
+Prints `No rules found.` when no rule matches, and `contexts` says so when the catalog has no context yet. Exits 1 for an unknown context and 2 for an invalid status.
 
 ### `show <id>` (L2)
 
@@ -194,7 +194,9 @@ R-CLI-001: A client document number is unique per country.
 context: clients
 status: active
 entities: Client
-anchors: src/clients/**/*.ts, src/api/clients.controller.ts
+anchors:
+  src/clients/**/*.ts
+  src/api/clients.controller.ts
 supersedes: R-CLI-000
 file: docs/rules/clients/R-CLI-001.md
 
@@ -231,7 +233,7 @@ Tests tagging R-CLI-001 (1):
 
 Exits 1 for an unknown id.
 
-### `new <context>`
+### `new <context> [--prefix <P>]`
 
 Scaffolds the next free id of a context as a `proposed` rule and prints its path. Ids are never reused, and an existing file is never overwritten. The placeholder text of the new rule follows `language` in the config.
 
@@ -240,7 +242,15 @@ $ rulebookguard new clients
 docs/rules/clients/R-CLI-004.md
 ```
 
-Exits 1 for an unknown context or when the context has no free id left.
+When the context does not exist yet, `new` creates its `_context.md` first and prints both paths. The prefix defaults to the first three letters and digits of the name, upper-cased; `--prefix` sets another one.
+
+```sh
+$ rulebookguard new inventory
+docs/rules/inventory/_context.md
+docs/rules/inventory/R-INV-001.md
+```
+
+Exits 1, writing nothing, when the context has no free id left, when the name is not lowercase letters, digits, `-` or `_`, when the prefix is invalid or already used by another context, or when `--prefix` differs from the prefix of an existing context.
 
 ### `hook`
 
@@ -308,7 +318,7 @@ Generated text and the interface follow `language` in the config. The site is a
 
 ### `lint [--base <ref>] [--json]`
 
-Checks the whole catalog. Each finding is printed as `<severity> <code> <file>[:line] <message>`, followed by a count.
+Checks the whole catalog. Each finding is printed as `<severity> <code> <file>[:line] <message>`, with a `hint:` line under it that says how to fix it, followed by a count.
 
 | Severity | Code                     | Meaning                                                          |
 | -------- | ------------------------ | ---------------------------------------------------------------- |
@@ -329,7 +339,9 @@ Checks the whole catalog. Each finding is printed as `<severity> <code> <file>[:
 ```sh
 $ rulebookguard lint
 error untested-rule docs/rules/billing/R-BIL-002.md active rule R-BIL-002 has no test tagging it
+  hint: add "@rule R-BIL-002" to a test in a file matched by testGlobs, or set the rule's status to proposed
 warning context-over-budget docs/rules/clients/_context.md context "clients" has 31 rules, more than the contextBudget of 30
+  hint: split the context into smaller ones, or raise contextBudget in rulebookguard.config.yaml
 1 error, 1 warning
 ```
 
@@ -340,10 +352,11 @@ With `--base <ref>`, lint also compares `<ref>` with the working tree (`git diff
 ```sh
 $ rulebookguard lint --base origin/main
 error pending-implementation docs/rules/clients/R-CLI-001.md rule R-CLI-001 changed since origin/main but none of the tests tagging it changed
+  hint: update or add a test tagging R-CLI-001 that covers the changed rule
 1 error, 0 warnings
 ```
 
-`--json` prints `{ "findings": [{ "severity", "code", "file", "line"?, "message" }], "errors", "warnings" }`.
+`--json` prints `{ "findings": [{ "severity", "code", "file", "line"?, "message", "hint" }], "errors", "warnings" }`.
 
 ## CI recipe
 

package/dist/{anchors-BFJCm1NU.mjs → anchors-e6T9BNoV.mjs}

@@ -1,4 +1,4 @@
-import { h as createGlobMatcher, v as toRepoPath } from "./lint-C1yUeLOq.mjs";
+import { h as createGlobMatcher, v as toRepoPath } from "./lint-D63Q2SM0.mjs";
 // src/catalog/anchors.ts
 function rulesForPath(rules, path) {
 	const target = toRepoPath(path);

package/dist/cli.mjs

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
-import { M as FormatError, N as formatIssue, a as CliError, c as openCatalog, d as scanTestTags, f as findRulebookRoot, g as expandGlobs, l as writeJson, o as findRule, p as loadCatalog, r as lintCommand, s as gitFallbackWarning, u as writeLines, v as toRepoPath } from "./lint-C1yUeLOq.mjs";
-import { t as rulesForPath } from "./anchors-BFJCm1NU.mjs";
-import { readdir, writeFile } from "node:fs/promises";
+import { M as messages, N as FormatError, P as formatIssue, T as CONTEXT_FILE_NAME, a as CliError, c as openCatalog, d as scanTestTags, f as findRulebookRoot, g as expandGlobs, l as writeJson, o as findRule, p as loadCatalog, r as lintCommand, s as gitFallbackWarning, u as writeLines, v as toRepoPath } from "./lint-D63Q2SM0.mjs";
+import { t as rulesForPath } from "./anchors-e6T9BNoV.mjs";
+import { mkdir, readdir, rm, writeFile } from "node:fs/promises";
 import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
 import { parseArgs } from "node:util";
 import { StdioServerTransport } from "@modelcontextprotocol/server/stdio";
@@ -80,7 +80,7 @@ function render(path, rules, text) {
 	return parts.join("\n\n");
 }
 // package.json
-var version = "0.5.1";
+var version = "0.6.0";
 // src/mcp/server.ts
 function createRulesServer(projectDir) {
 	const server = new McpServer({
@@ -136,24 +136,71 @@ async function mcpCommand(io, project) {
 }
 // src/commands/new.ts
 const MAX_NUMBER = 999;
-async function newCommand(catalog, io, name) {
+const CONTEXT_NAME = /^[a-z0-9][a-z0-9_-]*$/;
+const PREFIX = /^[A-Z][A-Z0-9]*$/;
+async function newCommand(catalog, io, name, prefix) {
+	const text = messages(catalog.config.language);
 	const context = catalog.contexts.find((item) => item.context === name);
-	if (context === void 0) throw new CliError(`Unknown context "${name}". Run "rulebookguard contexts" to list them.`);
+	if (context !== void 0) {
+		if (prefix !== void 0 && prefix !== context.prefix) throw new CliError(text.prefixMismatch(name, context.prefix, prefix));
+		writeLines(io, [await writeNextRule(catalog, context, text)]);
+		return;
+	}
+	const created = await createContext(catalog, name, prefix, text);
+	try {
+		writeLines(io, [created.file, await writeNextRule(catalog, created, text)]);
+	} catch (error) {
+		await rm(join(catalog.root, created.file), { force: true });
+		throw error;
+	}
+}
+async function createContext(catalog, name, option, text) {
+	if (!CONTEXT_NAME.test(name)) throw new CliError(text.invalidContextName(name));
+	const prefix = option ?? name.replace(/[^a-z0-9]/g, "").slice(0, 3).toUpperCase();
+	if (!PREFIX.test(prefix)) throw new CliError(text.invalidPrefix(prefix));
+	const owner = catalog.contexts.find((item) => item.prefix === prefix);
+	if (owner !== void 0) throw new CliError(text.prefixTaken(prefix, owner.context));
+	const directory = `${toRepoPath(catalog.config.rulesDir).replace(/\/+$/, "")}/${name}`;
+	const file = `${directory}/${CONTEXT_FILE_NAME}`;
+	await mkdir(join(catalog.root, directory), { recursive: true });
+	await writeNew(catalog, file, contextTemplate(name, prefix, text), text);
+	return {
+		file,
+		context: name,
+		prefix,
+		summary: "",
+		body: ""
+	};
+}
+async function writeNextRule(catalog, context, text) {
 	const directory = context.file.slice(0, context.file.lastIndexOf("/"));
 	const idPattern = new RegExp(`^R-${context.prefix}-([0-9]{3})$`);
 	const fileNames = (await readdir(join(catalog.root, directory))).filter((file) => file.endsWith(".md")).map((file) => file.slice(0, -3));
 	const taken = [...catalog.rules.map((rule) => rule.id), ...fileNames].map((id) => idPattern.exec(id)?.[1]).filter((digits) => digits !== void 0).map(Number);
 	const last = Math.max(0, ...taken);
-	if (last >= MAX_NUMBER) throw new CliError(`No free rule id left in context "${name}" (R-${context.prefix}-${MAX_NUMBER} is taken).`);
+	if (last >= MAX_NUMBER) throw new CliError(text.noFreeId(context.context, `R-${context.prefix}-${MAX_NUMBER}`));
 	const id = `R-${context.prefix}-${String(last + 1).padStart(3, "0")}`;
 	const file = `${directory}/${id}.md`;
+	await writeNew(catalog, file, ruleTemplate(id, context.context, catalog.config.language ?? "en"), text);
+	return file;
+}
+async function writeNew(catalog, file, content, text) {
 	try {
-		await writeFile(join(catalog.root, file), template(id, context.context, catalog.config.language ?? "en"), { flag: "wx" });
+		await writeFile(join(catalog.root, file), content, { flag: "wx" });
 	} catch (error) {
-		if (error.code === "EEXIST") throw new CliError(`${file} already exists; nothing was written.`);
+		if (error.code === "EEXIST") throw new CliError(text.alreadyExists(file));
 		throw error;
 	}
-	writeLines(io, [file]);
+}
+function contextTemplate(name, prefix, text) {
+	return `---
+context: ${name}
+prefix: ${prefix}
+summary: '${text.contextTemplateSummary}'
+---
+
+${text.contextTemplateBody}
+`;
 }
 const TEMPLATE_TEXT = {
 	en: {
@@ -176,7 +223,7 @@ Escenario: TODO
   Entonces TODO`
 	}
 };
-function template(id, context, language) {
+function ruleTemplate(id, context, language) {
 	const text = TEMPLATE_TEXT[language];
 	return `---
 id: ${id}
@@ -214,17 +261,26 @@ function contextsCommand(catalog, io, json) {
 		writeJson(io, { contexts });
 		return;
 	}
-	writeLines(io, contexts.map((item) => `${item.context} (${item.prefix}, ${item.rules} ${item.rules === 1 ? "rule" : "rules"}): ${item.summary}`));
+	if (contexts.length === 0) {
+		writeLines(io, [messages(catalog.config.language).noContexts]);
+		return;
+	}
+	writeLines(io, contexts.map((item) => `${item.context} (${item.prefix}, ${messages(catalog.config.language).ruleCount(item.rules)}): ${item.summary}`));
 }
 function listCommand(catalog, io, options) {
 	const { context, status } = options;
-	if (status !== void 0 && !RULE_STATUSES.includes(status)) throw new CliError(`Invalid status "${status}": expected one of ${RULE_STATUSES.join(", ")}.`, 2);
-	if (context !== void 0 && !catalog.contexts.some((item) => item.context === context)) throw new CliError(`Unknown context "${context}". Run "rulebookguard contexts" to list them.`);
+	const text = messages(catalog.config.language);
+	if (status !== void 0 && !RULE_STATUSES.includes(status)) throw new CliError(text.invalidStatus(status, RULE_STATUSES.join(", ")), 2);
+	if (context !== void 0 && !catalog.contexts.some((item) => item.context === context)) throw new CliError(text.unknownContext(context));
 	const rules = sortById(catalog.rules).filter((rule) => context === void 0 || rule.context === context).filter((rule) => status === void 0 || rule.status === status).map(toSummary);
 	if (options.json) {
 		writeJson(io, { rules });
 		return;
 	}
+	if (rules.length === 0) {
+		writeLines(io, [text.noRules]);
+		return;
+	}
 	writeLines(io, rules.map((rule) => `${rule.id} [${rule.status}] ${rule.summary}`));
 }
 function showCommand(catalog, io, id, json) {
@@ -240,19 +296,22 @@ function showCommand(catalog, io, id, json) {
 		} });
 		return;
 	}
+	const none = messages(catalog.config.language).none;
 	const header = [
 		`${rule.id}: ${rule.summary}`,
 		`context: ${rule.context}`,
 		`status: ${rule.status}`,
-		`entities: ${rule.entities.join(", ")}`,
-		`anchors: ${rule.anchors.join(", ")}`,
+		`entities: ${rule.entities.length === 0 ? none : rule.entities.join(", ")}`,
+		"anchors:",
+		...indent(rule.anchors, none),
 		...rule.supersedes === void 0 ? [] : [`supersedes: ${rule.supersedes}`],
 		`file: ${rule.file}`
 	];
 	io.stdout(`${header.join("\n")}\n\n${rule.body}`);
 }
 function forCommand(catalog, io, input, json) {
-	const path = toRootPath(catalog.root, resolve(io.cwd, input), input);
+	const text = messages(catalog.config.language);
+	const path = toRootPath(catalog, resolve(io.cwd, input), input);
 	const rules = rulesForPath(catalog.rules, path).filter((rule) => rule.status === "active").map((rule) => ({
 		...toSummary(rule),
 		file: rule.file
@@ -265,14 +324,15 @@ function forCommand(catalog, io, input, json) {
 		return;
 	}
 	if (rules.length === 0) {
-		writeLines(io, [`No active rules anchored to ${path}.`]);
+		writeLines(io, [text.noActiveRulesFor(path)]);
 		return;
 	}
 	writeLines(io, rules.map((rule) => `${rule.id} (${rule.context}): ${rule.summary}`));
 }
 async function impactCommand(catalog, io, id, json) {
 	const rule = findRule(catalog, id);
-	const warn = gitFallbackWarning(io);
+	const text = messages(catalog.config.language);
+	const warn = gitFallbackWarning(io, catalog.config.language);
 	const files = await expandGlobs(catalog.root, rule.anchors, warn);
 	const tests = (await scanTestTags(catalog.root, catalog.config.testGlobs, warn)).get(id) ?? [];
 	if (json) {
@@ -285,15 +345,15 @@ async function impactCommand(catalog, io, id, json) {
 	}
 	writeLines(io, [
 		`${rule.id}: ${rule.summary}`,
-		`Files matched by anchors (${files.length}):`,
-		...indent(files),
-		`Tests tagging ${rule.id} (${tests.length}):`,
-		...indent(tests.map((test) => `${test.file}:${test.line}`))
+		text.filesMatched(files.length),
+		...indent(files, text.none),
+		text.testsTagging(rule.id, tests.length),
+		...indent(tests.map((test) => `${test.file}:${test.line}`), text.none)
 	]);
 }
-function toRootPath(root, absolute, input) {
-	const path = toRepoPath(relative(root, absolute));
-	if (path === "" || path === ".." || path.startsWith("../") || isAbsolute(path)) throw new CliError(`Path "${input}" is outside the rulebook root ${root}.`);
+function toRootPath(catalog, absolute, input) {
+	const path = toRepoPath(relative(catalog.root, absolute));
+	if (path === "" || path === ".." || path.startsWith("../") || isAbsolute(path)) throw new CliError(messages(catalog.config.language).outsideRoot(input, catalog.root));
 	return path;
 }
 function toSummary(rule) {
@@ -304,8 +364,8 @@ function toSummary(rule) {
 		summary: rule.summary
 	};
 }
-function indent(lines) {
-	return lines.length === 0 ? ["  (none)"] : lines.map((line) => `  ${line}`);
+function indent(lines, none) {
+	return lines.length === 0 ? [`  ${none}`] : lines.map((line) => `  ${line}`);
 }
 function sortById(rules) {
 	return [...rules].sort((a, b) => compare(a.id, b.id));
@@ -322,11 +382,14 @@ Commands:
   show <id> [--json]                                 L2: the full rule
   for <path> [--json]                                active rules anchored to a path
   impact <id> [--json]                               files matched by a rule's anchors and tests tagging it
-  new <context>                                      scaffold the next free rule id as a proposed rule
+  new <context> [--prefix <P>]                       scaffold the next free rule id as a proposed rule;
+                                                     creates the context first when it does not exist,
+                                                     --prefix: its id prefix (default: first 3 letters)
   lint [--base <ref>] [--json]                       check the catalog, anchors and test tags;
                                                      --base: rules changed since <ref> need a changed test
-  hook                                               Claude Code PreToolUse hook: reads the event on stdin
-                                                     and prints the rules anchored to the edited file
+  hook                                               Claude Code hook for PreToolUse and PostToolUse: reads
+                                                     the event on stdin and prints the rules anchored to
+                                                     the file of the tool (Read, Edit, Write...)
   mcp [--project <dir>]                              MCP server over stdio with rules_for and rules_show;
                                                      --project: directory to find the rulebook from (default: cwd)
   site:generate [--out <dir>] [--base <path>]        build the read-only static site of the rulebook (alias: site);
@@ -372,9 +435,9 @@ const COMMANDS = {
 		options: JSON_OPTION
 	},
 	new: {
-		usage: "rulebookguard new <context>",
+		usage: "rulebookguard new <context> [--prefix <P>]",
 		argument: "context",
-		options: {}
+		options: { prefix: { type: "string" } }
 	},
 	hook: {
 		usage: "rulebookguard hook",
@@ -416,7 +479,7 @@ async function runCli(argv, io) {
 			return error.exitCode;
 		}
 		if (error instanceof FormatError) {
-			io.stderr(`${error.issues.map(formatIssue).join("\n")}\n`);
+			io.stderr(`${error.issues.map((issue) => formatIssue(issue)).join("\n")}\n`);
 			return 1;
 		}
 		throw error;
@@ -441,7 +504,7 @@ async function dispatch(argv, io) {
 		return 0;
 	}
 	if (name === "site" || name === "site:generate" || name === "site:run") {
-		const { siteCommand } = await import("./site-BiiOPVEe.mjs");
+		const { siteCommand } = await import("./site-DEdtLk6J.mjs");
 		await siteCommand(io, {
 			out: values.out,
 			base: values.base,
@@ -475,7 +538,7 @@ async function dispatch(argv, io) {
 		case "impact":
 			await impactCommand(catalog, io, argument, json);
 			break;
-		case "new": await newCommand(catalog, io, argument);
+		case "new": await newCommand(catalog, io, argument, values.prefix);
 	}
 	return 0;
 }

package/dist/index.d.mts

@@ -1,5 +1,9 @@
 type RuleStatus = "proposed" | "active" | "deprecated";
 type RuleLanguage = "en" | "es";
+interface ParseOptions {
+  /** Language of the issue messages; `en` when unset. */
+  language?: RuleLanguage | undefined;
+}
 interface RulebookConfig {
   schema: 1;
   rulesDir: string;
@@ -34,8 +38,8 @@ export declare const CONFIG_FILE_NAME = "rulebookguard.config.yaml";
 export declare function parseConfig(source: string, file: string): RulebookConfig;
 export declare function loadConfig(path: string): Promise<RulebookConfig>;
 export declare const CONTEXT_FILE_NAME = "_context.md";
-export declare function parseContext(source: string, file: string): ContextDoc;
-export declare function loadContext(path: string): Promise<ContextDoc>;
+export declare function parseContext(source: string, file: string, { language }?: ParseOptions): ContextDoc;
+export declare function loadContext(path: string, options?: ParseOptions): Promise<ContextDoc>;
 interface FormatIssue {
   file: string;
   field?: string;
@@ -50,10 +54,10 @@ interface Frontmatter {
   data: unknown;
   body: string;
 }
-export declare function splitFrontmatter(source: string, file: string): Frontmatter;
+export declare function splitFrontmatter(source: string, file: string, { language }?: ParseOptions): Frontmatter;
 export declare function isRuleId(value: string): boolean;
-export declare function parseRule(source: string, file: string): RuleDoc;
-export declare function loadRule(path: string): Promise<RuleDoc>;
+export declare function parseRule(source: string, file: string, { language }?: ParseOptions): RuleDoc;
+export declare function loadRule(path: string, options?: ParseOptions): Promise<RuleDoc>;
 interface RuleTag {
   id: string;
   line: number;
@@ -136,6 +140,8 @@ interface LintFinding {
   file: string;
   line?: number;
   message: string;
+  /** One line on how to fix the finding. */
+  hint: string;
 }
 interface LintJson {
   findings: LintFinding[];
@@ -149,4 +155,4 @@ interface LintOptions {
 export declare function lintCatalog(catalog: Catalog, tags?: TagIndex, onGitFallback?: GitFallbackListener): Promise<LintFinding[]>;
 export declare function pendingImplementation(catalog: Catalog, tags: TagIndex, base: string, changed: string[]): LintFinding[];
 export declare function formatFinding(finding: LintFinding): string;
-export type { Catalog, CatalogIssue, CatalogIssueCode, ContextDoc, ContextFrontmatter, ContextsJson, ForJson, FormatIssue, Frontmatter, GitFallbackListener, ImpactJson, LintFinding, LintJson, LintOptions, LintSeverity, ListJson, RuleDoc, RuleFrontmatter, RuleLanguage, RuleStatus, RuleSummaryJson, RuleTag, RulebookConfig, ShowJson, TagIndex, TagLocation };
+export type { Catalog, CatalogIssue, CatalogIssueCode, ContextDoc, ContextFrontmatter, ContextsJson, ForJson, FormatIssue, Frontmatter, GitFallbackListener, ImpactJson, LintFinding, LintJson, LintOptions, LintSeverity, ListJson, ParseOptions, RuleDoc, RuleFrontmatter, RuleLanguage, RuleStatus, RuleSummaryJson, RuleTag, RulebookConfig, ShowJson, TagIndex, TagLocation };

package/dist/index.mjs

@@ -1,3 +1,3 @@
-import { A as loadConfig, C as loadRule, D as parseContext, E as loadContext, M as FormatError, N as formatIssue, O as splitFrontmatter, S as isRuleId, T as CONTEXT_FILE_NAME, _ as listRepoFiles, b as RULE_TAG_PATTERN, d as scanTestTags, f as findRulebookRoot, g as expandGlobs, h as createGlobMatcher, i as pendingImplementation, j as parseConfig, k as CONFIG_FILE_NAME, m as relativeToRoot, n as lintCatalog, p as loadCatalog, t as formatFinding, v as toRepoPath, w as parseRule, x as findRuleTags } from "./lint-C1yUeLOq.mjs";
-import { t as rulesForPath } from "./anchors-BFJCm1NU.mjs";
+import { A as loadConfig, C as loadRule, D as parseContext, E as loadContext, N as FormatError, O as splitFrontmatter, P as formatIssue, S as isRuleId, T as CONTEXT_FILE_NAME, _ as listRepoFiles, b as RULE_TAG_PATTERN, d as scanTestTags, f as findRulebookRoot, g as expandGlobs, h as createGlobMatcher, i as pendingImplementation, j as parseConfig, k as CONFIG_FILE_NAME, m as relativeToRoot, n as lintCatalog, p as loadCatalog, t as formatFinding, v as toRepoPath, w as parseRule, x as findRuleTags } from "./lint-D63Q2SM0.mjs";
+import { t as rulesForPath } from "./anchors-e6T9BNoV.mjs";
 export { CONFIG_FILE_NAME, CONTEXT_FILE_NAME, FormatError, RULE_TAG_PATTERN, createGlobMatcher, expandGlobs, findRuleTags, findRulebookRoot, formatFinding, formatIssue, isRuleId, lintCatalog, listRepoFiles, loadCatalog, loadConfig, loadContext, loadRule, parseConfig, parseContext, parseRule, pendingImplementation, relativeToRoot, rulesForPath, scanTestTags, splitFrontmatter, toRepoPath };

package/dist/{lint-C1yUeLOq.mjs → lint-D63Q2SM0.mjs}

@@ -138,6 +138,152 @@ var rule_schema_default = {
 	],
 	additionalProperties: false
 };
+// src/messages.ts
+const MESSAGES = {
+	en: {
+		field: (name) => `field "${name}"`,
+		missingFrontmatter: "missing YAML frontmatter delimited by \"---\" lines",
+		unclosedFrontmatter: "frontmatter is not closed by a \"---\" line",
+		invalidYaml: (detail) => `invalid YAML: ${detail}`,
+		required: "is required",
+		notAllowed: "is not allowed",
+		oneOf: (values) => `must be one of: ${values}`,
+		equalTo: (value) => `must be equal to ${value}`,
+		singleLine: "must be a single line",
+		ofType: () => void 0,
+		minLength: () => void 0,
+		minimum: () => void 0,
+		pattern: () => void 0,
+		missingRulesDir: "directory does not exist",
+		missingContextFile: "has no _context.md",
+		contextMismatch: (name) => `must match its directory name "${name}"`,
+		fileNameMismatch: (baseName) => `must match the file name "${baseName}"`,
+		idPrefixMismatch: (prefix) => `must use the context prefix "${prefix}"`,
+		duplicateId: (first) => `duplicates the id of ${first}`,
+		catalogWarning: (count) => `warning: the catalog has ${count} format ${count === 1 ? "issue" : "issues"}; run "rulebookguard lint" to see them and to check anchors and test tags.`,
+		unknownRule: (id) => `Unknown rule id "${id}". Run "rulebookguard list" to list them.`,
+		unknownContext: (name) => `Unknown context "${name}". Run "rulebookguard contexts" to list them.`,
+		invalidStatus: (status, allowed) => `Invalid status "${status}": expected one of ${allowed}.`,
+		outsideRoot: (input, root) => `Path "${input}" is outside the rulebook root ${root}.`,
+		gitFallback: (reason) => `warning: git could not list files (${reason}); walking the directory instead.`,
+		submoduleSkipped: (submodule, reason) => `warning: could not list files of submodule "${submodule}" (${reason}); skipping it.`,
+		ruleCount: (count) => `${count} ${count === 1 ? "rule" : "rules"}`,
+		noContexts: "No contexts found. Create one with \"rulebookguard new <context>\".",
+		noRules: "No rules found.",
+		noActiveRulesFor: (path) => `No active rules anchored to ${path}.`,
+		filesMatched: (count) => `Files matched by anchors (${count}):`,
+		testsTagging: (id, count) => `Tests tagging ${id} (${count}):`,
+		none: "(none)",
+		noFreeId: (context, lastId) => `No free rule id left in context "${context}" (${lastId} is taken).`,
+		alreadyExists: (file) => `${file} already exists; nothing was written.`,
+		invalidContextName: (name) => `Invalid context name "${name}": use lowercase letters, digits, "-" or "_", starting with a letter or digit.`,
+		invalidPrefix: (prefix) => `Invalid prefix "${prefix}": use uppercase letters and digits, starting with a letter. Pass one with --prefix.`,
+		prefixTaken: (prefix, context) => `Prefix "${prefix}" is already used by context "${context}". Pass another one with --prefix.`,
+		prefixMismatch: (context, prefix, given) => `Context "${context}" already exists with prefix "${prefix}", not "${given}".`,
+		contextTemplateSummary: "TODO: one-line summary of the context.",
+		contextTemplateBody: "TODO: describe what this context covers and what it leaves out.",
+		untestedRule: (id) => `active rule ${id} has no test tagging it`,
+		unmatchedAnchor: (anchor) => `anchor "${anchor}" matches no file`,
+		unknownRuleTag: (id) => `tags ${id}, which does not exist`,
+		deprecatedRuleTag: (id) => `tags ${id}, which is deprecated`,
+		contextOverBudget: (context, count, budget) => `context "${context}" has ${count} rules, more than the contextBudget of ${budget}`,
+		pendingImplementation: (id, base) => `rule ${id} changed since ${base} but none of the tests tagging it changed`,
+		noIssues: "No issues found.",
+		hintLabel: "hint",
+		catalogHints: {
+			schema: "fix the file as the message says; the JSON Schemas ship under rulebookguard/schemas/v1/",
+			"missing-rules-dir": "create the directory, or set rulesDir in rulebookguard.config.yaml",
+			"missing-context-file": "add a _context.md with context, prefix and summary",
+			"context-mismatch": "make the context field equal to the directory name, or move the file to the matching directory",
+			"file-name-mismatch": "rename the file after the id, or change the id",
+			"id-prefix-mismatch": "change the id to use the context prefix, or move the rule to the context that owns its prefix",
+			"duplicate-id": "give one of the rules another id; \"rulebookguard new <context>\" picks the next free one"
+		},
+		untestedRuleHint: (id) => `add "@rule ${id}" to a test in a file matched by testGlobs, or set the rule's status to proposed`,
+		unmatchedAnchorHint: "fix the glob so it matches the files that implement the rule, or remove it",
+		unknownRuleTagHint: "fix the id in the tag, or create the rule it refers to",
+		deprecatedRuleTagHint: (id, successor) => successor === void 0 ? `tag the rule that replaces ${id}, or remove the tag` : `tag ${successor}, which supersedes ${id}, instead`,
+		contextOverBudgetHint: "split the context into smaller ones, or raise contextBudget in rulebookguard.config.yaml",
+		pendingImplementationHint: (id) => `update or add a test tagging ${id} that covers the changed rule`,
+		lintSummary: (errors, warnings) => `${errors} ${errors === 1 ? "error" : "errors"}, ${warnings} ${warnings === 1 ? "warning" : "warnings"}`,
+		needsWorkTree: (root) => `lint --base needs a git work tree, but ${root} is not inside one.`,
+		unknownRef: (ref) => `Unknown git ref "${ref}".`,
+		cannotListChanged: (ref, reason) => `Cannot list the files changed since "${ref}": ${reason}`
+	},
+	es: {
+		field: (name) => `el campo "${name}"`,
+		missingFrontmatter: "falta el frontmatter YAML delimitado por líneas \"---\"",
+		unclosedFrontmatter: "el frontmatter no se cierra con una línea \"---\"",
+		invalidYaml: (detail) => `YAML inválido: ${detail}`,
+		required: "es obligatorio",
+		notAllowed: "no está permitido",
+		oneOf: (values) => `debe ser uno de: ${values}`,
+		equalTo: (value) => `debe ser igual a ${value}`,
+		singleLine: "debe ocupar una sola línea",
+		ofType: (type) => `debe ser de tipo ${type}`,
+		minLength: (limit) => limit === 1 ? "no puede estar vacío" : `debe tener al menos ${limit} caracteres`,
+		minimum: (limit) => `debe ser mayor o igual que ${limit}`,
+		pattern: (pattern) => `debe cumplir el patrón "${pattern}"`,
+		missingRulesDir: "el directorio no existe",
+		missingContextFile: "no tiene _context.md",
+		contextMismatch: (name) => `debe coincidir con el nombre de su directorio "${name}"`,
+		fileNameMismatch: (baseName) => `debe coincidir con el nombre del archivo "${baseName}"`,
+		idPrefixMismatch: (prefix) => `debe usar el prefijo del contexto "${prefix}"`,
+		duplicateId: (first) => `repite el id de ${first}`,
+		catalogWarning: (count) => `aviso: el catálogo tiene ${count} ${count === 1 ? "problema" : "problemas"} de formato; ejecuta "rulebookguard lint" para verlos y para revisar anchors y etiquetas de test.`,
+		unknownRule: (id) => `No existe la regla "${id}". Ejecuta "rulebookguard list" para ver las reglas.`,
+		unknownContext: (name) => `No existe el contexto "${name}". Ejecuta "rulebookguard contexts" para ver los contextos.`,
+		invalidStatus: (status, allowed) => `Estado "${status}" inválido: debe ser uno de ${allowed}.`,
+		outsideRoot: (input, root) => `La ruta "${input}" está fuera de la raíz del rulebook ${root}.`,
+		gitFallback: (reason) => `aviso: git no pudo listar los archivos (${reason}); se recorre el directorio en su lugar.`,
+		submoduleSkipped: (submodule, reason) => `aviso: no se pudieron listar los archivos del submódulo "${submodule}" (${reason}); se omite.`,
+		ruleCount: (count) => `${count} ${count === 1 ? "regla" : "reglas"}`,
+		noContexts: "No se encontraron contextos. Crea uno con \"rulebookguard new <contexto>\".",
+		noRules: "No se encontraron reglas.",
+		noActiveRulesFor: (path) => `No hay reglas activas ancladas a ${path}.`,
+		filesMatched: (count) => `Archivos que cubren los anchors (${count}):`,
+		testsTagging: (id, count) => `Tests que etiquetan ${id} (${count}):`,
+		none: "(ninguno)",
+		noFreeId: (context, lastId) => `No quedan ids libres en el contexto "${context}" (${lastId} ya existe).`,
+		alreadyExists: (file) => `${file} ya existe; no se escribió nada.`,
+		invalidContextName: (name) => `Nombre de contexto "${name}" inválido: usa minúsculas, dígitos, "-" o "_", empezando por una letra o un dígito.`,
+		invalidPrefix: (prefix) => `Prefijo "${prefix}" inválido: usa mayúsculas y dígitos, empezando por una letra. Indica uno con --prefix.`,
+		prefixTaken: (prefix, context) => `El prefijo "${prefix}" ya lo usa el contexto "${context}". Indica otro con --prefix.`,
+		prefixMismatch: (context, prefix, given) => `El contexto "${context}" ya existe con el prefijo "${prefix}", no "${given}".`,
+		contextTemplateSummary: "TODO: resumen del contexto en una línea.",
+		contextTemplateBody: "TODO: describe qué cubre este contexto y qué queda fuera.",
+		untestedRule: (id) => `la regla activa ${id} no tiene ningún test que la etiquete`,
+		unmatchedAnchor: (anchor) => `el anchor "${anchor}" no coincide con ningún archivo`,
+		unknownRuleTag: (id) => `etiqueta ${id}, que no existe`,
+		deprecatedRuleTag: (id) => `etiqueta ${id}, que está deprecada`,
+		contextOverBudget: (context, count, budget) => `el contexto "${context}" tiene ${count} reglas, más que el contextBudget de ${budget}`,
+		pendingImplementation: (id, base) => `la regla ${id} cambió desde ${base} pero no cambió ninguno de los tests que la etiquetan`,
+		noIssues: "No se encontraron problemas.",
+		hintLabel: "sugerencia",
+		catalogHints: {
+			schema: "corrige el archivo según el mensaje; los JSON Schemas vienen en rulebookguard/schemas/v1/",
+			"missing-rules-dir": "crea el directorio o cambia rulesDir en rulebookguard.config.yaml",
+			"missing-context-file": "agrega un _context.md con context, prefix y summary",
+			"context-mismatch": "iguala el campo context al nombre del directorio o mueve el archivo al directorio que corresponde",
+			"file-name-mismatch": "renombra el archivo según el id o cambia el id",
+			"id-prefix-mismatch": "cambia el id para usar el prefijo del contexto o mueve la regla al contexto dueño de ese prefijo",
+			"duplicate-id": "dale otro id a una de las reglas; \"rulebookguard new <contexto>\" elige el siguiente libre"
+		},
+		untestedRuleHint: (id) => `agrega "@rule ${id}" a un test en un archivo que coincida con testGlobs, o cambia el estado de la regla a proposed`,
+		unmatchedAnchorHint: "corrige el glob para que coincida con los archivos que implementan la regla, o quítalo",
+		unknownRuleTagHint: "corrige el id de la etiqueta o crea la regla a la que se refiere",
+		deprecatedRuleTagHint: (id, successor) => successor === void 0 ? `etiqueta la regla que reemplaza a ${id} o quita la etiqueta` : `etiqueta ${successor}, que reemplaza a ${id}`,
+		contextOverBudgetHint: "divide el contexto en otros más chicos o sube contextBudget en rulebookguard.config.yaml",
+		pendingImplementationHint: (id) => `actualiza o agrega un test que etiquete ${id} y cubra el cambio de la regla`,
+		lintSummary: (errors, warnings) => `${errors} ${errors === 1 ? "error" : "errores"}, ${warnings} ${warnings === 1 ? "aviso" : "avisos"}`,
+		needsWorkTree: (root) => `lint --base necesita un work tree de git, pero ${root} no está en uno.`,
+		unknownRef: (ref) => `La referencia de git "${ref}" no existe.`,
+		cannotListChanged: (ref, reason) => `No se pudieron listar los archivos cambiados desde "${ref}": ${reason}`
+	}
+};
+function messages(language) {
+	return MESSAGES[language ?? "en"];
+}
 // src/format/validate.ts
 const ajv = new Ajv2020({
 	allErrors: true,
@@ -148,30 +294,35 @@ const validators = {
 	context: ajv.compile(context_schema_default),
 	rule: ajv.compile(rule_schema_default)
 };
-function validate(validator, data, file) {
+function validate(validator, data, file, { language } = {}) {
 	if (validator(data)) return data;
-	throw new FormatError((validator.errors ?? []).map((error) => toIssue(error, file)));
+	const text = messages(language);
+	throw new FormatError((validator.errors ?? []).map((error) => toIssue(error, file, text)));
 }
-function toIssue(error, file) {
+function toIssue(error, file, text) {
 	const base = toFieldPath(error.instancePath);
 	const params = error.params;
+	const fallback = error.message ?? "is invalid";
 	switch (error.keyword) {
 		case "required": return {
 			file,
 			field: join$1(base, String(params.missingProperty)),
-			message: "is required"
+			message: text.required
 		};
 		case "additionalProperties": return {
 			file,
 			field: join$1(base, String(params.additionalProperty)),
-			message: "is not allowed"
+			message: text.notAllowed
 		};
-		case "enum": return withField(file, base, `must be one of: ${params.allowedValues.join(", ")}`);
-		case "const": return withField(file, base, `must be equal to ${JSON.stringify(params.allowedValue)}`);
+		case "enum": return withField(file, base, text.oneOf(params.allowedValues.join(", ")));
+		case "const": return withField(file, base, text.equalTo(JSON.stringify(params.allowedValue)));
 		case "pattern":
-			if (params.pattern === "^[^\\r\\n]*$") return withField(file, base, "must be a single line");
-			return withField(file, base, error.message ?? "is invalid");
-		default: return withField(file, base, error.message ?? "is invalid");
+			if (params.pattern === "^[^\\r\\n]*$") return withField(file, base, text.singleLine);
+			return withField(file, base, text.pattern(String(params.pattern)) ?? fallback);
+		case "type": return withField(file, base, text.ofType(String(params.type)) ?? fallback);
+		case "minLength": return withField(file, base, text.minLength(Number(params.limit)) ?? fallback);
+		case "minimum": return withField(file, base, text.minimum(Number(params.limit)) ?? fallback);
+		default: return withField(file, base, fallback);
 	}
 }
 function withField(file, field, message) {
@@ -191,13 +342,13 @@ function toFieldPath(instancePath) {
 	return instancePath.split("/").slice(1).map((segment) => segment.replaceAll("~1", "/").replaceAll("~0", "~")).reduce((path, segment) => /^\d+$/.test(segment) ? `${path}[${segment}]` : join$1(path, segment), "");
 }
 // src/format/yaml.ts
-function parseYaml(source, file) {
+function parseYaml(source, file, { language } = {}) {
 	try {
 		return parse(source);
 	} catch (error) {
 		if (error instanceof YAMLParseError) throw new FormatError([{
 			file,
-			message: `invalid YAML: ${singleLine(error)}`
+			message: messages(language).invalidYaml(singleLine(error))
 		}]);
 		throw error;
 	}
@@ -219,53 +370,54 @@ async function loadConfig(path) {
 // src/format/frontmatter.ts
 const OPENING = /^---\r?\n/;
 const CLOSING = /^---[ \t]*(?:\r?\n|$)/m;
-function splitFrontmatter(source, file) {
+function splitFrontmatter(source, file, { language } = {}) {
+	const text = messages(language);
 	const opening = OPENING.exec(source);
 	if (opening === null) throw new FormatError([{
 		file,
-		message: "missing YAML frontmatter delimited by \"---\" lines"
+		message: text.missingFrontmatter
 	}]);
 	const rest = source.slice(opening[0].length);
 	const closing = CLOSING.exec(rest);
 	if (closing === null) throw new FormatError([{
 		file,
-		message: "frontmatter is not closed by a \"---\" line"
+		message: text.unclosedFrontmatter
 	}]);
 	const yaml = rest.slice(0, closing.index);
 	const body = rest.slice(closing.index + closing[0].length).replace(/^(?:\r?\n)+/, "");
 	return {
-		data: parseYaml(yaml, file),
+		data: parseYaml(yaml, file, { language }),
 		body
 	};
 }
 // src/format/context.ts
 const CONTEXT_FILE_NAME = "_context.md";
-function parseContext(source, file) {
-	const { data, body } = splitFrontmatter(source, file);
+function parseContext(source, file, { language } = {}) {
+	const { data, body } = splitFrontmatter(source, file, { language });
 	return {
 		file,
-		...validate(validators.context, data, file),
+		...validate(validators.context, data, file, { language }),
 		body
 	};
 }
-async function loadContext(path) {
-	return parseContext(await readSource(path), path);
+async function loadContext(path, options) {
+	return parseContext(await readSource(path), path, options);
 }
 // src/format/rule.ts
 const RULE_ID = /^R-[A-Z][A-Z0-9]*-[0-9]{3}$/;
 function isRuleId(value) {
 	return RULE_ID.test(value);
 }
-function parseRule(source, file) {
-	const { data, body } = splitFrontmatter(source, file);
+function parseRule(source, file, { language } = {}) {
+	const { data, body } = splitFrontmatter(source, file, { language });
 	return {
 		file,
-		...validate(validators.rule, data, file),
+		...validate(validators.rule, data, file, { language }),
 		body
 	};
 }
-async function loadRule(path) {
-	return parseRule(await readSource(path), path);
+async function loadRule(path, options) {
+	return parseRule(await readSource(path), path, options);
 }
 // src/format/tag.ts
 const RULE_TAG_PATTERN = /(?<![\w@.-])@rule\s+(R-[A-Z][A-Z0-9]*-[0-9]{3})(?![\w-])/g;
@@ -478,12 +630,12 @@ async function loadCatalog(root) {
 		catalog.issues.push({
 			code: "missing-rules-dir",
 			file: rulesDir,
-			message: "directory does not exist"
+			message: messages(config.language).missingRulesDir
 		});
 		return catalog;
 	}
 	for (const entry of directories.filter((item) => item.isDirectory())) await loadContextDirectory(catalog, `${rulesDir}/${entry.name}`, entry.name);
-	catalog.issues.push(...findDuplicateIds(catalog.rules));
+	catalog.issues.push(...findDuplicateIds(catalog.rules, config.language));
 	return catalog;
 }
 async function loadContextDirectory(catalog, dir, name) {
@@ -498,7 +650,7 @@ async function loadContextDirectory(catalog, dir, name) {
 	} else catalog.issues.push({
 		code: "missing-context-file",
 		file: dir,
-		message: "has no _context.md"
+		message: messages(catalog.config.language).missingContextFile
 	});
 	for (const file of files.filter((item) => item !== CONTEXT_FILE_NAME)) {
 		const rule = await load(catalog, `${dir}/${file}`, loadRule);
@@ -513,7 +665,7 @@ async function loadContextDirectory(catalog, dir, name) {
 async function load(catalog, file, loader) {
 	try {
 		return {
-			...await loader(join(catalog.root, file)),
+			...await loader(join(catalog.root, file), { language: catalog.config.language }),
 			file
 		};
 	} catch (error) {
@@ -531,7 +683,7 @@ function checkContextName(catalog, doc, name) {
 		code: "context-mismatch",
 		file: doc.file,
 		field: "context",
-		message: `must match its directory name "${name}"`
+		message: messages(catalog.config.language).contextMismatch(name)
 	});
 }
 function checkRule(catalog, rule, directory, baseName, context) {
@@ -539,17 +691,17 @@ function checkRule(catalog, rule, directory, baseName, context) {
 		code: "file-name-mismatch",
 		file: rule.file,
 		field: "id",
-		message: `must match the file name "${baseName}"`
+		message: messages(catalog.config.language).fileNameMismatch(baseName)
 	});
 	if (context !== void 0 && !rule.id.startsWith(`R-${context.prefix}-`)) catalog.issues.push({
 		code: "id-prefix-mismatch",
 		file: rule.file,
 		field: "id",
-		message: `must use the context prefix "${context.prefix}"`
+		message: messages(catalog.config.language).idPrefixMismatch(context.prefix)
 	});
 	checkContextName(catalog, rule, directory);
 }
-function findDuplicateIds(rules) {
+function findDuplicateIds(rules, language) {
 	const firstFile = /* @__PURE__ */ new Map();
 	const issues = [];
 	for (const rule of rules) {
@@ -559,7 +711,7 @@ function findDuplicateIds(rules) {
 			code: "duplicate-id",
 			file: rule.file,
 			field: "id",
-			message: `duplicates the id of ${first}`
+			message: messages(language).duplicateId(first)
 		});
 	}
 	return issues;
@@ -618,12 +770,12 @@ async function requireRulebookRoot(io) {
 async function openCatalog(io) {
 	const catalog = await loadCatalog(await requireRulebookRoot(io));
 	const count = catalog.issues.length;
-	if (count > 0) io.stderr(`warning: the catalog has ${count} ${count === 1 ? "issue" : "issues"}; run "rulebookguard lint" for details.\n`);
+	if (count > 0) io.stderr(`${messages(catalog.config.language).catalogWarning(count)}\n`);
 	return catalog;
 }
 function findRule(catalog, id) {
 	const rule = catalog.rules.find((item) => item.id === id);
-	if (rule === void 0) throw new CliError(`Unknown rule id "${id}". Run "rulebookguard list" to list them.`);
+	if (rule === void 0) throw new CliError(messages(catalog.config.language).unknownRule(id));
 	return rule;
 }
 function writeJson(io, value) {
@@ -632,20 +784,21 @@ function writeJson(io, value) {
 function writeLines(io, lines) {
 	io.stdout(lines.map((line) => `${line}\n`).join(""));
 }
-function gitFallbackWarning(io) {
+function gitFallbackWarning(io, language) {
+	const text = messages(language);
 	let warned = false;
 	const skipped = /* @__PURE__ */ new Set();
 	return (reason, submodule) => {
 		if (submodule !== void 0) {
 			if (!skipped.has(submodule)) {
 				skipped.add(submodule);
-				io.stderr(`warning: could not list files of submodule "${submodule}" (${reason}); skipping it.\n`);
+				io.stderr(`${text.submoduleSkipped(submodule, reason)}\n`);
 			}
 			return;
 		}
 		if (!warned) {
 			warned = true;
-			io.stderr(`warning: git could not list files (${reason}); walking the directory instead.\n`);
+			io.stderr(`${text.gitFallback(reason)}\n`);
 		}
 	};
 }
@@ -660,16 +813,17 @@ async function lintCommand(io, options) {
 		return report(io, error.issues.map((issue) => issueFinding("schema", {
 			...issue,
 			file: relativeToRoot(root, issue.file)
-		})), options.json);
+		}, messages("en"))), options.json, messages("en"));
 	}
-	const changed = options.base === void 0 ? void 0 : await changedFiles(catalog.root, options.base);
-	const warn = gitFallbackWarning(io);
+	const text = messages(catalog.config.language);
+	const changed = options.base === void 0 ? void 0 : await changedFiles(catalog.root, options.base, text);
+	const warn = gitFallbackWarning(io, catalog.config.language);
 	const tags = await scanTestTags(catalog.root, catalog.config.testGlobs, warn);
 	const findings = await lintCatalog(catalog, tags, warn);
 	if (options.base !== void 0 && changed !== void 0) findings.push(...pendingImplementation(catalog, tags, options.base, changed));
-	return report(io, findings, options.json);
+	return report(io, findings, options.json, text);
 }
-function report(io, findings, json) {
+function report(io, findings, json, text) {
 	const sorted = sortFindings(findings);
 	const errors = sorted.filter((finding) => finding.severity === "error").length;
 	const warnings = sorted.length - errors;
@@ -678,31 +832,33 @@ function report(io, findings, json) {
 		errors,
 		warnings
 	});
-	else if (sorted.length === 0) writeLines(io, ["No issues found."]);
-	else writeLines(io, [...sorted.map(formatFinding), `${plural(errors, "error")}, ${plural(warnings, "warning")}`]);
+	else if (sorted.length === 0) writeLines(io, [text.noIssues]);
+	else writeLines(io, [...sorted.flatMap((finding) => [formatFinding(finding), `  ${text.hintLabel}: ${finding.hint}`]), text.lintSummary(errors, warnings)]);
 	return errors > 0 ? 1 : 0;
 }
-function issueFinding(code, { file, field, message }) {
-	return error(code, file, field === void 0 ? message : `field "${field}" ${message}`);
+function issueFinding(code, { file, field, message }, text) {
+	return error(code, file, field === void 0 ? message : `${text.field(field)} ${message}`, text.catalogHints[code]);
 }
 async function lintCatalog(catalog, tags, onGitFallback) {
 	const tagIndex = tags ?? await scanTestTags(catalog.root, catalog.config.testGlobs, onGitFallback);
-	const findings = catalog.issues.map((issue) => issueFinding(issue.code, issue));
+	const text = messages(catalog.config.language);
+	const findings = catalog.issues.map((issue) => issueFinding(issue.code, issue, text));
 	const files = await listRepoFiles(catalog.root, onGitFallback);
 	const status = new Map(catalog.rules.map((rule) => [rule.id, rule.status]));
 	const invalid = new Set(catalog.invalidRuleIds);
+	const successors = new Map(catalog.rules.filter((rule) => rule.supersedes !== void 0 && rule.status !== "deprecated").map((rule) => [rule.supersedes, rule.id]));
 	for (const rule of catalog.rules) {
-		if (rule.status === "active" && !tagIndex.has(rule.id)) findings.push(error("untested-rule", rule.file, `active rule ${rule.id} has no test tagging it`));
-		for (const anchor of rule.anchors) if (!files.some(createGlobMatcher([anchor]))) findings.push(error("unmatched-anchor", rule.file, `anchor "${anchor}" matches no file`));
+		if (rule.status === "active" && !tagIndex.has(rule.id)) findings.push(error("untested-rule", rule.file, text.untestedRule(rule.id), text.untestedRuleHint(rule.id)));
+		for (const anchor of rule.anchors) if (!files.some(createGlobMatcher([anchor]))) findings.push(error("unmatched-anchor", rule.file, text.unmatchedAnchor(anchor), text.unmatchedAnchorHint));
 	}
 	for (const [id, locations] of tagIndex) {
 		const ruleStatus = status.get(id);
 		if (ruleStatus !== void 0 && ruleStatus !== "deprecated" || invalid.has(id)) continue;
 		for (const { file, line } of locations) findings.push(ruleStatus === void 0 ? {
-			...error("unknown-rule-tag", file, `tags ${id}, which does not exist`),
+			...error("unknown-rule-tag", file, text.unknownRuleTag(id), text.unknownRuleTagHint),
 			line
 		} : {
-			...error("deprecated-rule-tag", file, `tags ${id}, which is deprecated`),
+			...error("deprecated-rule-tag", file, text.deprecatedRuleTag(id), text.deprecatedRuleTagHint(id, successors.get(id))),
 			line
 		});
 	}
@@ -713,43 +869,43 @@ async function lintCatalog(catalog, tags, onGitFallback) {
 			severity: "warning",
 			code: "context-over-budget",
 			file: context.file,
-			message: `context "${context.context}" has ${count} rules, more than the contextBudget of ${budget}`
+			message: text.contextOverBudget(context.context, count, budget),
+			hint: text.contextOverBudgetHint
 		});
 	}
 	return findings;
 }
 function pendingImplementation(catalog, tags, base, changed) {
+	const text = messages(catalog.config.language);
 	const changedSet = new Set(changed);
-	return catalog.rules.filter((rule) => rule.status === "active" && changedSet.has(rule.file)).filter((rule) => (tags.get(rule.id) ?? []).length > 0).filter((rule) => !(tags.get(rule.id) ?? []).some(({ file }) => changedSet.has(file))).map((rule) => error("pending-implementation", rule.file, `rule ${rule.id} changed since ${base} but none of the tests tagging it changed`));
+	return catalog.rules.filter((rule) => rule.status === "active" && changedSet.has(rule.file)).filter((rule) => (tags.get(rule.id) ?? []).length > 0).filter((rule) => !(tags.get(rule.id) ?? []).some(({ file }) => changedSet.has(file))).map((rule) => error("pending-implementation", rule.file, text.pendingImplementation(rule.id, base), text.pendingImplementationHint(rule.id)));
 }
-async function changedFiles(root, base) {
-	if (!await isInsideWorkTree(root)) throw new CliError(`lint --base needs a git work tree, but ${root} is not inside one.`);
-	if (!await isCommitRef(root, base)) throw new CliError(`Unknown git ref "${base}".`);
+async function changedFiles(root, base, text) {
+	if (!await isInsideWorkTree(root)) throw new CliError(text.needsWorkTree(root));
+	if (!await isCommitRef(root, base)) throw new CliError(text.unknownRef(base));
 	try {
 		return await changedSince(root, base);
 	} catch (error) {
-		throw new CliError(`Cannot list the files changed since "${base}": ${gitFailureReason(error)}`);
+		throw new CliError(text.cannotListChanged(base, gitFailureReason(error)));
 	}
 }
 function formatFinding(finding) {
 	const location = finding.line === void 0 ? finding.file : `${finding.file}:${finding.line}`;
 	return `${finding.severity} ${finding.code} ${location} ${finding.message}`;
 }
-function error(code, file, message) {
+function error(code, file, message, hint) {
 	return {
 		severity: "error",
 		code,
 		file,
-		message
+		message,
+		hint
 	};
 }
 function sortFindings(findings) {
 	return [...findings].sort((a, b) => compare(a.file, b.file) || (a.line ?? 0) - (b.line ?? 0) || compare(a.code, b.code));
 }
-function plural(count, noun) {
-	return `${count} ${noun}${count === 1 ? "" : "s"}`;
-}
 function compare(a, b) {
 	return a < b ? -1 : a > b ? 1 : 0;
 }
-export { loadConfig as A, loadRule as C, parseContext as D, loadContext as E, FormatError as M, formatIssue as N, splitFrontmatter as O, isRuleId as S, CONTEXT_FILE_NAME as T, listRepoFiles as _, CliError as a, RULE_TAG_PATTERN as b, openCatalog as c, scanTestTags as d, findRulebookRoot as f, expandGlobs as g, createGlobMatcher as h, pendingImplementation as i, parseConfig as j, CONFIG_FILE_NAME as k, writeJson as l, relativeToRoot as m, lintCatalog as n, findRule as o, loadCatalog as p, lintCommand as r, gitFallbackWarning as s, formatFinding as t, writeLines as u, toRepoPath as v, parseRule as w, findRuleTags as x, runGit as y };
+export { loadConfig as A, loadRule as C, parseContext as D, loadContext as E, messages as M, FormatError as N, splitFrontmatter as O, formatIssue as P, isRuleId as S, CONTEXT_FILE_NAME as T, listRepoFiles as _, CliError as a, RULE_TAG_PATTERN as b, openCatalog as c, scanTestTags as d, findRulebookRoot as f, expandGlobs as g, createGlobMatcher as h, pendingImplementation as i, parseConfig as j, CONFIG_FILE_NAME as k, writeJson as l, relativeToRoot as m, lintCatalog as n, findRule as o, loadCatalog as p, lintCommand as r, gitFallbackWarning as s, formatFinding as t, writeLines as u, toRepoPath as v, parseRule as w, findRuleTags as x, runGit as y };

package/dist/{site-BiiOPVEe.mjs → site-DEdtLk6J.mjs}

@@ -1,4 +1,4 @@
-import { a as CliError, c as openCatalog, d as scanTestTags, g as expandGlobs, n as lintCatalog, s as gitFallbackWarning, u as writeLines, y as runGit } from "./lint-C1yUeLOq.mjs";
+import { a as CliError, c as openCatalog, d as scanTestTags, g as expandGlobs, n as lintCatalog, s as gitFallbackWarning, u as writeLines, y as runGit } from "./lint-D63Q2SM0.mjs";
 import { createRequire } from "node:module";
 import { readFile, readdir, stat, writeFile } from "node:fs/promises";
 import { dirname, extname, isAbsolute, join, relative, resolve, sep } from "node:path";
@@ -440,7 +440,7 @@ async function importSitePackage(from) {
 	throw new CliError(`The site commands need the ${SITE_PACKAGE} package. Install it next to rulebookguard: npm install --save-dev ${SITE_PACKAGE}`);
 }
 async function buildSite(site, catalog, out, language, base, io) {
-	const files = sitePages(await siteData(catalog, gitFallbackWarning(io)), {
+	const files = sitePages(await siteData(catalog, gitFallbackWarning(io, language)), {
 		language,
 		base
 	});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rulebookguard",
-  "version": "0.5.1",
+  "version": "0.6.0",
   "description": "Keep business rules as the single source of truth, bound to code and tests.",
   "homepage": "https://github.com/JuanCJR/rulebookguard#readme",
   "bugs": {
@@ -36,14 +36,14 @@
   },
   "devDependencies": {
     "@modelcontextprotocol/client": "2.3.1",
-    "@rulebookguard/site": "0.5.1",
+    "@rulebookguard/site": "0.6.0",
     "@types/node": "^20.19.43",
     "@types/picomatch": "^4.0.3",
     "typescript": "^7.0.2",
     "vite-plus": "^1.4.0"
   },
   "peerDependencies": {
-    "@rulebookguard/site": "^0.5.1"
+    "@rulebookguard/site": "^0.6.0"
   },
   "peerDependenciesMeta": {
     "@rulebookguard/site": {