rulebookguard 0.5.1 → 0.7.0

package/dist/lint-C1yUeLOq.mjs

@@ -1,755 +0,0 @@
-import { access, lstat, readFile, readdir, realpath } from "node:fs/promises";
-import { Ajv2020 } from "ajv/dist/2020.js";
-import { YAMLParseError, parse } from "yaml";
-import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
-import picomatch from "picomatch";
-import { execFile } from "node:child_process";
-import { promisify } from "node:util";
-// src/format/errors.ts
-function formatIssue(issue) {
-	return issue.field === void 0 ? `${issue.file}: ${issue.message}` : `${issue.file}: field "${issue.field}" ${issue.message}`;
-}
-var FormatError = class extends Error {
-	issues;
-	constructor(issues) {
-		super(issues.map(formatIssue).join("\n"));
-		this.name = "FormatError";
-		this.issues = issues;
-	}
-};
-// src/format/read.ts
-async function readSource(path) {
-	try {
-		return await readFile(path, "utf8");
-	} catch (error) {
-		throw new FormatError([{
-			file: path,
-			message: `cannot read file (${error.code ?? "unknown error"})`
-		}]);
-	}
-}
-// schemas/v1/config.schema.json
-var config_schema_default = {
-	$schema: "https://json-schema.org/draft/2020-12/schema",
-	$id: "urn:rulebookguard:schema:v1:config",
-	title: "rulebookguard.config.yaml",
-	type: "object",
-	properties: {
-		"schema": { "const": 1 },
-		"rulesDir": {
-			"type": "string",
-			"minLength": 1,
-			"default": "docs/rules"
-		},
-		"testGlobs": {
-			"type": "array",
-			"items": {
-				"type": "string",
-				"minLength": 1
-			}
-		},
-		"contextBudget": {
-			"type": "integer",
-			"minimum": 1,
-			"default": 30
-		},
-		"language": { "enum": ["en", "es"] }
-	},
-	required: ["schema", "testGlobs"],
-	additionalProperties: false
-};
-// schemas/v1/context.schema.json
-var context_schema_default = {
-	$schema: "https://json-schema.org/draft/2020-12/schema",
-	$id: "urn:rulebookguard:schema:v1:context",
-	title: "_context.md frontmatter",
-	type: "object",
-	properties: {
-		"context": {
-			"type": "string",
-			"minLength": 1
-		},
-		"prefix": {
-			"type": "string",
-			"pattern": "^[A-Z][A-Z0-9]*$"
-		},
-		"summary": {
-			"type": "string",
-			"minLength": 1,
-			"pattern": "^[^\\r\\n]*$"
-		}
-	},
-	required: [
-		"context",
-		"prefix",
-		"summary"
-	],
-	additionalProperties: false
-};
-// schemas/v1/rule.schema.json
-var rule_schema_default = {
-	$schema: "https://json-schema.org/draft/2020-12/schema",
-	$id: "urn:rulebookguard:schema:v1:rule",
-	title: "Rule file frontmatter",
-	type: "object",
-	$defs: { "ruleId": {
-		"type": "string",
-		"pattern": "^R-[A-Z][A-Z0-9]*-[0-9]{3}$"
-	} },
-	properties: {
-		"id": { "$ref": "#/$defs/ruleId" },
-		"context": {
-			"type": "string",
-			"minLength": 1
-		},
-		"entities": {
-			"type": "array",
-			"items": {
-				"type": "string",
-				"minLength": 1
-			}
-		},
-		"status": { "enum": [
-			"proposed",
-			"active",
-			"deprecated"
-		] },
-		"supersedes": { "$ref": "#/$defs/ruleId" },
-		"anchors": {
-			"type": "array",
-			"items": {
-				"type": "string",
-				"minLength": 1
-			}
-		},
-		"summary": {
-			"type": "string",
-			"minLength": 1,
-			"pattern": "^[^\\r\\n]*$"
-		}
-	},
-	required: [
-		"id",
-		"context",
-		"entities",
-		"status",
-		"anchors",
-		"summary"
-	],
-	additionalProperties: false
-};
-// src/format/validate.ts
-const ajv = new Ajv2020({
-	allErrors: true,
-	useDefaults: true
-});
-const validators = {
-	config: ajv.compile(config_schema_default),
-	context: ajv.compile(context_schema_default),
-	rule: ajv.compile(rule_schema_default)
-};
-function validate(validator, data, file) {
-	if (validator(data)) return data;
-	throw new FormatError((validator.errors ?? []).map((error) => toIssue(error, file)));
-}
-function toIssue(error, file) {
-	const base = toFieldPath(error.instancePath);
-	const params = error.params;
-	switch (error.keyword) {
-		case "required": return {
-			file,
-			field: join$1(base, String(params.missingProperty)),
-			message: "is required"
-		};
-		case "additionalProperties": return {
-			file,
-			field: join$1(base, String(params.additionalProperty)),
-			message: "is not allowed"
-		};
-		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 "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");
-	}
-}
-function withField(file, field, message) {
-	return field === "" ? {
-		file,
-		message
-	} : {
-		file,
-		field,
-		message
-	};
-}
-function join$1(base, key) {
-	return base === "" ? key : `${base}.${key}`;
-}
-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) {
-	try {
-		return parse(source);
-	} catch (error) {
-		if (error instanceof YAMLParseError) throw new FormatError([{
-			file,
-			message: `invalid YAML: ${singleLine(error)}`
-		}]);
-		throw error;
-	}
-}
-function singleLine(error) {
-	const first = (error.message.split("\n")[0] ?? "").replace(/:\s*$/, "");
-	const position = error.linePos?.[0];
-	if (position === void 0 || / at line \d+, column \d+$/.test(first)) return first;
-	return `${first} at line ${position.line}, column ${position.col}`;
-}
-// src/format/config.ts
-const CONFIG_FILE_NAME = "rulebookguard.config.yaml";
-function parseConfig(source, file) {
-	return validate(validators.config, parseYaml(source, file), file);
-}
-async function loadConfig(path) {
-	return parseConfig(await readSource(path), path);
-}
-// src/format/frontmatter.ts
-const OPENING = /^---\r?\n/;
-const CLOSING = /^---[ \t]*(?:\r?\n|$)/m;
-function splitFrontmatter(source, file) {
-	const opening = OPENING.exec(source);
-	if (opening === null) throw new FormatError([{
-		file,
-		message: "missing YAML frontmatter delimited by \"---\" lines"
-	}]);
-	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"
-	}]);
-	const yaml = rest.slice(0, closing.index);
-	const body = rest.slice(closing.index + closing[0].length).replace(/^(?:\r?\n)+/, "");
-	return {
-		data: parseYaml(yaml, file),
-		body
-	};
-}
-// src/format/context.ts
-const CONTEXT_FILE_NAME = "_context.md";
-function parseContext(source, file) {
-	const { data, body } = splitFrontmatter(source, file);
-	return {
-		file,
-		...validate(validators.context, data, file),
-		body
-	};
-}
-async function loadContext(path) {
-	return parseContext(await readSource(path), path);
-}
-// 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);
-	return {
-		file,
-		...validate(validators.rule, data, file),
-		body
-	};
-}
-async function loadRule(path) {
-	return parseRule(await readSource(path), path);
-}
-// src/format/tag.ts
-const RULE_TAG_PATTERN = /(?<![\w@.-])@rule\s+(R-[A-Z][A-Z0-9]*-[0-9]{3})(?![\w-])/g;
-function findRuleTags(source) {
-	const tags = [];
-	source.split(/\r?\n/).forEach((text, index) => {
-		for (const match of text.matchAll(RULE_TAG_PATTERN)) tags.push({
-			id: match[1],
-			line: index + 1
-		});
-	});
-	return tags;
-}
-// src/catalog/git.ts
-const execFileAsync = promisify(execFile);
-const SAFE_CONFIG = ["-c", "core.fsmonitor=false"];
-async function runGit(cwd, args) {
-	const { stdout } = await execFileAsync("git", [...SAFE_CONFIG, ...args], {
-		cwd,
-		maxBuffer: 268435456
-	});
-	return stdout;
-}
-async function gitPaths(cwd, command, args) {
-	return (await runGit(cwd, [
-		command,
-		"-z",
-		...args
-	])).split("\0").filter((path) => path !== "");
-}
-async function isInsideWorkTree(cwd) {
-	try {
-		return (await runGit(cwd, ["rev-parse", "--is-inside-work-tree"])).trim() === "true";
-	} catch {
-		return false;
-	}
-}
-async function isCommitRef(cwd, ref) {
-	if (ref.startsWith("-")) return false;
-	try {
-		await runGit(cwd, [
-			"rev-parse",
-			"--verify",
-			"--quiet",
-			`${ref}^{commit}`
-		]);
-		return true;
-	} catch {
-		return false;
-	}
-}
-async function changedSince(cwd, ref) {
-	const changed = await gitPaths(cwd, "diff", [
-		"--name-only",
-		"--relative",
-		ref,
-		"--"
-	]);
-	const untracked = await gitPaths(cwd, "ls-files", ["--others", "--exclude-standard"]);
-	return [.../* @__PURE__ */ new Set([...changed, ...untracked])].sort();
-}
-function gitFailureReason(error) {
-	const { code, stderr, message } = error;
-	if (code === "ENOENT") return "git was not found";
-	return `${typeof stderr === "string" ? stderr : ""}\n${String(message ?? error)}`.split("\n").map((line) => line.trim()).filter((line) => line !== "" && !line.startsWith("warning:"))[0] ?? "git failed";
-}
-function isNotARepository(error) {
-	const { stderr } = error;
-	return typeof stderr === "string" && stderr.includes("not a git repository");
-}
-// src/catalog/files.ts
-const SKIPPED_DIRECTORIES = /* @__PURE__ */ new Set([".git", "node_modules"]);
-const GITLINK_MODE = "160000";
-function toRepoPath(path) {
-	return path.replaceAll("\\", "/").replace(/^(?:\.\/)+/, "");
-}
-function createGlobMatcher(globs) {
-	if (globs.length === 0) return () => false;
-	const isMatch = picomatch(globs);
-	return (path) => isMatch(toRepoPath(path));
-}
-async function listRepoFiles(root, onGitFallback) {
-	return (await listGitFiles(root, {
-		realRoot: await realpath(root),
-		prefix: "",
-		onGitFallback
-	}) ?? await walkFiles(root)).sort();
-}
-async function expandGlobs(root, globs, onGitFallback) {
-	const isMatch = createGlobMatcher(globs);
-	return (await listRepoFiles(root, onGitFallback)).filter(isMatch);
-}
-async function listGitFiles(root, scope) {
-	let listing;
-	try {
-		listing = await listGitIndex(root);
-	} catch (error) {
-		if (isNotARepository(error)) return;
-		if (scope.prefix !== "") throw error;
-		scope.onGitFallback?.(gitFailureReason(error));
-		return;
-	}
-	if (listing === void 0) return;
-	const { files, gitlinks } = listing;
-	for (const gitlink of gitlinks) {
-		const nested = await listSubmoduleFiles(root, gitlink, scope);
-		files.push(...nested.map((file) => `${gitlink}/${file}`));
-	}
-	return files;
-}
-async function listGitIndex(root) {
-	const staged = (await gitPaths(root, "ls-files", ["--stage"])).map(parseStageEntry);
-	const others = await gitPaths(root, "ls-files", ["--others", "--exclude-standard"]);
-	const deleted = new Set(await gitPaths(root, "ls-files", ["--deleted"]));
-	const gitlinks = new Set(staged.filter(({ mode }) => mode === GITLINK_MODE).map(({ path }) => path));
-	const files = [.../* @__PURE__ */ new Set([...staged.map(({ path }) => path), ...others])].filter((file) => !deleted.has(file) && !gitlinks.has(file));
-	if (files.length === 0 && gitlinks.size === 0) return;
-	return {
-		files,
-		gitlinks: [...gitlinks]
-	};
-}
-async function listSubmoduleFiles(root, gitlink, scope) {
-	const dir = join(root, gitlink);
-	const path = `${scope.prefix}${gitlink}`;
-	try {
-		if (!await isContainedEntry(dir, scope.realRoot)) return [];
-		if (!await exists$1(join(dir, ".git"))) return await walkFiles(dir);
-		return await listGitFiles(dir, {
-			...scope,
-			prefix: `${path}/`
-		}) ?? await walkFiles(dir);
-	} catch (error) {
-		scope.onGitFallback?.(gitFailureReason(error), path);
-		return [];
-	}
-}
-async function isContainedEntry(path, realRoot) {
-	try {
-		if ((await lstat(path)).isSymbolicLink()) return false;
-	} catch (error) {
-		if (error.code === "ENOENT") return false;
-		throw error;
-	}
-	return resolvesInside(path, realRoot);
-}
-async function resolvesInside(path, realRoot) {
-	let target;
-	try {
-		target = await realpath(path);
-	} catch (error) {
-		if (error.code === "ENOENT") return false;
-		throw error;
-	}
-	const fromRoot = relative(realRoot, target);
-	return fromRoot !== ".." && !fromRoot.startsWith(`..${sep}`) && !isAbsolute(fromRoot);
-}
-function parseStageEntry(entry) {
-	const tab = entry.indexOf("	");
-	return {
-		mode: entry.slice(0, entry.indexOf(" ")),
-		path: entry.slice(tab + 1)
-	};
-}
-async function exists$1(path) {
-	try {
-		await access(path);
-		return true;
-	} catch {
-		return false;
-	}
-}
-async function walkFiles(root) {
-	const files = [];
-	await walk(root, "", files);
-	return files;
-}
-async function walk(root, prefix, files) {
-	const entries = await readdir(join(root, prefix), { withFileTypes: true });
-	for (const entry of entries) {
-		const path = prefix === "" ? entry.name : `${prefix}/${entry.name}`;
-		if (entry.isDirectory()) {
-			if (!SKIPPED_DIRECTORIES.has(entry.name)) await walk(root, path, files);
-		} else if (entry.isFile()) files.push(path);
-	}
-}
-// src/catalog/load.ts
-async function findRulebookRoot(start) {
-	let directory = resolve(start);
-	for (;;) {
-		if (await exists(join(directory, "rulebookguard.config.yaml"))) return directory;
-		const parent = dirname(directory);
-		if (parent === directory) return;
-		directory = parent;
-	}
-}
-async function loadCatalog(root) {
-	const config = await loadConfig(join(root, CONFIG_FILE_NAME));
-	const catalog = {
-		root,
-		config,
-		contexts: [],
-		rules: [],
-		invalidRuleIds: [],
-		issues: []
-	};
-	const rulesDir = toRepoPath(config.rulesDir).replace(/\/+$/, "");
-	const directories = await listEntries(join(root, rulesDir));
-	if (directories === void 0) {
-		catalog.issues.push({
-			code: "missing-rules-dir",
-			file: rulesDir,
-			message: "directory does not exist"
-		});
-		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));
-	return catalog;
-}
-async function loadContextDirectory(catalog, dir, name) {
-	const files = (await listEntries(join(catalog.root, dir)) ?? []).filter((entry) => entry.isFile() && entry.name.endsWith(".md")).map((entry) => entry.name);
-	let context;
-	if (files.includes("_context.md")) {
-		context = await load(catalog, `${dir}/${CONTEXT_FILE_NAME}`, loadContext);
-		if (context !== void 0) {
-			catalog.contexts.push(context);
-			checkContextName(catalog, context, name);
-		}
-	} else catalog.issues.push({
-		code: "missing-context-file",
-		file: dir,
-		message: "has no _context.md"
-	});
-	for (const file of files.filter((item) => item !== CONTEXT_FILE_NAME)) {
-		const rule = await load(catalog, `${dir}/${file}`, loadRule);
-		const baseName = file.slice(0, -3);
-		if (rule === void 0 && isRuleId(baseName)) catalog.invalidRuleIds.push(baseName);
-		if (rule !== void 0) {
-			catalog.rules.push(rule);
-			checkRule(catalog, rule, name, baseName, context);
-		}
-	}
-}
-async function load(catalog, file, loader) {
-	try {
-		return {
-			...await loader(join(catalog.root, file)),
-			file
-		};
-	} catch (error) {
-		if (!(error instanceof FormatError)) throw error;
-		for (const issue of error.issues) catalog.issues.push({
-			code: "schema",
-			...issue,
-			file
-		});
-		return;
-	}
-}
-function checkContextName(catalog, doc, name) {
-	if (doc.context !== name) catalog.issues.push({
-		code: "context-mismatch",
-		file: doc.file,
-		field: "context",
-		message: `must match its directory name "${name}"`
-	});
-}
-function checkRule(catalog, rule, directory, baseName, context) {
-	if (rule.id !== baseName) catalog.issues.push({
-		code: "file-name-mismatch",
-		file: rule.file,
-		field: "id",
-		message: `must match the file name "${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}"`
-	});
-	checkContextName(catalog, rule, directory);
-}
-function findDuplicateIds(rules) {
-	const firstFile = /* @__PURE__ */ new Map();
-	const issues = [];
-	for (const rule of rules) {
-		const first = firstFile.get(rule.id);
-		if (first === void 0) firstFile.set(rule.id, rule.file);
-		else issues.push({
-			code: "duplicate-id",
-			file: rule.file,
-			field: "id",
-			message: `duplicates the id of ${first}`
-		});
-	}
-	return issues;
-}
-async function listEntries(path) {
-	try {
-		return (await readdir(path, { withFileTypes: true })).sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0);
-	} catch (error) {
-		if (error.code === "ENOENT") return;
-		throw error;
-	}
-}
-async function exists(path) {
-	try {
-		await access(path);
-		return true;
-	} catch {
-		return false;
-	}
-}
-function relativeToRoot(root, path) {
-	return toRepoPath(relative(root, path));
-}
-// src/catalog/tags.ts
-async function scanTestTags(root, testGlobs, onGitFallback) {
-	const index = /* @__PURE__ */ new Map();
-	const realRoot = await realpath(root);
-	for (const file of await expandGlobs(root, testGlobs, onGitFallback)) {
-		const path = join(root, file);
-		if (!await resolvesInside(path, realRoot)) continue;
-		const source = await readFile(path, "utf8");
-		for (const { id, line } of findRuleTags(source)) {
-			const locations = index.get(id) ?? [];
-			locations.push({
-				file,
-				line
-			});
-			index.set(id, locations);
-		}
-	}
-	return new Map([...index].sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0));
-}
-var CliError = class extends Error {
-	exitCode;
-	constructor(message, exitCode = 1) {
-		super(message);
-		this.name = "CliError";
-		this.exitCode = exitCode;
-	}
-};
-async function requireRulebookRoot(io) {
-	const root = await findRulebookRoot(io.cwd);
-	if (root === void 0) throw new CliError(`${CONFIG_FILE_NAME} not found in ${io.cwd} or any parent directory.`);
-	return root;
-}
-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`);
-	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.`);
-	return rule;
-}
-function writeJson(io, value) {
-	io.stdout(`${JSON.stringify(value, null, 2)}\n`);
-}
-function writeLines(io, lines) {
-	io.stdout(lines.map((line) => `${line}\n`).join(""));
-}
-function gitFallbackWarning(io) {
-	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`);
-			}
-			return;
-		}
-		if (!warned) {
-			warned = true;
-			io.stderr(`warning: git could not list files (${reason}); walking the directory instead.\n`);
-		}
-	};
-}
-// src/commands/lint.ts
-async function lintCommand(io, options) {
-	const root = await requireRulebookRoot(io);
-	let catalog;
-	try {
-		catalog = await loadCatalog(root);
-	} catch (error) {
-		if (!(error instanceof FormatError)) throw error;
-		return report(io, error.issues.map((issue) => issueFinding("schema", {
-			...issue,
-			file: relativeToRoot(root, issue.file)
-		})), options.json);
-	}
-	const changed = options.base === void 0 ? void 0 : await changedFiles(catalog.root, options.base);
-	const warn = gitFallbackWarning(io);
-	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);
-}
-function report(io, findings, json) {
-	const sorted = sortFindings(findings);
-	const errors = sorted.filter((finding) => finding.severity === "error").length;
-	const warnings = sorted.length - errors;
-	if (json) writeJson(io, {
-		findings: sorted,
-		errors,
-		warnings
-	});
-	else if (sorted.length === 0) writeLines(io, ["No issues found."]);
-	else writeLines(io, [...sorted.map(formatFinding), `${plural(errors, "error")}, ${plural(warnings, "warning")}`]);
-	return errors > 0 ? 1 : 0;
-}
-function issueFinding(code, { file, field, message }) {
-	return error(code, file, field === void 0 ? message : `field "${field}" ${message}`);
-}
-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 files = await listRepoFiles(catalog.root, onGitFallback);
-	const status = new Map(catalog.rules.map((rule) => [rule.id, rule.status]));
-	const invalid = new Set(catalog.invalidRuleIds);
-	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`));
-	}
-	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`),
-			line
-		} : {
-			...error("deprecated-rule-tag", file, `tags ${id}, which is deprecated`),
-			line
-		});
-	}
-	const budget = catalog.config.contextBudget;
-	for (const context of catalog.contexts) {
-		const count = catalog.rules.filter((rule) => rule.context === context.context).length;
-		if (count > budget) findings.push({
-			severity: "warning",
-			code: "context-over-budget",
-			file: context.file,
-			message: `context "${context.context}" has ${count} rules, more than the contextBudget of ${budget}`
-		});
-	}
-	return findings;
-}
-function pendingImplementation(catalog, tags, base, changed) {
-	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`));
-}
-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}".`);
-	try {
-		return await changedSince(root, base);
-	} catch (error) {
-		throw new CliError(`Cannot list the files changed since "${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) {
-	return {
-		severity: "error",
-		code,
-		file,
-		message
-	};
-}
-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 };