@antelopejs/tooling-configs 0.0.8 → 0.2.0

package/dist/files-BSl0U8lT.mjs

@@ -0,0 +1,98 @@
+import { n as IGNORE_PATTERNS, t as AGENT_IGNORE_PATTERNS } from "./shared-NC0T8ykm.mjs";
+import { existsSync, lstatSync } from "node:fs";
+import { join, matchesGlob, relative, resolve } from "node:path";
+import { execFileSync, spawnSync } from "node:child_process";
+//#region src/guardrails/cli.ts
+function runCli(main) {
+	try {
+		process.exitCode = main();
+	} catch (error) {
+		process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
+		process.exitCode = 1;
+	}
+}
+//#endregion
+//#region src/guardrails/files.ts
+const SIZE_EXCLUSIONS = [
+	{
+		kind: "generated",
+		patterns: [
+			...IGNORE_PATTERNS,
+			...AGENT_IGNORE_PATTERNS,
+			"**/*.generated.*",
+			"**/generated/**",
+			"**/__snapshots__/**"
+		]
+	},
+	{
+		kind: "fixtures",
+		patterns: ["**/fixtures/**", "**/__fixtures__/**"]
+	},
+	{
+		kind: "lockfiles",
+		patterns: [
+			"**/{pnpm-lock.yaml,package-lock.json,npm-shrinkwrap.json,yarn.lock,bun.lock,bun.lockb,Cargo.lock,poetry.lock,uv.lock,Gemfile.lock,composer.lock,go.sum}",
+			"**/*.lock",
+			"**/*.lockb"
+		]
+	},
+	{
+		kind: "documentation",
+		patterns: ["**/CHANGELOG.md", "**/*.{md,mdx,markdown,MD}"]
+	},
+	{
+		kind: "assets",
+		patterns: ["**/*.{png,jpg,jpeg,gif,webp,avif,ico,svg,bmp,tiff,pdf,mp3,wav,ogg,flac,mp4,webm,mov,avi,woff,woff2,ttf,otf,eot,zip,gz,tgz,bz2,xz,7z,tar,rar,wasm,bin,exe,dll,so,dylib,db,sqlite,sqlite3,icns}"]
+	}
+];
+function gitFiles(root) {
+	return [...new Set(execFileSync("git", [
+		"ls-files",
+		"--cached",
+		"--others",
+		"--exclude-standard",
+		"-z"
+	], {
+		cwd: root,
+		encoding: "utf8"
+	}).split("\0").filter(Boolean))];
+}
+function repositoryRoot(cwd = process.cwd()) {
+	return execFileSync("git", ["rev-parse", "--show-toplevel"], {
+		cwd,
+		encoding: "utf8"
+	}).trim();
+}
+function repositoryPath(root, file) {
+	return relative(root, resolve(root, file)).split("\\").join("/");
+}
+function fileBytes(root, file, staged = false) {
+	if (staged) {
+		const result = spawnSync("git", [
+			"cat-file",
+			"-s",
+			`:${file}`
+		], {
+			cwd: root,
+			encoding: "utf8"
+		});
+		if (result.error) throw result.error;
+		return result.status === 0 ? Number(result.stdout.trim()) : void 0;
+	}
+	const path = join(root, file);
+	if (!existsSync(path)) return void 0;
+	const stat = lstatSync(path);
+	return stat.isFile() ? stat.size : void 0;
+}
+function authoredSizes(root, files = gitFiles(root), staged = false) {
+	const sizes = /* @__PURE__ */ new Map();
+	for (const input of files) {
+		const file = repositoryPath(root, input);
+		if (SIZE_EXCLUSIONS.some(({ patterns }) => patterns.some((pattern) => matchesGlob(file, pattern)))) continue;
+		const size = fileBytes(root, file, staged);
+		if (size !== void 0) sizes.set(file, size);
+	}
+	return sizes;
+}
+//#endregion
+export { repositoryRoot as a, repositoryPath as i, fileBytes as n, runCli as o, gitFiles as r, authoredSizes as t };

