@farming-labs/docs 0.2.62 → 0.2.64

package/dist/agent-scope-C_U--OZ7.mjs

@@ -0,0 +1,283 @@
+//#region src/agent-scope.ts
+/** Normalize framework aliases used by page metadata, agent contracts, MCP, and evaluations. */
+function normalizeAgentFramework(value) {
+	const normalized = value.toLowerCase().replace(/[^a-z0-9]/gu, "");
+	if ([
+		"next",
+		"nextjs",
+		"nextjsapp",
+		"reactnext"
+	].includes(normalized)) return "nextjs";
+	if ([
+		"tanstack",
+		"tanstackstart",
+		"start"
+	].includes(normalized)) return "tanstackstart";
+	if (["svelte", "sveltekit"].includes(normalized)) return "sveltekit";
+	if (["nuxt", "nuxtjs"].includes(normalized)) return "nuxt";
+	return normalized;
+}
+function normalizeAgentLocale(value) {
+	return value.trim().toLowerCase().replace(/_/gu, "-");
+}
+function normalizeAgentVersion(value) {
+	return value.trim().toLowerCase().replace(/^v(?=\d)/u, "");
+}
+function normalizeAgentScopeValues(value) {
+	const values = Array.isArray(value) ? value : typeof value === "string" ? [value] : [];
+	return Array.from(new Set(values.map((item) => item.trim()).filter(Boolean)));
+}
+function compareVersions(left, right) {
+	for (let index = 0; index < 3; index += 1) if (left[index] !== right[index]) return left[index] > right[index] ? 1 : -1;
+	return 0;
+}
+function parseExactVersion(value) {
+	const match = normalizeAgentVersion(value).match(/^(\d+)(?:\.(\d+))?(?:\.(\d+))?(?:-[0-9a-z.-]+)?(?:\+[0-9a-z.-]+)?$/iu);
+	if (!match) return void 0;
+	return [
+		Number(match[1]),
+		Number(match[2] ?? 0),
+		Number(match[3] ?? 0)
+	];
+}
+function parseVersionOperand(value) {
+	const normalized = normalizeAgentVersion(value);
+	if (normalized === "*" || normalized === "x") return {
+		version: [
+			0,
+			0,
+			0
+		],
+		components: 0,
+		wildcard: true
+	};
+	const match = normalized.match(/^(\d+)(?:\.(\d+|x|\*))?(?:\.(\d+|x|\*))?$/iu);
+	if (!match) return void 0;
+	const raw = [
+		match[1],
+		match[2],
+		match[3]
+	];
+	const wildcardIndex = raw.findIndex((part, index) => index > 0 && (part?.toLowerCase() === "x" || part === "*"));
+	if (wildcardIndex >= 0 && raw.slice(wildcardIndex + 1).some((part) => part && part.toLowerCase() !== "x" && part !== "*")) return;
+	const components = wildcardIndex >= 0 ? wildcardIndex : raw.filter(Boolean).length;
+	return {
+		version: [
+			Number(raw[0]),
+			Number(raw[1] ?? 0) || 0,
+			Number(raw[2] ?? 0) || 0
+		],
+		components,
+		wildcard: wildcardIndex >= 0
+	};
+}
+function nextVersionBoundary(operand) {
+	const [major, minor] = operand.version;
+	if (operand.components <= 0) return void 0;
+	if (operand.components === 1) return [
+		major + 1,
+		0,
+		0
+	];
+	return [
+		major,
+		minor + 1,
+		0
+	];
+}
+function operandRange(operand) {
+	if (operand.components === 0) return {
+		minimumInclusive: true,
+		maximumInclusive: false
+	};
+	if (operand.components < 3 || operand.wildcard) return {
+		minimum: operand.version,
+		minimumInclusive: true,
+		maximum: nextVersionBoundary(operand),
+		maximumInclusive: false
+	};
+	return {
+		minimum: operand.version,
+		minimumInclusive: true,
+		maximum: operand.version,
+		maximumInclusive: true
+	};
+}
+function caretRange(operand) {
+	const [major, minor, patch] = operand.version;
+	let maximum;
+	if (major > 0) maximum = [
+		major + 1,
+		0,
+		0
+	];
+	else if (operand.components <= 1) maximum = [
+		1,
+		0,
+		0
+	];
+	else if (minor > 0 || operand.components === 2) maximum = [
+		0,
+		minor + 1,
+		0
+	];
+	else maximum = [
+		0,
+		0,
+		patch + 1
+	];
+	return {
+		minimum: operand.version,
+		minimumInclusive: true,
+		maximum,
+		maximumInclusive: false
+	};
+}
+function tildeRange(operand) {
+	const [major, minor] = operand.version;
+	const maximum = operand.components <= 1 ? [
+		major + 1,
+		0,
+		0
+	] : [
+		major,
+		minor + 1,
+		0
+	];
+	return {
+		minimum: operand.version,
+		minimumInclusive: true,
+		maximum,
+		maximumInclusive: false
+	};
+}
+function intersectRanges(left, right) {
+	let minimum = left.minimum;
+	let minimumInclusive = left.minimumInclusive;
+	if (!minimum || right.minimum && compareVersions(right.minimum, minimum) > 0) {
+		minimum = right.minimum;
+		minimumInclusive = right.minimumInclusive;
+	} else if (right.minimum && compareVersions(right.minimum, minimum) === 0) minimumInclusive = minimumInclusive && right.minimumInclusive;
+	let maximum = left.maximum;
+	let maximumInclusive = left.maximumInclusive;
+	if (!maximum || right.maximum && compareVersions(right.maximum, maximum) < 0) {
+		maximum = right.maximum;
+		maximumInclusive = right.maximumInclusive;
+	} else if (right.maximum && compareVersions(right.maximum, maximum) === 0) maximumInclusive = maximumInclusive && right.maximumInclusive;
+	if (minimum && maximum) {
+		const compared = compareVersions(minimum, maximum);
+		if (compared > 0 || compared === 0 && !(minimumInclusive && maximumInclusive)) return void 0;
+	}
+	return {
+		minimum,
+		minimumInclusive,
+		maximum,
+		maximumInclusive
+	};
+}
+function comparatorRange(operator, operand) {
+	if (!operator || operator === "=") return operandRange(operand);
+	if (operator === ">=") return {
+		minimum: operand.version,
+		minimumInclusive: true,
+		maximumInclusive: false
+	};
+	if (operator === ">") {
+		const partialBoundary = operand.components < 3 ? nextVersionBoundary(operand) : void 0;
+		return {
+			minimum: partialBoundary ?? operand.version,
+			minimumInclusive: Boolean(partialBoundary),
+			maximumInclusive: false
+		};
+	}
+	if (operator === "<") return {
+		minimumInclusive: true,
+		maximum: operand.version,
+		maximumInclusive: false
+	};
+	const partialBoundary = operand.components < 3 ? nextVersionBoundary(operand) : void 0;
+	return {
+		minimumInclusive: true,
+		maximum: partialBoundary ?? operand.version,
+		maximumInclusive: !partialBoundary
+	};
+}
+function parseVersionRangeBranch(value) {
+	const branch = normalizeAgentVersion(value).trim();
+	if (!branch) return void 0;
+	const hyphen = branch.match(/^(.+?)\s+-\s+(.+)$/u);
+	if (hyphen) {
+		const minimumOperand = parseVersionOperand(hyphen[1]);
+		const maximumOperand = parseVersionOperand(hyphen[2]);
+		if (!minimumOperand || !maximumOperand) return void 0;
+		const maximumBoundary = maximumOperand.components < 3 ? nextVersionBoundary(maximumOperand) : maximumOperand.version;
+		return intersectRanges({
+			minimum: minimumOperand.version,
+			minimumInclusive: true,
+			maximumInclusive: false
+		}, {
+			minimumInclusive: true,
+			maximum: maximumBoundary,
+			maximumInclusive: maximumOperand.components === 3
+		});
+	}
+	const special = branch.match(/^(\^|~)\s*(.+)$/u);
+	if (special) {
+		const operand = parseVersionOperand(special[2]);
+		if (!operand || operand.components === 0) return void 0;
+		return special[1] === "^" ? caretRange(operand) : tildeRange(operand);
+	}
+	const comparators = Array.from(branch.matchAll(/(>=|<=|>|<|=)\s*([^\s]+)/gu));
+	if (comparators.length > 0) {
+		if (comparators.map((match) => match[0]).join(" ").replace(/\s+/gu, " ") !== branch.replace(/\s+/gu, " ")) return void 0;
+		let range = {
+			minimumInclusive: true,
+			maximumInclusive: false
+		};
+		for (const comparator of comparators) {
+			const operand = parseVersionOperand(comparator[2]);
+			if (!operand) return void 0;
+			const next = intersectRanges(range, comparatorRange(comparator[1], operand));
+			if (!next) return void 0;
+			range = next;
+		}
+		return range;
+	}
+	const operand = parseVersionOperand(branch);
+	return operand ? operandRange(operand) : void 0;
+}
+function parseVersionRanges(value) {
+	return normalizeAgentVersion(value).split("||").map((branch) => parseVersionRangeBranch(branch)).filter((range) => Boolean(range));
+}
+function rangeContains(range, version) {
+	if (range.minimum) {
+		const compared = compareVersions(version, range.minimum);
+		if (compared < 0 || compared === 0 && !range.minimumInclusive) return false;
+	}
+	if (range.maximum) {
+		const compared = compareVersions(version, range.maximum);
+		if (compared > 0 || compared === 0 && !range.maximumInclusive) return false;
+	}
+	return true;
+}
+function rangesOverlap(left, right) {
+	return Boolean(intersectRanges(left, right));
+}
+/** Match an exact requested version against an exact or range-like documented constraint. */
+function agentVersionConstraintMatches(requested, constraint) {
+	if (normalizeAgentVersion(requested) === normalizeAgentVersion(constraint)) return Boolean(normalizeAgentVersion(requested));
+	const wanted = parseExactVersion(requested);
+	if (!wanted) return false;
+	return parseVersionRanges(constraint).some((range) => rangeContains(range, wanted));
+}
+/** Return true when two exact or range-like documented version constraints can select one version. */
+function agentVersionConstraintsOverlap(left, right) {
+	const normalizedLeft = normalizeAgentVersion(left);
+	if (normalizedLeft === normalizeAgentVersion(right)) return Boolean(normalizedLeft);
+	const leftRanges = parseVersionRanges(left);
+	const rightRanges = parseVersionRanges(right);
+	return leftRanges.some((leftRange) => rightRanges.some((rightRange) => rangesOverlap(leftRange, rightRange)));
+}
+
+//#endregion
+export { normalizeAgentScopeValues as a, normalizeAgentLocale as i, agentVersionConstraintsOverlap as n, normalizeAgentVersion as o, normalizeAgentFramework as r, agentVersionConstraintMatches as t };

