@jterrazz/test 10.1.0 → 11.0.0

package/dist/oxlint.js

@@ -251,6 +251,20 @@ const RULE_DOCS = {
 		id: "C1",
 		rationale: "Une profondeur fixe rend la place de chaque fichier prévisible et détectable statiquement."
 	},
+	"c10-contracts-boundary": {
+		channel: "statique",
+		convention: "Hors de `specs/**/contracts/`, un import qui résout dans un dossier de provider (`contracts/{http,openai,anthropic}/…`) est une erreur : un test n’importe que les façades `*.contracts.ts`.",
+		family: "C",
+		id: "C10",
+		rationale: "Les contrats unitaires sont des détails de composition ; passer par la façade garde chaque scénario nommé au même endroit que le monde dont il dérive."
+	},
+	"c11-contract-data-pairing": {
+		channel: "statique",
+		convention: "Dans un dossier de provider, tout `*.response.json` et tout `*.request.ts` a un frère `<souche>.ts` — la souche est le nom jusqu’au PREMIER point (`events.fr.response.json` → `events.ts`) ; une donnée orpheline est une erreur.",
+		family: "C",
+		id: "C11",
+		rationale: "Une donnée n’existe que servie par un contrat — un fichier sans propriétaire est du poids mort qu’aucun test ne charge."
+	},
 	"c2-http-only-requests": {
 		channel: "statique",
 		convention: "`requests/` ne contient que des fichiers `.http` ; toute autre extension est une erreur.",
@@ -260,10 +274,10 @@ const RULE_DOCS = {
 	},
 	"c4-contract-shape": {
 		channel: "statique",
-		convention: "Un fichier de `contracts/` respecte `<nom>.<provider>.ts` (provider ∈ openai|anthropic|http), à plat, `export default defineContract(...)`, imports depuis le point d’entrée public.",
+		convention: "Sous `specs/**/contracts/` : la RACINE ne porte que des façades `*.contracts.ts` (export default construit par `defineContracts(...)` ou une re-export de composition ; exports nommés = scénarios) et les dossiers de provider `http` | `openai` | `anthropic`. Un contrat unitaire est `<provider>/<nom-kebab>.ts` avec un `export default defineContract(...)` (ou une factory qui en retourne un), et son builder de `request` doit désigner le provider de son dossier. Un dossier de provider est plat et ne contient que des `*.ts` et des `*.response.json`.",
 		family: "C",
 		id: "C4",
-		rationale: "Une forme figée rend les contrats découvrables et typables sans convention locale."
+		rationale: "Une arborescence figée sépare la façade publique des unités internes et fait porter le provider par le DOSSIER — les noms de fichiers redeviennent du métier, et la donnée volumineuse se range à côté du contrat qui la sert."
 	},
 	"c6-tomatch-extension": {
 		channel: "statique",
@@ -490,7 +504,7 @@ const CHECKER_PASSES = [
 	},
 	{
 		channel: "checker",
-		convention: "Aucune fixture morte : tout fichier sous `seeds/`/`requests/`/`intercepts/`/`fixtures/` et toute entrée de premier niveau de `expected/` doit être référencée ; un dossier de feature sans `*.test.ts` est orphelin (warning si argument non littéral).",
+		convention: "Aucune fixture morte : tout fichier sous `seeds/`/`requests/`/`fixtures/` et toute entrée de premier niveau de `expected/` doit être référencée ; un dossier de feature sans `*.test.ts` est orphelin (warning si argument non littéral).",
 		family: "C",
 		id: "C9",
 		name: "c9-dead-fixtures",
@@ -1432,8 +1446,94 @@ const c1DomainStructure = {
 	}
 };
 //#endregion
+//#region src/lint/rules/c10-contracts-boundary.ts
+/** A specifier reaching into a provider folder — the internal half of contracts/. */
+const INTERNAL_UNIT = /(?:^|\/)contracts\/(?:anthropic|http|openai)\//u;
+/**
+* CONVENTIONS C10 — the contracts boundary. A feature's `contracts/` folder has
+* a PUBLIC half (`*.contracts.ts` facades: the default export is the world, the
+* named exports are its scenarios) and an INTERNAL half (the `http/`, `openai/`
+* and `anthropic/` unit contracts the facades compose). Outside `contracts/`,
+* importing a unit is an error — a test routes through the facade, so a
+* scenario is named once, next to the world it derives from.
+*/
+const c10ContractsBoundary = {
+	create(context) {
+		const parts = segments(context.physicalFilename);
+		if (!parts.includes("specs")) return {};
+		if (parts.slice(0, -1).includes("contracts")) return {};
+		return importSourceVisitor(({ node, source }) => {
+			if (INTERNAL_UNIT.test(source)) context.report({
+				data: { source },
+				messageId: "internal",
+				node
+			});
+		});
+	},
+	meta: {
+		docs: RULE_DOCS["c10-contracts-boundary"],
+		messages: { internal: "Import \"{{source}}\" reaches into a provider folder — only contracts/*.contracts.ts is importable from a test; add a named scenario export there instead (C10 — see docs/10-linting.md)." },
+		type: "problem"
+	}
+};
+//#endregion
+//#region src/lint/rules/c11-contract-data-pairing.ts
+const TEST_FILE$11 = /\.test\.[cm]?[jt]sx?$/;
+/** The provider folders that may carry data files. */
+const PROVIDERS$1 = [
+	"anthropic",
+	"http",
+	"openai"
+];
+/** Data files: served payloads and matched inputs, both owned by a contract. */
+const DATA_SUFFIXES = [".request.ts", ".response.json"];
+/** The owning contract of a data file: its name up to the FIRST dot, `.ts`. */
+function ownerOf(entry) {
+	return `${entry.slice(0, entry.indexOf("."))}.ts`;
+}
+/**
+* CONVENTIONS C11 — data is owned by a contract. Inside a provider folder every
+* `*.response.json` (served payload) and `*.request.ts` (matched prompt/body)
+* pairs with the sibling `<stem>.ts` that serves it, where the stem is the name
+* up to the FIRST dot: `events.fr.response.json` belongs to `events.ts`. A data
+* file with no owner is dead weight no test can reach — reported on the feature's
+* test file, since oxlint never visits a `.json`.
+*/
+const c11ContractDataPairing = {
+	create(context) {
+		const file = context.physicalFilename;
+		if (!TEST_FILE$11.test(file) || !segments(file).includes("specs")) return {};
+		return { Program(node) {
+			const contractsDir = join(dirname(file), "contracts");
+			for (const provider of PROVIDERS$1) {
+				const entries = listDirectory(join(contractsDir, provider));
+				if (entries === null) continue;
+				const present = new Set(entries);
+				for (const entry of entries) {
+					if (!DATA_SUFFIXES.some((suffix) => entry.endsWith(suffix))) continue;
+					const owner = ownerOf(entry);
+					if (!present.has(owner)) context.report({
+						data: {
+							entry,
+							owner,
+							provider
+						},
+						messageId: "orphan",
+						node
+					});
+				}
+			}
+		} };
+	},
+	meta: {
+		docs: RULE_DOCS["c11-contract-data-pairing"],
+		messages: { orphan: "contracts/{{provider}}/{{entry}} has no owning contract — data pairs with the sibling {{owner}} (stem = name up to the first dot) (C11 — see docs/10-linting.md)." },
+		type: "problem"
+	}
+};
+//#endregion
 //#region src/lint/rules/c2-http-only-requests.ts
-const TEST_FILE$9 = /\.test\.[cm]?[jt]sx?$/;
+const TEST_FILE$10 = /\.test\.[cm]?[jt]sx?$/;
 /**
 * CONVENTIONS C2 — `requests/` contains only `.http` files (a request file is
 * a COMPLETE request: method, path, headers, body). Anchored on the feature's
@@ -1444,7 +1544,7 @@ const TEST_FILE$9 = /\.test\.[cm]?[jt]sx?$/;
 const c2HttpOnlyRequests = {
 	create(context) {
 		const file = context.physicalFilename;
-		if (!TEST_FILE$9.test(file) || !segments(file).includes("specs")) return {};
+		if (!TEST_FILE$10.test(file) || !segments(file).includes("specs")) return {};
 		return { Program(node) {
 			const requestsDir = join(dirname(file), "requests");
 			for (const entry of listDirectory(requestsDir) ?? []) if (!entry.endsWith(".http")) context.report({
@@ -1462,65 +1562,217 @@ const c2HttpOnlyRequests = {
 };
 //#endregion
 //#region src/lint/rules/c4-contract-shape.ts
-/** Providers a contract file may declare (C4 — see docs/10-linting.md). */
+/** The only directories a `contracts/` root may hold — the provider carriers. */
 const PROVIDERS = /* @__PURE__ */ new Set([
 	"anthropic",
 	"http",
 	"openai"
 ]);
-const CONTRACT_NAME = /^[A-Za-z0-9][\w-]*\.(?<provider>[a-z]+)\.[cm]?ts$/;
-/** Is the import source the framework's public entry (`@jterrazz/test` / `src/index`)? */
-function isPublicEntry(source) {
-	return source === "@jterrazz/test" || source.endsWith("/src/index.js") || source.endsWith("/src/index.ts");
+const TEST_FILE$9 = /\.test\.[cm]?[jt]sx?$/;
+/** A file oxlint itself visits — the AST half of the rule reports on those. */
+const SOURCE_FILE = /\.[cm]?[jt]sx?$/;
+/** The public facade of a feature: `contracts/<kebab>.contracts.ts`. */
+const COMPOSITE_FILE = /^[a-z0-9]+(?:-[a-z0-9]+)*\.contracts\.[cm]?ts$/u;
+/** An internal unit contract: `contracts/<provider>/<kebab>.ts`. */
+const UNIT_FILE = /^[a-z0-9]+(?:-[a-z0-9]+)*\.[cm]?ts$/u;
+/** Matched data next to its contract: `contracts/<provider>/<stem>.request.ts`. */
+const REQUEST_DATA_FILE = /^[a-z0-9]+(?:-[a-z0-9]+)*\.request\.[cm]?ts$/u;
+/** Served data next to its contract: `contracts/<provider>/<stem>[.<qualifier>].response.json`. */
+const RESPONSE_DATA_FILE = /\.response\.json$/;
+/** The name a specifier/declaration exports under, when it is `default`. */
+function exportsDefault(node) {
+	return (node.specifiers ?? []).some((specifier) => {
+		const exported = specifier.exported;
+		return exported?.type === "Identifier" && exported.name === "default" || stringValue(exported) === "default";
+	});
+}
+/** Is this node a `defineContract(...)` call? */
+function isDefineContract(node) {
+	const callee = node.callee;
+	return node.type === "CallExpression" && callee?.type === "Identifier" && callee.name === "defineContract";
+}
+/** A default export that may legitimately produce a contract (value or factory). */
+function producesContract(declaration) {
+	if (declaration === void 0) return false;
+	return isDefineContract(declaration) || declaration.type === "ArrowFunctionExpression" || declaration.type === "FunctionDeclaration" || declaration.type === "FunctionExpression" || declaration.type === "Identifier";
 }
 /**
-* CONVENTIONS C4 — a contract file (`contracts/<name>.<provider>.ts`) has a
-* rigid shape: flat under `contracts/` (no subfolders), `provider ∈ { openai,
-* anthropic, http }`, a single `export default defineContract(...)`, no named
-* exports, and imports only from the public entry. The runtime channel (the
-* loader) only catches a bad default export; this rule closes the rest.
+* The provider a `request:` value implies, when the builder is written as
+* `<provider>.<verb>(…)` — the only statically decidable form.
 */
-const c4ContractShape = {
-	create(context) {
-		const parts = segments(context.physicalFilename);
-		const contractsIndex = parts.lastIndexOf("contracts");
-		if (contractsIndex === -1 || contractsIndex >= parts.length - 1 || !parts.includes("specs")) return {};
-		const base = parts.at(-1) ?? "";
-		return { Program(node) {
-			if (contractsIndex !== parts.length - 2) context.report({
-				data: { base },
-				messageId: "subfolder",
+function requestProvider(request) {
+	if (request?.type !== "CallExpression") return;
+	const callee = request.callee;
+	if (callee?.type !== "MemberExpression") return;
+	const object = callee.object;
+	return object?.type === "Identifier" ? object.name : void 0;
+}
+/**
+* The layout half — walks the feature's `contracts/` tree from the test file
+* that owns it. Covers what oxlint never visits: a stray `.json` at the root,
+* a directory that is not a provider, a nested folder or a foreign extension
+* inside a provider folder.
+*/
+function checkLayout(context, node, contractsDir) {
+	const entries = listDirectory(contractsDir);
+	if (entries === null) return;
+	for (const entry of entries) {
+		const path = join(contractsDir, entry);
+		if (!isDirectory(path)) {
+			if (!SOURCE_FILE.test(entry)) context.report({
+				data: { entry },
+				messageId: "rootEntry",
 				node
 			});
-			const match = CONTRACT_NAME.exec(base);
-			if (match === null || !PROVIDERS.has(match.groups?.provider ?? "")) context.report({
-				data: { base },
-				messageId: "badName",
+			continue;
+		}
+		if (!PROVIDERS.has(entry)) {
+			context.report({
+				data: { entry },
+				messageId: "badProviderDir",
 				node
 			});
-			let hasDefault = false;
-			for (const statement of node.body ?? []) if (statement.type === "ImportDeclaration") {
-				const source = stringValue(statement.source);
-				if (source !== void 0 && !isPublicEntry(source)) context.report({
-					data: { source },
-					messageId: "foreignImport",
-					node: statement
-				});
-			} else if (statement.type === "ExportNamedDeclaration" || statement.type === "ExportAllDeclaration") context.report({
-				messageId: "namedExport",
-				node: statement
-			});
-			else if (statement.type === "ExportDefaultDeclaration") {
+			continue;
+		}
+		for (const child of listDirectory(path) ?? []) if (isDirectory(join(path, child))) context.report({
+			data: {
+				child,
+				provider: entry
+			},
+			messageId: "providerSubfolder",
+			node
+		});
+		else if (!/\.[cm]?ts$/u.test(child) && !RESPONSE_DATA_FILE.test(child)) context.report({
+			data: {
+				child,
+				provider: entry
+			},
+			messageId: "providerEntry",
+			node
+		});
+	}
+}
+/** The facade: `<kebab>.contracts.ts`, default-exporting a composition. */
+function checkComposite(context, program, base) {
+	if (!COMPOSITE_FILE.test(base)) {
+		context.report({
+			data: { base },
+			messageId: "rootFile",
+			node: program
+		});
+		return;
+	}
+	let hasDefault = false;
+	let composed = false;
+	walk(program, (node) => {
+		if (node.type === "ExportDefaultDeclaration") hasDefault = true;
+		else if (node.type === "ExportAllDeclaration" || node.type === "ExportNamedDeclaration") {
+			if (exportsDefault(node)) {
 				hasDefault = true;
-				const declaration = statement.declaration;
-				const callee = declaration?.type === "CallExpression" ? declaration.callee : void 0;
-				if (callee?.type !== "Identifier" || callee.name !== "defineContract") context.report({
-					messageId: "notDefineContract",
-					node: statement
-				});
+				composed = stringValue(node.source) !== void 0 || composed;
 			}
-			if (!hasDefault) context.report({
-				messageId: "missingDefault",
+		} else if (node.type === "CallExpression") {
+			const callee = node.callee;
+			if (callee?.type === "Identifier" && callee.name === "defineContracts" || callee !== void 0 && memberPropertyName(callee) === "with") composed = true;
+		}
+	});
+	if (!hasDefault) context.report({
+		data: { base },
+		messageId: "missingComposite",
+		node: program
+	});
+	else if (!composed) context.report({
+		data: { base },
+		messageId: "notDefineContracts",
+		node: program
+	});
+}
+/** A unit contract under its provider folder. */
+function checkUnit(context, program, base, provider) {
+	if (REQUEST_DATA_FILE.test(base)) return;
+	if (!UNIT_FILE.test(base)) {
+		context.report({
+			data: { base },
+			messageId: "badName",
+			node: program
+		});
+		return;
+	}
+	let hasDefault = false;
+	let wellFormed = false;
+	walk(program, (node) => {
+		if (node.type === "ExportDefaultDeclaration") {
+			hasDefault = true;
+			wellFormed = producesContract(node.declaration) || wellFormed;
+		} else if (node.type === "ExportNamedDeclaration" && exportsDefault(node)) {
+			hasDefault = true;
+			wellFormed = true;
+		}
+		if (isDefineContract(node)) {
+			const argument = node.arguments?.[0];
+			const declared = requestProvider(argument === void 0 ? void 0 : findProperty(argument, "request")?.value);
+			if (declared !== void 0 && PROVIDERS.has(declared) && declared !== provider) context.report({
+				data: {
+					declared,
+					provider
+				},
+				messageId: "providerMismatch",
+				node
+			});
+		}
+	});
+	if (!hasDefault) context.report({
+		data: { base },
+		messageId: "missingDefault",
+		node: program
+	});
+	else if (!wellFormed) context.report({
+		data: { base },
+		messageId: "notDefineContract",
+		node: program
+	});
+}
+/**
+* CONVENTIONS C4 — the structure of a feature's `contracts/` tree. The ROOT
+* holds only `*.contracts.ts` facades (default export = a `defineContracts`
+* composition, named exports = scenario factories) and the provider
+* directories `http` / `openai` / `anthropic`. A provider directory holds
+* `<kebab>.ts` unit contracts (default export = `defineContract(...)` or a
+* factory returning one) plus their sibling data (`*.response.json`,
+* `*.request.ts`) — the FOLDER carries the provider, so a unit whose `request`
+* builder names another provider is an error.
+*
+* Two halves: the AST half reports on each contract file it visits, the layout
+* half walks the tree from the feature's test file (oxlint never visits a
+* `.json` fixture or an empty directory).
+*/
+const c4ContractShape = {
+	create(context) {
+		const file = context.physicalFilename;
+		const parts = segments(file);
+		if (!parts.includes("specs")) return {};
+		const contractsIndex = parts.lastIndexOf("contracts");
+		if (contractsIndex === -1) {
+			if (!TEST_FILE$9.test(file)) return {};
+			return { Program(node) {
+				checkLayout(context, node, join(dirname(file), "contracts"));
+			} };
+		}
+		const base = parts.at(-1) ?? "";
+		const depth = parts.length - 1 - contractsIndex;
+		if (depth === 1) return { Program(node) {
+			checkComposite(context, node, base);
+		} };
+		if (depth === 2) {
+			const provider = parts[contractsIndex + 1];
+			return PROVIDERS.has(provider) ? { Program(node) {
+				checkUnit(context, node, base, provider);
+			} } : {};
+		}
+		return { Program(node) {
+			context.report({
+				data: { base },
+				messageId: "tooDeep",
 				node
 			});
 		} };
@@ -1528,12 +1780,18 @@ const c4ContractShape = {
 	meta: {
 		docs: RULE_DOCS["c4-contract-shape"],
 		messages: {
-			badName: "Contract file \"{{base}}\" must be named <name>.<provider>.ts with provider ∈ openai | anthropic | http (C4 — see docs/10-linting.md).",
-			foreignImport: "Contract imports \"{{source}}\" — a contract imports only from the public entry (@jterrazz/test) (C4 — see docs/10-linting.md).",
-			missingDefault: "Contract file has no `export default defineContract(...)` (C4 — see docs/10-linting.md).",
-			namedExport: "Contract files have no named exports — only `export default defineContract(...)` (C4 — see docs/10-linting.md).",
-			notDefineContract: "The default export of a contract file must be `defineContract(...)` syntactically (C4 — see docs/10-linting.md).",
-			subfolder: "Contract file \"{{base}}\" is nested — contracts/ is flat, no subfolders (C4 — see docs/10-linting.md)."
+			badName: "Contract unit \"{{base}}\" must be named <kebab-name>.ts — the folder already carries the provider (C4 — see docs/10-linting.md).",
+			badProviderDir: "contracts/{{entry}}/ is not a provider directory — a contracts/ root holds only http/, openai/, anthropic/ and *.contracts.ts files (C4 — see docs/10-linting.md).",
+			missingComposite: "Contract facade \"{{base}}\" has no default export — it must default-export the composed world (C4 — see docs/10-linting.md).",
+			missingDefault: "Contract unit \"{{base}}\" has no default export — a unit default-exports `defineContract(...)` or a factory returning one (C4 — see docs/10-linting.md).",
+			notDefineContract: "The default export of a contract unit must be `defineContract(...)` or a factory returning a contract (C4 — see docs/10-linting.md).",
+			notDefineContracts: "The default export of \"{{base}}\" must be built from `defineContracts(...)` (or a composition re-export) (C4 — see docs/10-linting.md).",
+			providerEntry: "contracts/{{provider}}/{{child}} is neither a *.ts contract nor a *.response.json payload (C4 — see docs/10-linting.md).",
+			providerMismatch: "This contract lives in contracts/{{provider}}/ but its request is a `{{declared}}.*` builder — the folder carries the provider (C4 — see docs/10-linting.md).",
+			providerSubfolder: "contracts/{{provider}}/{{child}}/ is nested — a provider folder is flat (C4 — see docs/10-linting.md).",
+			rootEntry: "contracts/{{entry}} is not a *.contracts.ts facade — data files live in a provider folder next to their contract (C4 — see docs/10-linting.md).",
+			rootFile: "Contract file \"{{base}}\" sits at the contracts/ root, which holds only *.contracts.ts facades — a unit contract belongs in http/, openai/ or anthropic/ (C4 — see docs/10-linting.md).",
+			tooDeep: "Contract file \"{{base}}\" is nested deeper than contracts/<provider>/ (C4 — see docs/10-linting.md)."
 		},
 		type: "problem"
 	}
@@ -2950,6 +3208,8 @@ const plugin = {
 		"b8-kebab-trigger": b8KebabTrigger,
 		"b9w-product-command": b9wProductCommand,
 		"c1-domain-structure": c1DomainStructure,
+		"c10-contracts-boundary": c10ContractsBoundary,
+		"c11-contract-data-pairing": c11ContractDataPairing,
 		"c2-http-only-requests": c2HttpOnlyRequests,
 		"c4-contract-shape": c4ContractShape,
 		"c6-tomatch-extension": c6ToMatchExtension,