package/dist/knip.mjs

@@ -9,6 +9,11 @@
 * The front end is absent too: {@link DEFAULT_PROJECT} only reaches `src/`, so
 * `frontend-vue/` is outside the analysis unless a repository opts it in
 * through Knip's `workspaces`, which an ignore here would then override.
+*
+* - `src/interfaces/**`: the public API, imported through the package's `exports` subpaths.
+* - `src/test/**`: the test tree run by `ajs module test`, which Knip has no plugin for.
+*   The whole directory, because the runner loads the harness and its fixtures; no test imports them.
+* - `antelope.test.ts`: the `ajs module test` harness manifest, when a module keeps one at its root.
 */
 const DEFAULT_ENTRY = [
 	"src/interfaces/**/*.ts",

package/dist/oxc/fmt.mjs

@@ -1,4 +1,4 @@
-import { n as IGNORE_PATTERNS, t as AGENT_IGNORE_PATTERNS } from "../shared-Ch-ZcMQb.mjs";
+import { n as IGNORE_PATTERNS, t as AGENT_IGNORE_PATTERNS } from "../shared-NC0T8ykm.mjs";
 import { defineConfig } from "oxfmt";
 //#region src/oxc/fmt.ts
 /**

package/dist/oxc/guardrails/index.d.mts

@@ -0,0 +1,6 @@
+import { n as TEST_FILE_GLOBS, t as ASSERTION_FUNCTION_NAMES } from "../../shared-BG0Nkzh0.mjs";
+//#region src/oxc/guardrails/index.d.ts
+/** AntelopeJS rules that reject comments and low-evidence tests. */
+declare const guardrailsPlugin: import("@oxlint/plugins").Plugin;
+//#endregion
+export { ASSERTION_FUNCTION_NAMES, TEST_FILE_GLOBS, guardrailsPlugin as default };

package/dist/oxc/guardrails/index.mjs

@@ -0,0 +1,318 @@
+import { a as matcherChain, i as isAssertion, n as TEST_FILE_GLOBS, o as memberName, r as callName, s as testCallback, t as ASSERTION_FUNCTION_NAMES } from "../../shared-WC0z3y9F.mjs";
+import { defineRule, eslintCompatPlugin } from "@oxlint/plugins";
+//#region src/oxc/guardrails/rules/no-comments.ts
+const allowedCommentForms = [
+	{
+		type: "Shebang",
+		pattern: /^/u
+	},
+	{
+		type: "Block",
+		pattern: /^[*!]/u,
+		raw: true
+	},
+	{
+		type: "Line",
+		pattern: /^\/\s*<reference\s[^>]*\/\s*>\s*$/u
+	},
+	{
+		type: null,
+		pattern: /^(?:oxlint|eslint)-enable(?:\s|$)/u
+	},
+	{
+		type: null,
+		pattern: /^(?:oxlint|eslint)-disable(?:-line|-next-line)?\s+(?!-)[\w@/]/u
+	},
+	{
+		type: null,
+		pattern: /^@ts-expect-error(?:\s*:\s*|\s+)(?!:)\S/u
+	},
+	{
+		type: null,
+		pattern: /^SAFETY:/u,
+		safety: true
+	},
+	{
+		type: null,
+		pattern: /^(?:#|@)__PURE__\s*$/u
+	},
+	{
+		type: null,
+		pattern: /^@vite-ignore\b/u
+	},
+	{
+		type: null,
+		pattern: /^webpack(?:ChunkName|Prefetch|Preload|Mode|Ignore|Exports|Include|Exclude)\s*:/u
+	},
+	{
+		type: null,
+		pattern: /^(?:prettier|oxfmt)-ignore\s*$/u
+	}
+];
+const disableDirective = /^(?:oxlint|eslint)-disable(?:-line|-next-line)?(?:\s|$)/u;
+/** Ordinary comments must become executable constraints or documentation on a public item. */
+const noCommentsRule = defineRule({
+	meta: {
+		type: "problem",
+		docs: { description: "Disallow comments except documentation and explicit compiler or safety directives." },
+		messages: {
+			comment: "Comments rot. Encode this constraint in a type, a lint rule, or a test, or write TSDoc (`/** */`) on the public item it documents.",
+			unnamedDisable: "Name the rule(s) to disable and give a reason, for example: oxlint-disable-next-line no-debugger -- debugging this operation."
+		}
+	},
+	createOnce(context) {
+		return { Program() {
+			let safetyLine;
+			for (const comment of context.sourceCode.getAllComments()) {
+				const text = comment.value.replace(/^\s*\*?\s*/u, "").trimEnd();
+				const form = allowedCommentForms.find((allowed) => (allowed.type === null || allowed.type === comment.type) && allowed.pattern.test("raw" in allowed ? comment.value : text));
+				const continuesSafety = comment.type === "Line" && safetyLine !== void 0 && comment.loc.start.line === safetyLine.loc.end.line + 1 && /^\s*$/u.test(context.sourceCode.text.slice(safetyLine.end, comment.start));
+				safetyLine = comment.type === "Line" && (continuesSafety || form !== void 0 && "safety" in form) ? comment : void 0;
+				const unnamedDisable = disableDirective.test(text) && form === void 0;
+				if (!unnamedDisable && (form !== void 0 || continuesSafety)) continue;
+				context.report({
+					loc: comment.loc,
+					messageId: unnamedDisable ? "unnamedDisable" : "comment"
+				});
+			}
+		} };
+	}
+});
+//#endregion
+//#region src/oxc/guardrails/rules/no-constant-value-assertion.ts
+const equalityMatchers = /* @__PURE__ */ new Set([
+	"toBe",
+	"toEqual",
+	"toStrictEqual",
+	"to.equal",
+	"to.eq",
+	"eql",
+	"to.eql",
+	"to.deep.eq",
+	"to.deep.equal",
+	"to.be.equal"
+]);
+const constantName = /^[A-Z][A-Z0-9]*(?:_[A-Z0-9]+)*$/u;
+function isConstant(node) {
+	if (node?.type === "Identifier") return constantName.test(node.name);
+	if (node?.type !== "MemberExpression") return false;
+	return isConstant(node.object);
+}
+function isLiteralValue(node) {
+	if (node.type === "Literal") return !("regex" in node) && !("bigint" in node);
+	if (node.type === "TemplateLiteral") return node.expressions.length === 0;
+	if (node.type === "UnaryExpression") return node.operator === "-" && node.argument.type === "Literal" && Number.isFinite(node.argument.value);
+	if (node.type === "ArrayExpression") return node.elements.every((element) => element !== null && isLiteralValue(element));
+	if (node.type === "ObjectExpression") return node.properties.every((property) => property.type === "Property" && !property.computed && !property.method && !property.shorthand && property.kind === "init" && isLiteralValue(property.value));
+	return false;
+}
+/** Constant declarations already specify their values; tests must assert the behavior they drive. */
+const noConstantValueAssertionRule = defineRule({
+	meta: {
+		type: "problem",
+		docs: { description: "Disallow assertions that only restate a constant's literal value." },
+		messages: { constant: "A test that restates a constant fails only when someone edits the constant on purpose. Assert the behaviour the constant drives." }
+	},
+	createOnce(context) {
+		return { CallExpression(node) {
+			const chain = matcherChain(node);
+			const expected = node.arguments[0];
+			if (chain !== null && equalityMatchers.has(chain.matcher) && isConstant(chain.expect.arguments[0]) && expected !== void 0 && isLiteralValue(expected)) context.report({
+				node,
+				messageId: "constant"
+			});
+		} };
+	}
+});
+//#endregion
+//#region src/oxc/guardrails/rules/no-fs-read-in-tests.ts
+const fsModules = /* @__PURE__ */ new Set(["fs", "node:fs"]);
+const readMethods = /* @__PURE__ */ new Set(["readFileSync", "readdirSync"]);
+function isFsRequire(node) {
+	return node.type === "CallExpression" && node.callee.type === "Identifier" && node.callee.name === "require" && node.arguments[0]?.type === "Literal" && fsModules.has(String(node.arguments[0].value));
+}
+function isFsNamespace(source, node) {
+	if (isFsRequire(node)) return true;
+	if (node.type !== "Identifier") return false;
+	let scope = source.getScope(node);
+	while (scope !== null) {
+		const binding = scope.set.get(node.name);
+		if (binding !== void 0) return binding.defs.some((definition) => {
+			if (definition.node.type === "TSImportEqualsDeclaration") {
+				const reference = definition.node.moduleReference;
+				return reference.type === "TSExternalModuleReference" && fsModules.has(reference.expression.value);
+			}
+			if (definition.type === "ImportBinding") return (definition.node.type !== "ImportSpecifier" || definition.node.imported.type === "Identifier" && definition.node.imported.name === "default") && definition.parent?.type === "ImportDeclaration" && fsModules.has(definition.parent.source.value);
+			return definition.node.type === "VariableDeclarator" && definition.node.init !== null && isFsRequire(definition.node.init);
+		});
+		scope = scope.upper;
+	}
+	return false;
+}
+/** Tests exercise behavior through public interfaces rather than reading implementation text. */
+const noFsReadInTestsRule = defineRule({
+	meta: {
+		type: "problem",
+		docs: { description: "Move synchronous filesystem reads out of tests into fixture helpers." },
+		messages: { fsRead: "Tests exercise behaviour through the public interface. A test that reads source files asserts text, not behaviour. Move fixture reads into a helper under fixtures/, helpers/ or locales/." }
+	},
+	createOnce(context) {
+		return {
+			ImportDeclaration(node) {
+				if (!fsModules.has(node.source.value) || node.importKind === "type") return;
+				for (const specifier of node.specifiers) {
+					if (specifier.type !== "ImportSpecifier" || specifier.importKind === "type") continue;
+					const name = specifier.imported.type === "Identifier" ? specifier.imported.name : specifier.imported.value;
+					if (readMethods.has(name)) context.report({
+						node: specifier,
+						messageId: "fsRead"
+					});
+				}
+			},
+			MemberExpression(node) {
+				const name = memberName(node);
+				if (name !== null && readMethods.has(name) && isFsNamespace(context.sourceCode, node.object)) context.report({
+					node,
+					messageId: "fsRead"
+				});
+			},
+			VariableDeclarator(node) {
+				if (node.id.type !== "ObjectPattern" || node.init === null || !isFsNamespace(context.sourceCode, node.init)) return;
+				for (const property of node.id.properties) {
+					if (property.type !== "Property") continue;
+					const name = property.key.type === "Identifier" && !property.computed ? property.key.name : property.key.type === "Literal" ? String(property.key.value) : null;
+					if (name !== null && readMethods.has(name)) context.report({
+						node: property,
+						messageId: "fsRead"
+					});
+				}
+			}
+		};
+	}
+});
+//#endregion
+//#region src/oxc/guardrails/rules/no-typeof-function-only-test.ts
+const functionMatchers = /* @__PURE__ */ new Set([
+	"toBeTypeOf",
+	"to.be.a",
+	"to.be.an"
+]);
+const typeofMatchers = /* @__PURE__ */ new Set(["toBe", "to.equal"]);
+const assertTypeofMatchers = /* @__PURE__ */ new Set(["assert.equal", "assert.strictEqual"]);
+function isTypeof(node) {
+	return node?.type === "UnaryExpression" && node.operator === "typeof";
+}
+function isFunctionString(node) {
+	return node?.type === "Literal" && node.value === "function";
+}
+function isFunctionCheck(node) {
+	const name = callName(node.callee);
+	if (name === "assert.isFunction") return true;
+	if (name !== null && assertTypeofMatchers.has(name)) return isTypeof(node.arguments[0]) && isFunctionString(node.arguments[1]);
+	let outer = node;
+	while (outer.parent.type === "MemberExpression" && outer.parent.object === outer) {
+		let member = outer.parent;
+		while (member.parent.type === "MemberExpression" && member.parent.object === member) member = member.parent;
+		if (member.parent.type !== "CallExpression" || member.parent.callee !== member) break;
+		outer = member.parent;
+	}
+	const chain = matcherChain(outer);
+	if (chain === null || !isFunctionString(outer.arguments[0])) return false;
+	return functionMatchers.has(chain.matcher) || typeofMatchers.has(chain.matcher) && isTypeof(chain.expect.arguments[0]);
+}
+/** Function existence alone is already a type-checker guarantee, not a behavioral test. */
+const noTypeofFunctionOnlyTestRule = defineRule({
+	meta: {
+		type: "problem",
+		docs: { description: "Require tests to do more than assert that functions exist." },
+		messages: { functionOnly: "The type checker already proves this. Call the function and assert what it returns or does." }
+	},
+	createOnce(context) {
+		const frames = [];
+		function recordAssertion(node) {
+			const frame = frames.at(-1);
+			if (frame === void 0 || node.start < frame.callback.start || node.end > frame.callback.end || !isAssertion(node)) return;
+			frame.assertions.push(node.type === "CallExpression" && isFunctionCheck(node));
+		}
+		return {
+			before() {
+				frames.length = 0;
+			},
+			CallExpression(node) {
+				const callback = testCallback(node);
+				if (callback !== void 0) frames.push({
+					node,
+					callback,
+					assertions: []
+				});
+				else recordAssertion(node);
+			},
+			MemberExpression: recordAssertion,
+			"CallExpression:exit"(node) {
+				const frame = frames.at(-1);
+				if (frame?.node !== node) return;
+				frames.pop();
+				if (frame.assertions.length > 0 && frame.assertions.every(Boolean)) context.report({
+					node,
+					messageId: "functionOnly"
+				});
+			}
+		};
+	}
+});
+//#endregion
+//#region src/oxc/guardrails/rules/require-assertion.ts
+/** Test callbacks must contain an assertion regardless of their framework or filename. */
+const requireAssertionRule = defineRule({
+	meta: {
+		type: "problem",
+		docs: { description: "Require an assertion in every executable test callback." },
+		messages: { missingAssertion: "Call an assertion in this test to verify its behavior." }
+	},
+	createOnce(context) {
+		const frames = [];
+		function recordAssertion(node) {
+			const frame = frames.at(-1);
+			if (frame !== void 0 && node.start >= frame.callback.start && node.end <= frame.callback.end && isAssertion(node)) frame.hasAssertion = true;
+		}
+		return {
+			before() {
+				frames.length = 0;
+			},
+			CallExpression(node) {
+				const callback = testCallback(node);
+				if (callback !== void 0) frames.push({
+					node,
+					callback,
+					hasAssertion: false
+				});
+				else recordAssertion(node);
+			},
+			MemberExpression: recordAssertion,
+			"CallExpression:exit"(node) {
+				const frame = frames.at(-1);
+				if (frame?.node !== node) return;
+				frames.pop();
+				if (!frame.hasAssertion) context.report({
+					node,
+					messageId: "missingAssertion"
+				});
+			}
+		};
+	}
+});
+//#endregion
+//#region src/oxc/guardrails/index.ts
+/** AntelopeJS rules that reject comments and low-evidence tests. */
+const guardrailsPlugin = eslintCompatPlugin({
+	meta: { name: "antelopejs" },
+	rules: {
+		"no-comments": noCommentsRule,
+		"no-fs-read-in-tests": noFsReadInTestsRule,
+		"no-constant-value-assertion": noConstantValueAssertionRule,
+		"no-typeof-function-only-test": noTypeofFunctionOnlyTestRule,
+		"require-assertion": requireAssertionRule
+	}
+});
+//#endregion
+export { ASSERTION_FUNCTION_NAMES, TEST_FILE_GLOBS, guardrailsPlugin as default };