@antelopejs/tooling-configs 0.0.9 → 0.2.1

package/dist/package-B1aipTbn.mjs

@@ -0,0 +1,115 @@
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+//#region src/guardrails/package.ts
+function parseManifest(text) {
+	const manifest = JSON.parse(text);
+	if (manifest === null || Array.isArray(manifest)) throw new Error("package.json must contain an object.");
+	return manifest;
+}
+function packageManager(manifest) {
+	const manager = (manifest.packageManager ?? "pnpm").split("@")[0];
+	switch (manager) {
+		case "pnpm":
+		case "npm":
+		case "yarn":
+		case "bun": return manager;
+		default: throw new Error(`Unsupported package manager ${manager}. Expected pnpm, npm, yarn, or bun.`);
+	}
+}
+function execCommand(manager) {
+	if (manager === "npm") return "npm exec --";
+	if (manager === "bun") return "bun x --no-install";
+	return `${manager} exec`;
+}
+function toolingVersions() {
+	let directory = dirname(fileURLToPath(import.meta.url));
+	while (true) {
+		const path = join(directory, "package.json");
+		if (existsSync(path)) {
+			const manifest = parseManifest(readFileSync(path, "utf8"));
+			if (manifest.name === "@antelopejs/tooling-configs") {
+				const lefthook = manifest.devDependencies?.lefthook;
+				const knip = manifest.devDependencies?.knip;
+				const tsgolint = manifest.devDependencies?.["oxlint-tsgolint"];
+				if (!lefthook || !knip || !tsgolint) throw new Error("tooling-configs must declare lefthook, knip and oxlint-tsgolint devDependencies.");
+				return {
+					lefthook,
+					knip,
+					tsgolint
+				};
+			}
+		}
+		const parent = dirname(directory);
+		if (parent === directory) throw new Error("Cannot find tooling-configs package.json.");
+		directory = parent;
+	}
+}
+function repositoryTools(manifest) {
+	return {
+		installed: {
+			commands: {
+				checks: "antelopejs-checks",
+				size: "antelopejs-check-size",
+				ratchet: "antelopejs-ratchet",
+				sync: "antelopejs-sync"
+			},
+			presets: {
+				"oxlint.config.ts": "@antelopejs/tooling-configs/oxc/lint",
+				"oxfmt.config.ts": "@antelopejs/tooling-configs/oxc/fmt",
+				"knip.config.ts": "@antelopejs/tooling-configs/knip"
+			},
+			hookPrefix: `${execCommand(packageManager(manifest))} `
+		},
+		source: {
+			commands: {
+				checks: "node src/bin/checks.ts",
+				size: "node src/bin/check-size.ts",
+				ratchet: "node src/bin/ratchet.ts",
+				sync: "node src/bin/sync.ts"
+			},
+			presets: {
+				"oxlint.config.ts": "./src/oxc/lint.ts",
+				"oxfmt.config.ts": "./src/oxc/fmt.ts",
+				"knip.config.ts": "./src/knip.ts"
+			},
+			hookPrefix: ""
+		}
+	}[manifest.name === "@antelopejs/tooling-configs" ? "source" : "installed"];
+}
+const PREPARE_INSTALL = "if git rev-parse --is-inside-work-tree >/dev/null 2>&1 && command -v lefthook >/dev/null 2>&1; then lefthook install; fi";
+const DEFAULT_SCRIPTS = {
+	typecheck: "tsc --noEmit",
+	lint: "oxlint",
+	format: "oxfmt .",
+	"format:check": "oxfmt --check .",
+	knip: "knip"
+};
+function prepareScript(current = "") {
+	if (current.includes("if git rev-parse --is-inside-work-tree >/dev/null 2>&1 && command -v lefthook >/dev/null 2>&1; then lefthook install; fi")) return current;
+	const legacy = /(^|&&\s*|;\s*)(?:(?:pnpm exec|npm exec --|yarn exec|bun x --no-install)\s+)?lefthook\s+install(?=\s*(?:$|&&|;))/;
+	if (legacy.test(current)) return current.replace(legacy, `$1${PREPARE_INSTALL}`);
+	return current ? `${current} && ${PREPARE_INSTALL}` : PREPARE_INSTALL;
+}
+function managedPackage(current, versions, options = {}) {
+	if (current === void 0) throw new Error("package.json is missing.");
+	const manifest = parseManifest(current);
+	const scripts = manifest.scripts ??= {};
+	scripts.prepare = prepareScript(scripts.prepare);
+	const tools = repositoryTools(manifest);
+	Object.assign(scripts, tools.commands, {
+		"ratchet:update": `${tools.commands.ratchet} --update`,
+		"sync:check": `${tools.commands.sync} --check`
+	});
+	for (const [name, command] of Object.entries(DEFAULT_SCRIPTS)) scripts[name] ??= name === "typecheck" && options.nuxt ? "nuxi typecheck" : command;
+	const dependencies = manifest.devDependencies ??= {};
+	dependencies.lefthook ??= versions.lefthook;
+	dependencies.knip ??= versions.knip;
+	if (options.typeAware) dependencies["oxlint-tsgolint"] ??= versions.tsgolint;
+	manifest.devDependencies = Object.fromEntries(Object.entries(dependencies).sort(([a], [b]) => a.localeCompare(b)));
+	const indent = /^([\t ]+)"/m.exec(current)?.[1] ?? "  ";
+	const newline = current.includes("\r\n") ? "\r\n" : "\n";
+	return `${JSON.stringify(manifest, null, indent).replaceAll("\n", newline)}${newline}`;
+}
+//#endregion
+export { repositoryTools as a, parseManifest as i, managedPackage as n, toolingVersions as o, packageManager as r, execCommand as t };