package/dist/agent-skills-bundle.d.mts

@@ -0,0 +1,13 @@
+import { A as DocsPublishedAgentSkill } from "./standards-discovery-C4HUqMd2.mjs";
+
+//#region src/agent-skills-bundle.d.ts
+/**
+ * Build-time snapshot of configured Agent Skills.
+ *
+ * `docsAgentSkills()` replaces this module in production bundles. The undefined
+ * fallback keeps direct Node usage and development setups on the filesystem
+ * resolver when the build plugin is not installed.
+ */
+declare const bundledAgentSkills: readonly DocsPublishedAgentSkill[] | undefined;
+//#endregion
+export { bundledAgentSkills };

package/dist/agent-skills-bundle.mjs

@@ -0,0 +1,12 @@
+//#region src/agent-skills-bundle.ts
+/**
+* Build-time snapshot of configured Agent Skills.
+*
+* `docsAgentSkills()` replaces this module in production bundles. The undefined
+* fallback keeps direct Node usage and development setups on the filesystem
+* resolver when the build plugin is not installed.
+*/
+const bundledAgentSkills = void 0;
+
+//#endregion
+export { bundledAgentSkills };

package/dist/agent-skills-server-CPja6Syt.d.mts

@@ -0,0 +1,14 @@
+import { A as DocsPublishedAgentSkill } from "./standards-discovery-C4HUqMd2.mjs";
+import { P as DocsAgentSkillsInput } from "./types-lMBIdZg0.mjs";
+
+//#region src/agent-skills-server.d.ts
+interface ResolveConfiguredAgentSkillsOptions {
+  rootDir?: string;
+  workspaceRoot?: string;
+}
+/** Resolve and safely package all project skills configured through `agent.skills` synchronously. */
+declare function resolveConfiguredAgentSkillsSync(input: DocsAgentSkillsInput | undefined, options?: ResolveConfiguredAgentSkillsOptions): DocsPublishedAgentSkill[];
+/** Resolve and package configured skills without blocking runtime filesystem or compression work. */
+declare function resolveConfiguredAgentSkills(input: DocsAgentSkillsInput | undefined, options?: ResolveConfiguredAgentSkillsOptions): Promise<DocsPublishedAgentSkill[]>;
+//#endregion
+export { resolveConfiguredAgentSkills as n, resolveConfiguredAgentSkillsSync as r, ResolveConfiguredAgentSkillsOptions as t };