@jterrazz/intelligence 4.2.0 → 6.0.0

package/dist/oxlint.js

@@ -0,0 +1,623 @@
+import { existsSync } from "node:fs";
+import { dirname, join } from "node:path";
+//#region src/lint/ast.ts
+/**
+* Shared AST helpers for the rule files. Everything here is pure and
+* structural: rules narrow nodes by `type` and read fields defensively, so the
+* layer stays decoupled from oxlint's internal (alpha) typings (mirrors
+* `@jterrazz/test`'s `src/lint/ast.ts`).
+*/
+/** Split a path into its non-empty segments (posix or win separators). */
+function segments(path) {
+	return path.split(/[/\\]/).filter(Boolean);
+}
+/** The string value of a plain string literal (or a template with no holes). */
+function stringValue(node) {
+	if (node === void 0) return;
+	if (node.type === "Literal" && typeof node.value === "string") return node.value;
+	if (node.type === "TemplateLiteral") {
+		const expressions = node.expressions;
+		const quasis = node.quasis;
+		if (expressions?.length === 0 && quasis?.length === 1) return quasis[0].value?.cooked;
+	}
+}
+/** The property name of a non-computed member expression, if identifiable. */
+function memberPropertyName(node) {
+	if (node.type !== "MemberExpression" || node.computed === true) return;
+	const property = node.property;
+	return property?.type === "Identifier" ? property.name : void 0;
+}
+//#endregion
+//#region src/lint/agents.ts
+/**
+* Is `filePath` under a folder literally named `agents` (exact path segment,
+* anywhere in the path — P1's broader scope, unlike {@link detectAgentFile}'s
+* narrower `<name>/<name>.ts` shape)?
+*/
+function isUnderAgentsFolder(filePath) {
+	return segments(filePath).includes("agents");
+}
+/**
+* `agents/<name>/<name>.ts` — the file basename (minus `.ts`) must equal its
+* parent directory name, and an `agents` segment must be a proper ancestor of
+* that parent directory. Returns `undefined` for anything else, including
+* `*.prompt.ts` and `*.test.ts` (never agent files).
+*/
+function detectAgentFile(filePath) {
+	const parts = segments(filePath);
+	const base = parts.at(-1);
+	if (base === void 0 || !base.endsWith(".ts")) return;
+	if (base.endsWith(".prompt.ts") || base.endsWith(".test.ts")) return;
+	const stem = base.slice(0, -3);
+	const parentIndex = parts.length - 2;
+	if (parts[parentIndex] !== stem) return;
+	const agentsIndex = parts.lastIndexOf("agents");
+	if (agentsIndex === -1 || agentsIndex >= parentIndex) return;
+	return { name: stem };
+}
+/** `<name>.prompt.ts` — any directory; `shared` is true directly under `_shared/`. */
+function detectPromptFile(filePath) {
+	const parts = segments(filePath);
+	const base = parts.at(-1);
+	if (base === void 0 || !base.endsWith(".prompt.ts")) return;
+	const stem = base.slice(0, -10);
+	return {
+		dir: dirname(filePath),
+		name: stem,
+		shared: parts.at(-2) === "_shared"
+	};
+}
+//#endregion
+//#region src/lint/manifest.ts
+/**
+* The rule manifest — the single source of truth for the mechanized
+* agent/prompt conventions catalogue (mirrors `@jterrazz/test`'s
+* `src/lint/manifest.ts` docs-as-code inversion: the normative text lives
+* NEXT TO the rule it documents, attached as `meta.docs`, instead of drifting
+* apart in a hand-maintained doc).
+*
+* The README's "Agent & prompt conventions" section is the human-facing
+* explanation of *why* this shape exists; this manifest is the machine-facing
+* "what exactly is checked" — `plugin.test.ts` asserts every shipped rule
+* carries its entry and that no entry is orphaned.
+*/
+const RULE_DOCS = {
+	"g1-agent-class-shape": {
+		id: "G1",
+		convention: "An agent file (`agents/<name>/<name>.ts`) exports exactly one class; that class has a `static readonly SCHEMA` member, a `run` method, and a constructor whose first parameter is named `model`.",
+		rationale: "A fixed shape makes every agent class predictable to read and to wire up from a DI container without re-deriving its contract each time."
+	},
+	"m1-model-resolution-in-container": {
+		id: "M1",
+		convention: "Calls to `createIntelligence(...)`, `createGatewayProvider(...)`, `createOpenRouterProvider(...)`, and `.model('…')` on the value they produce, are only allowed in a file whose path contains `/di/` or whose name ends in `container.ts`.",
+		rationale: "Model resolution is composition-root work — scattering it lets a provider/model choice drift outside the one place meant to own it."
+	},
+	"m2w-no-hardcoded-model-id": {
+		id: "M2",
+		convention: "A string literal that looks like a model id (`claude-…`, `openai/gpt-…`, …) outside config/test/fixture/spec files is a warning — model ids belong in configuration.",
+		rationale: "A model id inlined in application code can only change by a code deploy; configuration lets it change without one."
+	},
+	"p1-prose-in-prompt-files": {
+		id: "P1",
+		convention: "In any file under an `agents/` folder that is not a `*.prompt.ts` (nor a `*.test.ts`), a template literal spanning 3+ lines that reads as natural-language prose (a line with 4+ space-separated words, or a markdown heading) is an error — move it to the sibling `*.prompt.ts`.",
+		rationale: "The agent class only shapes data; prose that leaks into it hides the actual prompt contract and makes the two impossible to review independently."
+	},
+	"p2-prompt-file-exports": {
+		id: "P2",
+		convention: "A `*.prompt.ts` file exports only const arrow functions returning a string, plus types/interfaces — no default export, no class, no non-function const.",
+		rationale: "A closed export surface keeps a prompt file a pure builder module — anything else (state, a class, a default export) would invite prompt logic to grow side effects."
+	},
+	"p3-agent-prompt-sibling": {
+		id: "P3",
+		convention: "An agent file (`agents/<name>/<name>.ts`) imports its prompt from `./<name>.prompt.js`; a `<name>.prompt.ts` file outside `_shared/` has a sibling `<name>.ts` in the same directory.",
+		rationale: "The two-way link is what makes the pairing mechanical instead of a naming convention nobody enforces — an orphaned prompt file, or an agent that silently doesn't use its prompt, is almost always a mistake."
+	}
+};
+//#endregion
+//#region src/lint/rules/g1-agent-class-shape.ts
+/** Unwrap `private readonly model: T` (TSParameterProperty) / defaults to the bare identifier. */
+function parameterName(param) {
+	if (param === void 0) return;
+	if (param.type === "Identifier") return param.name;
+	if (param.type === "TSParameterProperty") return parameterName(param.parameter);
+	if (param.type === "AssignmentPattern") return parameterName(param.left);
+}
+function classBody(classNode) {
+	return classNode.body?.body ?? [];
+}
+/**
+* CONVENTIONS G1 — an agent file's class shape: exactly one exported class,
+* carrying a `static readonly SCHEMA` member, a `run` method, and a
+* constructor whose first parameter is `model` (the `LanguageModel` the
+* class's `run()` passes straight to `generateText`/`streamText`).
+*/
+const g1AgentClassShape = {
+	create(context) {
+		const file = context.physicalFilename;
+		if (detectAgentFile(file) === void 0) return {};
+		const exportedClasses = [];
+		return {
+			ExportDefaultDeclaration(node) {
+				const declaration = node.declaration;
+				if (declaration?.type === "ClassDeclaration" || declaration?.type === "ClassExpression") exportedClasses.push(declaration);
+			},
+			ExportNamedDeclaration(node) {
+				const declaration = node.declaration;
+				if (declaration?.type === "ClassDeclaration") exportedClasses.push(declaration);
+			},
+			"Program:exit"(node) {
+				if (exportedClasses.length === 0) {
+					context.report({
+						messageId: "noExportedClass",
+						node
+					});
+					return;
+				}
+				if (exportedClasses.length > 1) for (const extra of exportedClasses.slice(1)) context.report({
+					messageId: "multipleExportedClasses",
+					node: extra
+				});
+				const target = exportedClasses[0];
+				const members = classBody(target);
+				if (!members.some((member) => {
+					if (member.type !== "PropertyDefinition" || member.static !== true) return false;
+					const key = member.key;
+					return key?.type === "Identifier" && key.name === "SCHEMA";
+				})) context.report({
+					messageId: "missingSchema",
+					node: target
+				});
+				if (!members.some((member) => {
+					if (member.type !== "MethodDefinition" && member.type !== "PropertyDefinition") return false;
+					const key = member.key;
+					return key?.type === "Identifier" && key.name === "run";
+				})) context.report({
+					messageId: "missingRun",
+					node: target
+				});
+				const constructor = members.find((member) => member.type === "MethodDefinition" && (member.kind === "constructor" || member.key?.name === "constructor"));
+				if (constructor === void 0) {
+					context.report({
+						messageId: "missingConstructorModel",
+						node: target
+					});
+					return;
+				}
+				const firstParam = (constructor.value?.params)?.[0];
+				if (parameterName(firstParam) !== "model") context.report({
+					messageId: "missingConstructorModel",
+					node: firstParam ?? constructor
+				});
+			}
+		};
+	},
+	meta: {
+		docs: RULE_DOCS["g1-agent-class-shape"],
+		messages: {
+			missingConstructorModel: "Agent class constructor's first parameter must be named `model` (G1).",
+			missingRun: "Agent class is missing a `run` method (G1).",
+			missingSchema: "Agent class is missing a `static readonly SCHEMA` member (G1).",
+			multipleExportedClasses: "Agent file exports more than one class — exactly one (G1).",
+			noExportedClass: "Agent file exports no class — exactly one is required (G1)."
+		},
+		type: "problem"
+	}
+};
+//#endregion
+//#region src/lint/rules/m1-model-resolution-in-container.ts
+/** The composition-root factories `@jterrazz/intelligence` exposes. */
+const FACTORY_NAMES = /* @__PURE__ */ new Set([
+	"createGatewayProvider",
+	"createIntelligence",
+	"createOpenRouterProvider"
+]);
+/** Is `file` a DI/composition-root file? */
+function isContainerFile(file) {
+	return file.includes("/di/") || file.endsWith("container.ts");
+}
+/**
+* CONVENTIONS M1 — model resolution is composition-root work. `createIntelligence`
+* and the two provider factories, plus `.model('…')` calls on whatever they
+* produce, are only allowed in a file under `di/` or named `*container.ts`.
+*
+* Detection is best effort by design: a `.model(<string literal>)` call is
+* flagged wherever it appears in a file that imports `@jterrazz/intelligence`,
+* WITHOUT verifying the receiver is actually the `Intelligence` instance —
+* static analysis cannot reliably trace that binding across parameter
+* passing/destructuring (see the container.ts example in the README, where
+* `Intelligence` arrives as an injected parameter, not a local `const`). A
+* project with an unrelated `.model()` method on some other object, imported
+* from the same file as `@jterrazz/intelligence`, would false-positive here —
+* an accepted, documented limitation of this rule.
+*/
+const m1ModelResolutionInContainer = {
+	create(context) {
+		const file = context.physicalFilename;
+		const allowed = isContainerFile(file);
+		let importsIntelligence = false;
+		const modelCalls = [];
+		const factoryCalls = [];
+		return {
+			CallExpression(node) {
+				const callee = node.callee;
+				if (callee === void 0) return;
+				if (callee.type === "Identifier" && FACTORY_NAMES.has(callee.name)) {
+					factoryCalls.push({
+						name: callee.name,
+						node
+					});
+					return;
+				}
+				if (callee.type === "MemberExpression" && memberPropertyName(callee) === "model") {
+					const args = node.arguments ?? [];
+					if (args.length === 1 && stringValue(args[0]) !== void 0) modelCalls.push(node);
+				}
+			},
+			ImportDeclaration(node) {
+				if (stringValue(node.source) === "@jterrazz/intelligence") importsIntelligence = true;
+			},
+			"Program:exit"() {
+				if (allowed) return;
+				for (const { name, node } of factoryCalls) context.report({
+					data: { name },
+					messageId: "factoryOutsideContainer",
+					node
+				});
+				if (importsIntelligence) for (const node of modelCalls) context.report({
+					messageId: "modelCallOutsideContainer",
+					node
+				});
+			}
+		};
+	},
+	meta: {
+		docs: RULE_DOCS["m1-model-resolution-in-container"],
+		messages: {
+			factoryOutsideContainer: "{{name}}() must only be called from a DI/container file (path containing \"/di/\" or ending in \"container.ts\") (M1).",
+			modelCallOutsideContainer: ".model('…') resolution must only happen in a DI/container file (M1)."
+		},
+		type: "problem"
+	}
+};
+//#endregion
+//#region src/lint/rules/m2w-no-hardcoded-model-id.ts
+/** `claude-…`, `gpt-4o`, `o1-preview`, `grok-2`, `deepseek-v3`, … */
+const BARE_MODEL_ID = /^(?<family>claude|deepseek|gemini|gpt|grok|llama|mistral|o[0-9])[-0-9a-z.]/iu;
+/** `openai/gpt-4o`, `anthropic/claude-3-5-sonnet`, … (provider-prefixed form). */
+const PREFIXED_MODEL_ID = /^[a-z0-9-]+\/(?<family>claude|deepseek|gemini|gpt|grok|llama|mistral)/iu;
+/** Config/test/fixture/spec files are exempt — that's exactly where a model id belongs. */
+function isExemptFile(file) {
+	const parts = segments(file);
+	const base = parts.at(-1) ?? "";
+	if (/\.(?:test|spec)\.[cm]?tsx?$/u.test(base)) return true;
+	if (parts.includes("fixtures") || parts.includes("specs") || parts.includes("__fixtures__")) return true;
+	return parts.includes("config") || /\.config\.[cm]?tsx?$/u.test(base);
+}
+function looksLikeModelId(value) {
+	return BARE_MODEL_ID.test(value) || PREFIXED_MODEL_ID.test(value);
+}
+/**
+* CONVENTIONS M2 (warning) — a string literal shaped like a model id belongs
+* in configuration, not inlined in application code. Config/test/fixture/spec
+* files are exempt by design (oxlint only ever visits `.ts`/`.tsx` sources —
+* a `.yml`/`.json` config value is never in its reach regardless).
+*/
+const m2wNoHardcodedModelId = {
+	create(context) {
+		const file = context.physicalFilename;
+		if (isExemptFile(file)) return {};
+		return { Literal(node) {
+			if (typeof node.value !== "string") return;
+			if (looksLikeModelId(node.value)) context.report({
+				data: { value: node.value },
+				messageId: "hardcodedModelId",
+				node
+			});
+		} };
+	},
+	meta: {
+		docs: RULE_DOCS["m2w-no-hardcoded-model-id"],
+		messages: { hardcodedModelId: "String \"{{value}}\" looks like a model id — model ids belong in configuration (M2)." },
+		type: "suggestion"
+	}
+};
+//#endregion
+//#region src/lint/rules/p1-prose-in-prompt-files.ts
+/** A markdown heading — `#`, `##`, or `###` followed by a space. */
+const MARKDOWN_HEADING = /^#{1,3}\s/;
+/** A line reading as prose: 4+ tokens separated by whitespace. */
+const MIN_PROSE_WORDS = 4;
+/** Does `text` (one physical line) look like natural-language prose? */
+function looksLikeProseLine(line) {
+	const trimmed = line.trim();
+	if (trimmed.length === 0) return false;
+	if (MARKDOWN_HEADING.test(trimmed)) return true;
+	return trimmed.split(/\s+/u).filter(Boolean).length >= MIN_PROSE_WORDS;
+}
+/** Number of physical lines a source span covers, from a `\n` count. */
+function lineSpan(text) {
+	return text.split("\n").length;
+}
+/**
+* CONVENTIONS P1 — the flagship rule: no multi-line natural-language literal
+* outside a `*.prompt.ts` file. A template literal is flagged when its full
+* source span reaches 3+ lines AND at least one of its own static quasis
+* (never the interpolated expressions) reads as prose — a line with 4+
+* space-separated words, or a markdown heading. Single-line literals, JSON-ish
+* multi-line literals, and pure data interpolation stay under the threshold
+* and pass.
+*/
+const p1ProseInPromptFiles = {
+	create(context) {
+		const file = context.physicalFilename;
+		if (!isUnderAgentsFolder(file)) return {};
+		const base = file.split(/[/\\]/).pop() ?? "";
+		if (base.endsWith(".prompt.ts") || base.endsWith(".test.ts")) return {};
+		const target = `${base.replace(/\.ts$/, "")}.prompt.ts`;
+		return { TemplateLiteral(node) {
+			const start = node.start ?? node.range?.[0];
+			const end = node.end ?? node.range?.[1];
+			if (typeof start !== "number" || typeof end !== "number") return;
+			if (lineSpan(context.sourceCode.text.slice(start, end)) < 3) return;
+			if ((node.quasis ?? []).some((quasi) => {
+				return (quasi.value?.raw ?? "").split("\n").some(looksLikeProseLine);
+			})) context.report({
+				data: { target },
+				messageId: "moveProse",
+				node
+			});
+		} };
+	},
+	meta: {
+		docs: RULE_DOCS["p1-prose-in-prompt-files"],
+		messages: { moveProse: "Multi-line natural-language template literal outside a *.prompt.ts file — move prompt prose to {{target}} (P1)." },
+		type: "problem"
+	}
+};
+//#endregion
+//#region src/lint/rules/p2-prompt-file-exports.ts
+/** Declaration types that are types, not values — always allowed. */
+const TYPE_DECLARATIONS = /* @__PURE__ */ new Set(["TSInterfaceDeclaration", "TSTypeAliasDeclaration"]);
+/**
+* Best-effort "does this expression plausibly evaluate to a string?" check.
+* Permissive by design (P2 is a shape gate, not a type checker): a delegated
+* call (`return sharedSection();`), a bare identifier, member access, string
+* concatenation, and `? :` / `||` narrowing all pass. Only expressions that
+* are CLEARLY the wrong shape — an object/array literal, a non-string literal,
+* a nested function — are rejected.
+*/
+function looksLikeStringExpression(node) {
+	if (node === void 0) return false;
+	switch (node.type) {
+		case "BinaryExpression": return node.operator === "+";
+		case "CallExpression":
+		case "Identifier":
+		case "MemberExpression":
+		case "TemplateLiteral": return true;
+		case "ConditionalExpression": return looksLikeStringExpression(node.consequent) && looksLikeStringExpression(node.alternate);
+		case "Literal": return typeof node.value === "string";
+		case "LogicalExpression": return looksLikeStringExpression(node.right);
+		default: return false;
+	}
+}
+/**
+* The expressions `fn` itself returns — the concise-arrow expression body, or
+* every top-level `return`'s argument in a block body (never descending into a
+* nested function's own returns). Each is a REAL AST node (unlike a synthetic
+* `ReturnStatement` wrapper), so it always carries a valid position to report on.
+*/
+function ownReturnExpressions(fn) {
+	const body = fn.body;
+	if (body === void 0) return [];
+	if (body.type !== "BlockStatement") return [body];
+	const expressions = [];
+	const visit = (node) => {
+		if (node === void 0) return;
+		if (node.type === "ReturnStatement") {
+			const argument = node.argument;
+			if (argument !== void 0) expressions.push(argument);
+			return;
+		}
+		if (node.type === "ArrowFunctionExpression" || node.type === "FunctionExpression" || node.type === "FunctionDeclaration") return;
+		for (const key of Object.keys(node)) {
+			if (key === "parent") continue;
+			const value = node[key];
+			if (Array.isArray(value)) {
+				for (const item of value) if (isNode(item)) visit(item);
+			} else if (isNode(value)) visit(value);
+		}
+	};
+	visit(body);
+	return expressions;
+}
+function isNode(value) {
+	return typeof value === "object" && value !== null && typeof value.type === "string";
+}
+/**
+* CONVENTIONS P2 — a `*.prompt.ts` file's export surface is closed: const
+* arrow functions returning a string (the builders), and types/interfaces.
+* No default export, no class, no non-function const, no plain `function`
+* declaration (the convention is arrow consts specifically — see the
+* README's "Agent & prompt conventions" section).
+*/
+const p2PromptFileExports = {
+	create(context) {
+		if (!context.physicalFilename.endsWith(".prompt.ts")) return {};
+		return { Program(node) {
+			for (const statement of node.body ?? []) {
+				if (statement.type === "ExportDefaultDeclaration") {
+					context.report({
+						messageId: "defaultExport",
+						node: statement
+					});
+					continue;
+				}
+				if (statement.type !== "ExportNamedDeclaration") continue;
+				const declaration = statement.declaration;
+				if (declaration === void 0) continue;
+				if (TYPE_DECLARATIONS.has(declaration.type)) continue;
+				if (declaration.type === "ClassDeclaration") {
+					context.report({
+						messageId: "classExport",
+						node: statement
+					});
+					continue;
+				}
+				if (declaration.type !== "VariableDeclaration") {
+					const declId = declaration.id;
+					const declName = declId?.type === "Identifier" ? declId.name : "?";
+					context.report({
+						data: { name: declName },
+						messageId: "nonFunctionExport",
+						node: statement
+					});
+					continue;
+				}
+				for (const declarator of declaration.declarations ?? []) {
+					const id = declarator.id;
+					const name = id?.type === "Identifier" ? id.name : "?";
+					const init = declarator.init;
+					if (init?.type !== "ArrowFunctionExpression") {
+						context.report({
+							data: { name },
+							messageId: "nonFunctionExport",
+							node: declarator
+						});
+						continue;
+					}
+					const returnExpressions = ownReturnExpressions(init);
+					const badReturn = returnExpressions.length === 0 ? init : returnExpressions.find((expression) => !looksLikeStringExpression(expression));
+					if (badReturn !== void 0) context.report({
+						data: { name },
+						messageId: "nonStringReturn",
+						node: badReturn
+					});
+				}
+			}
+		} };
+	},
+	meta: {
+		docs: RULE_DOCS["p2-prompt-file-exports"],
+		messages: {
+			classExport: "Prompt file exports a class — a *.prompt.ts file exports only const string-builder functions and types (P2).",
+			defaultExport: "Prompt file has a default export — a *.prompt.ts file exports only const string-builder functions and types (P2).",
+			nonFunctionExport: "Prompt file export \"{{name}}\" is not a const arrow function — a *.prompt.ts file exports only const string-builder functions and types (P2).",
+			nonStringReturn: "Prompt file export \"{{name}}\" does not appear to return a string (P2)."
+		},
+		type: "problem"
+	}
+};
+//#endregion
+//#region src/lint/fs.ts
+/**
+* Filesystem probe for the one fs-anchored rule (P3 — the sibling check).
+* Mirrors `@jterrazz/test`'s `src/lint/fs-cache.ts` in spirit, minus the
+* memoization: P3 does at most one `existsSync` per visited file, so a cache
+* would add complexity without a measurable payoff at this plugin's size.
+*/
+function fileExists(path) {
+	try {
+		return existsSync(path);
+	} catch {
+		return false;
+	}
+}
+//#endregion
+//#region src/lint/plugin.ts
+/**
+* The `@jterrazz/intelligence` oxlint plugin — formalizes the agent/prompt
+* folder convention documented in the README's "Agent & prompt conventions"
+* section as statically-checkable rules, mirroring `@jterrazz/test`'s
+* `src/lint/plugin.ts` (same composable-fragment architecture, same
+* `RuleTester` test layer, same manifest/docs-as-code pattern).
+*
+* Registered in a consumer's `oxlint.config.ts` via
+* `jsPlugins: ['@jterrazz/intelligence/oxlint']` and referenced as
+* `intelligence/<rule>` in the `rules` map — or enabled wholesale via the
+* {@link intelligence} composable fragment:
+*
+*     import { compose, node } from '@jterrazz/typescript/oxlint';
+*     import { intelligence } from '@jterrazz/intelligence/oxlint';
+*     export default compose(node, intelligence);
+*
+* Bundled by tsdown (`dist/oxlint.js`); rules import nothing from this
+* package's AI SDK runtime (only pure structural helpers: `ast.ts`, `fs.ts`,
+* `agents.ts`), so the bundle stays free of the `ai`/`@ai-sdk/*` dependency
+* graph the main entry pulls in.
+*/
+const plugin = {
+	meta: { name: "intelligence" },
+	rules: {
+		"g1-agent-class-shape": g1AgentClassShape,
+		"m1-model-resolution-in-container": m1ModelResolutionInContainer,
+		"m2w-no-hardcoded-model-id": m2wNoHardcodedModelId,
+		"p1-prose-in-prompt-files": p1ProseInPromptFiles,
+		"p2-prompt-file-exports": p2PromptFileExports,
+		"p3-agent-prompt-sibling": {
+			create(context) {
+				const file = context.physicalFilename;
+				const agent = detectAgentFile(file);
+				const prompt = agent === void 0 ? detectPromptFile(file) : void 0;
+				if (agent === void 0 && prompt === void 0) return {};
+				return { Program(node) {
+					if (agent !== void 0) {
+						const expected = `./${agent.name}.prompt.js`;
+						if (!(node.body ?? []).some((statement) => statement.type === "ImportDeclaration" && stringValue(statement.source) === expected)) context.report({
+							data: { expected },
+							messageId: "missingPromptImport",
+							node
+						});
+						return;
+					}
+					if (prompt !== void 0 && !prompt.shared) {
+						if (!fileExists(join(prompt.dir, `${prompt.name}.ts`))) context.report({
+							data: { name: prompt.name },
+							messageId: "missingAgentSibling",
+							node
+						});
+					}
+				} };
+			},
+			meta: {
+				docs: RULE_DOCS["p3-agent-prompt-sibling"],
+				messages: {
+					missingAgentSibling: "Prompt file \"{{name}}.prompt.ts\" has no sibling agent file \"{{name}}.ts\" in the same directory (P3).",
+					missingPromptImport: "Agent file must import its prompt from \"{{expected}}\" (P3)."
+				},
+				type: "problem"
+			}
+		}
+	}
+};
+/**
+* The full catalogue at its intended severities — spread into an oxlint
+* `rules` map to enable everything in one line:
+*
+*     rules: { ...recommendedRules }
+*
+* Hard conventions are errors; `m2w-*` (the model-id heuristic) is a warning.
+*/
+const recommendedRules = Object.fromEntries(Object.keys(plugin.rules).map((rule) => [`intelligence/${rule}`, /^\w+w-/.test(rule) ? "warn" : "error"]));
+/**
+* The composable fragment — wire the plugin and enable the whole catalogue.
+* Designed to be composed with a base preset (e.g. `@jterrazz/typescript/oxlint`):
+*
+*     import { compose, node } from '@jterrazz/typescript/oxlint';
+*     import { intelligence } from '@jterrazz/intelligence/oxlint';
+*     export default compose(node, intelligence);
+*
+* `jsPlugins` registers the tool-facing entry, `rules` is {@link recommendedRules}.
+* `overrides` ships empty (no per-glob relaxation is needed today — every rule
+* gates itself by file path/name internally) but is kept on the fragment's
+* shape for parity with `@jterrazz/test`'s `testing` fragment and so a future
+* relaxation has somewhere to go without a breaking shape change.
+*/
+const intelligence = {
+	jsPlugins: ["@jterrazz/intelligence/oxlint"],
+	overrides: [],
+	rules: recommendedRules
+};
+//#endregion
+export { plugin as default, intelligence, recommendedRules };
+
+//# sourceMappingURL=oxlint.js.map