package/dist/ratchet-B2-4XxAl.mjs

@@ -0,0 +1,172 @@
+import { a as formatCeilings, n as MAX_FILE_BYTES, o as readCeilings, r as MEASURE_ENV, t as CEILINGS_FILE } from "./ceilings--pJmhSde.mjs";
+import { i as repositoryPath, n as fileBytes, r as gitFiles, t as authoredSizes } from "./files-Bocv-qA8.mjs";
+import { n as sizeFailure } from "./size-DJ7YSry_.mjs";
+import { createRequire } from "node:module";
+import { existsSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { basename, dirname, join } from "node:path";
+import { execFileSync, spawnSync } from "node:child_process";
+//#region src/guardrails/oxlint.ts
+function resolveOxlint(root) {
+	try {
+		const require = createRequire(join(root, "package.json"));
+		return join(dirname(require.resolve("oxlint/package.json")), "bin/oxlint");
+	} catch {
+		throw new Error("oxlint is not installed in this repository. Install dependencies first.");
+	}
+}
+function ruleId(code) {
+	const match = /^([^()]+)\(([^()]+)\)$/.exec(code);
+	if (!match) throw new Error(`Cannot measure oxlint diagnostic code ${JSON.stringify(code)}. Fix parser or configuration errors before recording a baseline.`);
+	const [, plugin, rule] = match;
+	return `${plugin === "typescript-eslint" ? "typescript" : plugin}/${rule}`;
+}
+function parseDiagnostics(text, root) {
+	const report = JSON.parse(text);
+	if (!Array.isArray(report?.diagnostics)) throw new Error("oxlint did not return a JSON diagnostics array.");
+	return report.diagnostics.map((item) => {
+		const file = repositoryPath(root, item.filename);
+		const span = item.labels?.[0]?.span;
+		return {
+			rule: ruleId(item.code),
+			file,
+			location: span ? `${file}:${span.line}:${span.column}` : file,
+			message: item.message,
+			line: span?.line,
+			help: item.help
+		};
+	});
+}
+function lintDiagnostics(root, config, files) {
+	const binary = resolveOxlint(root);
+	const temporary = config === void 0 ? void 0 : mkdtempSync(join(root, ".antelopejs-measure.generated."));
+	try {
+		const args = [
+			binary,
+			"-f",
+			"json"
+		];
+		if (temporary) {
+			const path = join(temporary, "oxlint.config.ts");
+			writeFileSync(path, config ?? "");
+			args.push("--config", path, "--ignore-pattern", `${basename(temporary)}/**`);
+		}
+		if (files) args.push("--", ...files);
+		const result = spawnSync(process.execPath, args, {
+			cwd: root,
+			encoding: "utf8",
+			env: {
+				...process.env,
+				[MEASURE_ENV]: "1"
+			},
+			maxBuffer: 67108864
+		});
+		if (result.error) throw result.error;
+		if (result.status !== 0 && result.status !== 1) throw new Error(`oxlint failed (${result.status ?? result.signal}): ${result.stderr || result.stdout}`);
+		const diagnostics = parseDiagnostics(result.stdout, root);
+		if (result.status !== 0 && diagnostics.length === 0) throw new Error(`oxlint failed without diagnostics: ${result.stderr || result.stdout}`);
+		return diagnostics;
+	} finally {
+		if (temporary) rmSync(temporary, {
+			recursive: true,
+			force: true
+		});
+	}
+}
+//#endregion
+//#region src/guardrails/ratchet.ts
+function baseline(root, diagnostics) {
+	const rules = {};
+	const oversizeFiles = {};
+	for (const diagnostic of diagnostics) if (diagnostic.rule === "eslint/max-lines") {
+		const size = fileBytes(root, diagnostic.file);
+		if (size !== void 0) oversizeFiles[diagnostic.file] = size;
+	} else rules[diagnostic.rule] = (rules[diagnostic.rule] ?? 0) + 1;
+	for (const [file, size] of authoredSizes(root)) if (size > 2e4) oversizeFiles[file] = size;
+	return {
+		rules,
+		oversizeFiles
+	};
+}
+function measureBaseline(root, config) {
+	return baseline(root, lintDiagnostics(root, config));
+}
+function changedFiles(root) {
+	if (spawnSync("git", [
+		"rev-parse",
+		"--verify",
+		"HEAD"
+	], {
+		cwd: root,
+		stdio: "ignore"
+	}).status !== 0) return new Set(gitFiles(root));
+	const tracked = execFileSync("git", [
+		"diff",
+		"HEAD",
+		"--name-only",
+		"-z"
+	], {
+		cwd: root,
+		encoding: "utf8"
+	});
+	const untracked = execFileSync("git", [
+		"ls-files",
+		"--others",
+		"--exclude-standard",
+		"-z"
+	], {
+		cwd: root,
+		encoding: "utf8"
+	});
+	return new Set(`${tracked}${untracked}`.split("\0").filter(Boolean));
+}
+function lowerCeilings(ceilings, current) {
+	const lowered = [];
+	for (const [rule, limit] of Object.entries(ceilings.rules)) {
+		const count = current.rules[rule] ?? 0;
+		if (count === 0) delete ceilings.rules[rule];
+		else if (count < limit) ceilings.rules[rule] = count;
+		if (count < limit) lowered.push(`${rule}: ${limit} -> ${count}`);
+	}
+	for (const [file, limit] of Object.entries(ceilings.oversizeFiles)) if (current.oversizeFiles[file] === void 0) {
+		delete ceilings.oversizeFiles[file];
+		lowered.push(`${file}: removed oversize allowance`);
+	} else if (current.oversizeFiles[file] < limit) {
+		ceilings.oversizeFiles[file] = current.oversizeFiles[file];
+		lowered.push(`${file}: ${limit} -> ${current.oversizeFiles[file]} bytes`);
+	}
+	return lowered;
+}
+function ratchet(root, update = false) {
+	if (!existsSync(join(root, "guardrails.ratchet.json"))) throw new Error(`${CEILINGS_FILE} is missing. Run antelopejs-sync first.`);
+	const ceilings = readCeilings(root);
+	const diagnostics = lintDiagnostics(root);
+	const current = baseline(root, diagnostics);
+	const changed = changedFiles(root);
+	const failures = [];
+	for (const [rule, count] of Object.entries(current.rules)) {
+		const limit = ceilings.rules[rule] ?? 0;
+		if (count <= limit) continue;
+		failures.push(`${rule}: ${count} diagnostics exceeds ceiling ${limit}.`);
+		const matches = diagnostics.filter((diagnostic) => diagnostic.rule === rule);
+		const inChanged = matches.filter(({ file }) => changed.has(file));
+		const shown = inChanged.length > 0 ? inChanged : matches;
+		for (const diagnostic of shown) failures.push(`  ${diagnostic.location}: ${diagnostic.message}`);
+		if (shown.length < matches.length) failures.push(`  ...and ${matches.length - shown.length} recorded in files this change does not touch.`);
+	}
+	for (const [file, size] of Object.entries(current.oversizeFiles)) if (ceilings.oversizeFiles[file] === void 0) failures.push(size > 2e4 ? sizeFailure(file, size, MAX_FILE_BYTES) : `${file}: ${size} bytes and an eslint/max-lines diagnostic; this file has no oversize allowance. Split by responsibility into sibling modules, or split tests by behaviour under test, one file per describe.`);
+	for (const [file, limit] of Object.entries(ceilings.oversizeFiles)) {
+		const size = fileBytes(root, file);
+		if (size !== void 0 && size > limit) failures.push(sizeFailure(file, size, limit));
+	}
+	const lowered = update ? lowerCeilings(ceilings, current) : [];
+	if (update) {
+		const path = join(root, CEILINGS_FILE);
+		writeFileSync(path, formatCeilings(ceilings));
+	}
+	return {
+		failures,
+		lowered
+	};
+}
+//#endregion
+export { ratchet as n, lintDiagnostics as r, measureBaseline as t };

package/dist/shared-BG0Nkzh0.d.mts

@@ -0,0 +1,8 @@
+import "@oxlint/plugins";
+//#region src/oxc/guardrails/shared.d.ts
+/** Test locations shared by the preset's assertion and test-quality rules. */
+declare const TEST_FILE_GLOBS: string[];
+/** Assertion entry points recognized by the assertion and function-only rules. */
+declare const ASSERTION_FUNCTION_NAMES: string[];
+//#endregion
+export { TEST_FILE_GLOBS as n, ASSERTION_FUNCTION_NAMES as t };

package/dist/{shared-Ch-ZcMQb.mjs → shared-NC0T8ykm.mjs}

@@ -1,5 +1,9 @@
 //#region src/oxc/shared.ts
-/** Paths every AntelopeJS project generates or vendors, and that no linter should read. */
+/**
+* Paths every AntelopeJS project generates or vendors, and that no linter should read.
+* `.github/ISSUE_TEMPLATE/**` holds GitHub's legacy issue templates: Markdown with
+* YAML frontmatter saved under a .yml extension, which a YAML formatter cannot parse.
+*/
 const IGNORE_PATTERNS = [
 	"**/node_modules/**",
 	"**/dist/**",

package/dist/shared-WC0z3y9F.mjs

@@ -0,0 +1,63 @@
+//#region src/oxc/guardrails/shared.ts
+/** Test locations shared by the preset's assertion and test-quality rules. */
+const TEST_FILE_GLOBS = [
+	"**/*.test.*",
+	"**/*.spec.*",
+	"**/test/**",
+	"**/tests/**",
+	"**/__tests__/**"
+];
+/** Assertion entry points recognized by the assertion and function-only rules. */
+const ASSERTION_FUNCTION_NAMES = [
+	"expect",
+	"assert",
+	"assert.*",
+	"assert*",
+	"expect*"
+];
+/** Static property names include quoted computed access, but never dynamic keys. */
+function memberName(node) {
+	if (!node.computed) return node.property.type === "Identifier" ? node.property.name : null;
+	return node.property.type === "Literal" && !("regex" in node.property) ? String(node.property.value) : null;
+}
+/** A statically named callee, such as expect, assert.equal, or test.concurrent.only. */
+function callName(node) {
+	if (node.type === "Identifier") return node.name;
+	if (node.type !== "MemberExpression") return null;
+	const owner = callName(node.object);
+	const name = memberName(node);
+	return owner !== null && name !== null ? `${owner}.${name}` : null;
+}
+/** The expect call and matcher path in expect(value).to.deep.equal(expected). */
+function matcherChain(node) {
+	const chain = [];
+	let current = node.callee;
+	while (current.type === "MemberExpression") {
+		const name = memberName(current);
+		if (name === null) return null;
+		chain.unshift(name);
+		current = current.object;
+	}
+	if (current.type !== "CallExpression" || callName(current.callee) !== "expect") return null;
+	return {
+		expect: current,
+		matcher: chain.join(".")
+	};
+}
+function isAssertionName(name) {
+	return ASSERTION_FUNCTION_NAMES.some((pattern) => pattern.endsWith("*") ? name.startsWith(pattern.slice(0, -1)) : name === pattern);
+}
+/** Assertion syntax shared by both test-quality rules, including fluent assertion libraries. */
+function isAssertion(node) {
+	if (node.type === "MemberExpression") return memberName(node) === "should";
+	const name = callName(node.callee);
+	return name !== null && (isAssertionName(name) || name.startsWith("sinon.assert.") || name === "should") || node.callee.type === "MemberExpression" && memberName(node.callee) === "expect";
+}
+/** Executable inline callbacks for it/test, excluding skipped and todo registrations. */
+function testCallback(node) {
+	const name = callName(node.callee);
+	if (name === null || !/^(?:it|test)(?:\.(?:only|concurrent|serial|fails|skip|todo))*$/u.test(name) || /\.(?:skip|todo)(?:\.|$)/u.test(name)) return void 0;
+	for (const argument of node.arguments) if (argument.type === "ArrowFunctionExpression" || argument.type === "FunctionExpression") return argument;
+}
+//#endregion
+export { matcherChain as a, isAssertion as i, TEST_FILE_GLOBS as n, memberName as o, callName as r, testCallback as s, ASSERTION_FUNCTION_NAMES as t };

package/dist/size-DJ7YSry_.mjs

@@ -0,0 +1,17 @@
+import { o as readCeilings } from "./ceilings--pJmhSde.mjs";
+import { t as authoredSizes } from "./files-Bocv-qA8.mjs";
+//#region src/guardrails/size.ts
+function sizeFailure(file, size, limit) {
+	return `${file}: ${size} bytes, ${size - limit} bytes over the ${limit}-byte ceiling. Split by responsibility into sibling modules, one cohesive group of exports each; keep the original path re-exporting only if it is a public entry point. Split a test file by behaviour under test, one file per describe. Do not minify, strip whitespace, or move code under an excluded path to pass.`;
+}
+function checkSize(root, files, staged = false) {
+	const ceilings = readCeilings(root);
+	const failures = [];
+	for (const [file, size] of authoredSizes(root, files, staged)) {
+		const limit = ceilings.oversizeFiles[file] ?? 2e4;
+		if (size > limit) failures.push(sizeFailure(file, size, limit));
+	}
+	return failures;
+}
+//#endregion
+export { sizeFailure as n, checkSize as t };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@antelopejs/tooling-configs",
-  "version": "0.0.9",
+  "version": "0.2.1",
   "description": "Shared tooling presets for AntelopeJS repositories: oxlint (with the vendored anti-slop rules), oxfmt, ESLint for Nuxt layers, Knip, and an interface range check",
   "keywords": [
     "antelopejs",
@@ -21,7 +21,11 @@
     "url": "git+https://github.com/AntelopeJS/tooling-configs.git"
   },
   "bin": {
-    "antelopejs-check-interface-ranges": "./dist/bin/check-interface-ranges.mjs"
+    "antelopejs-check-interface-ranges": "./dist/bin/check-interface-ranges.mjs",
+    "antelopejs-check-size": "./dist/bin/check-size.mjs",
+    "antelopejs-checks": "./dist/bin/checks.mjs",
+    "antelopejs-ratchet": "./dist/bin/ratchet.mjs",
+    "antelopejs-sync": "./dist/bin/sync.mjs"
   },
   "files": [
     "dist"
@@ -31,6 +35,7 @@
     "./oxc/lint": "./dist/oxc/lint.mjs",
     "./oxc/fmt": "./dist/oxc/fmt.mjs",
     "./oxc/anti-slop": "./dist/oxc/anti-slop/index.mjs",
+    "./oxc/guardrails": "./dist/oxc/guardrails/index.mjs",
     "./knip": "./dist/knip.mjs",
     "./eslint": "./dist/eslint.mjs"
   },
@@ -46,19 +51,30 @@
     "prepack": "pnpm run build",
     "release": "pnpm run lint && pnpm run prepack && release-it",
     "typecheck": "tsc --noEmit",
-    "test": "node --test \"src/oxc/anti-slop/rules/*.test.ts\" \"src/*.test.ts\"",
-    "checks": "pnpm run typecheck && pnpm run lint && pnpm run format:check && pnpm run test",
-    "format:check": "oxfmt --check ."
+    "test": "node --test \"src/**/*.test.ts\"",
+    "checks": "node src/bin/checks.ts",
+    "format:check": "oxfmt --check .",
+    "size": "node src/bin/check-size.ts",
+    "ratchet": "node src/bin/ratchet.ts",
+    "prepare": "if git rev-parse --is-inside-work-tree >/dev/null 2>&1 && command -v lefthook >/dev/null 2>&1; then lefthook install; fi",
+    "sync": "node src/bin/sync.ts",
+    "ratchet:update": "node src/bin/ratchet.ts --update",
+    "sync:check": "node src/bin/sync.ts --check",
+    "knip": "knip"
   },
   "dependencies": {
-    "@oxlint/plugins": "1.81.0"
+    "@oxlint/plugins": "1.81.0",
+    "yaml": "^2.9.1"
   },
   "devDependencies": {
     "@nuxt/eslint-config": "^1.17.0",
     "@types/node": "^24.13.3",
     "eslint-plugin-perfectionist": "^5.11.0",
+    "knip": "^6.34.0",
+    "lefthook": "^2.2.2",
     "oxfmt": "^0.66.0",
     "oxlint": "1.81.0",
+    "oxlint-tsgolint": "^7.0.2001",
     "release-it": "^19.2.4",
     "release-it-changelogen": "^0.1.0",
     "tsdown": "^0.22.14",