@tanstack/intent 0.0.34 → 0.0.36

package/README.md

@@ -104,7 +104,7 @@ npx @tanstack/intent@latest setup
 | Node.js + pnpm | Supported   | Use `pnpm dlx @tanstack/intent@latest <command>`   |
 | Node.js + Bun  | Supported   | Use `bunx @tanstack/intent@latest <command>`       |
 | Deno           | Best-effort | Requires `npm:` interop and `node_modules` support |
-| Yarn PnP       | Unsupported | `@tanstack/intent` scans `node_modules`            |
+| Yarn PnP       | Supported   | Uses Yarn's PnP API when `node_modules` is absent  |
 
 ## Monorepos
 

package/dist/cli.mjs

@@ -1,10 +1,10 @@
 #!/usr/bin/env node
-import "./utils-COlDcU72.mjs";
+import { s as toPosixPath } from "./utils-COlDcU72.mjs";
 import { n as findWorkspacePackages } from "./workspace-patterns-BN2A_60g.mjs";
 import { i as parseSkillUse } from "./skill-use-BzuuvLM7.mjs";
 import { r as resolveSkillUse } from "./resolver-Whd12ksO.mjs";
 import { t as resolveProjectContext } from "./project-context-alYMNoNa.mjs";
-import { a as scanIntentsOrFail, c as fail, i as resolveStaleTargets, l as isCliFailure, n as runInstallCommand, o as scanOptionsFromGlobalFlags, r as getMetaDir, s as printWarnings } from "./install-QjryhQtg.mjs";
+import { a as scanIntentsOrFail, c as fail, i as resolveStaleTargets, l as isCliFailure, n as runInstallCommand, o as scanOptionsFromGlobalFlags, r as getMetaDir, s as printWarnings } from "./install-2_wkomiT.mjs";
 import { appendFileSync, existsSync, readFileSync, readdirSync, realpathSync } from "node:fs";
 import { basename, dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
 import { fileURLToPath } from "node:url";
@@ -99,6 +99,205 @@ function isPathInsidePackageRoot(path, packageRoot) {
 	const relativePath = relative(resolveFromCwd(packageRoot), resolveFromCwd(path));
 	return relativePath === "" || !relativePath.startsWith("..") && !isAbsolute(relativePath);
 }
+function splitDestinationSuffix(destination) {
+	const hashIndex = destination.indexOf("#");
+	const queryIndex = destination.indexOf("?");
+	const suffixIndex = hashIndex === -1 ? queryIndex : queryIndex === -1 ? hashIndex : Math.min(hashIndex, queryIndex);
+	if (suffixIndex === -1) return {
+		pathPart: destination,
+		suffix: ""
+	};
+	return {
+		pathPart: destination.slice(0, suffixIndex),
+		suffix: destination.slice(suffixIndex)
+	};
+}
+function isExternalOrAbsoluteDestination(destination) {
+	return destination === "" || destination.startsWith("#") || destination.startsWith("?") || destination.startsWith("//") || /^[A-Za-z][A-Za-z0-9+.-]*:/.test(destination) || isAbsolute(destination);
+}
+function findClosingBracket(line, start) {
+	let depth = 0;
+	for (let index = start; index < line.length; index++) {
+		const char = line[index];
+		if (char === "\\") {
+			index++;
+			continue;
+		}
+		if (char === "[") {
+			depth++;
+			continue;
+		}
+		if (char === "]") {
+			depth--;
+			if (depth === 0) return index;
+		}
+	}
+	return -1;
+}
+function findClosingParen(line, start) {
+	for (let index = start; index < line.length; index++) {
+		const char = line[index];
+		if (char === "\\") {
+			index++;
+			continue;
+		}
+		if (char === ")") return index;
+	}
+	return -1;
+}
+function readBareDestination(line, start) {
+	let depth = 0;
+	for (let index = start; index < line.length; index++) {
+		const char = line[index];
+		if (char === "\\") {
+			index++;
+			continue;
+		}
+		if (char === "(") {
+			depth++;
+			continue;
+		}
+		if (char === ")") {
+			if (depth === 0) return {
+				destinationEnd: index,
+				endParen: index
+			};
+			depth--;
+			continue;
+		}
+		if (/\s/.test(char) && depth === 0) {
+			const endParen = findClosingParen(line, index);
+			if (endParen === -1) return null;
+			return {
+				destinationEnd: index,
+				endParen
+			};
+		}
+	}
+	return null;
+}
+function readMarkdownDestination(line, start) {
+	let cursor = start;
+	while (cursor < line.length && /\s/.test(line[cursor])) cursor++;
+	if (line[cursor] === "<") {
+		const destinationStart = cursor + 1;
+		const destinationEnd = line.indexOf(">", destinationStart);
+		if (destinationEnd === -1) return null;
+		const endParen = findClosingParen(line, destinationEnd + 1);
+		if (endParen === -1) return null;
+		return {
+			destination: line.slice(destinationStart, destinationEnd),
+			destinationStart,
+			destinationEnd,
+			endParen
+		};
+	}
+	const read = readBareDestination(line, cursor);
+	if (!read) return null;
+	return {
+		destination: line.slice(cursor, read.destinationEnd),
+		destinationStart: cursor,
+		destinationEnd: read.destinationEnd,
+		endParen: read.endParen
+	};
+}
+function getCodeFenceMarker(line) {
+	const marker = line.match(/^\s*(`{3,}|~{3,})/)?.[1]?.[0];
+	return marker === "`" || marker === "~" ? marker : null;
+}
+function rewriteMarkdownDestination({ context, destination }) {
+	if (isExternalOrAbsoluteDestination(destination)) return destination;
+	const { pathPart, suffix } = splitDestinationSuffix(destination);
+	if (isExternalOrAbsoluteDestination(pathPart)) return destination;
+	const resolvedDestinationPath = resolve(context.skillDir, pathPart);
+	const relativeToPackageRoot = relative(context.resolvedPackageRoot, resolvedDestinationPath);
+	if (relativeToPackageRoot.startsWith("..") || isAbsolute(relativeToPackageRoot)) return destination;
+	const relativeToCwd = relative(context.cwd, resolvedDestinationPath);
+	return `${toPosixPath(relativeToCwd && !relativeToCwd.startsWith("..") && !isAbsolute(relativeToCwd) ? relativeToCwd : resolvedDestinationPath)}${suffix}`;
+}
+function rewriteMarkdownLineDestinations({ context, line }) {
+	if (!line.includes("[")) return line;
+	let output = "";
+	let cursor = 0;
+	while (cursor < line.length) {
+		const nextCodeStart = line.indexOf("`", cursor);
+		const nextLinkStart = line.indexOf("[", cursor);
+		if (nextLinkStart === -1) {
+			output += line.slice(cursor);
+			break;
+		}
+		if (nextCodeStart !== -1 && nextCodeStart < nextLinkStart) {
+			output += line.slice(cursor, nextCodeStart);
+			cursor = nextCodeStart;
+			const codeStart = cursor;
+			while (cursor < line.length && line[cursor] === "`") cursor++;
+			const marker = line.slice(codeStart, cursor);
+			const codeEnd = line.indexOf(marker, cursor);
+			if (codeEnd === -1) {
+				output += line.slice(codeStart);
+				break;
+			}
+			output += line.slice(codeStart, codeEnd + marker.length);
+			cursor = codeEnd + marker.length;
+			continue;
+		}
+		const linkStart = nextLinkStart > 0 && line[nextLinkStart - 1] === "!" ? nextLinkStart - 1 : nextLinkStart;
+		output += line.slice(cursor, linkStart);
+		const labelEnd = findClosingBracket(line, nextLinkStart);
+		if (labelEnd === -1) {
+			output += line.slice(linkStart);
+			break;
+		}
+		if (line[labelEnd + 1] !== "(") {
+			output += line.slice(linkStart, nextLinkStart + 1);
+			cursor = nextLinkStart + 1;
+			continue;
+		}
+		const destination = readMarkdownDestination(line, labelEnd + 2);
+		if (!destination) {
+			output += line.slice(linkStart, nextLinkStart + 1);
+			cursor = nextLinkStart + 1;
+			continue;
+		}
+		const rewritten = rewriteMarkdownDestination({
+			context,
+			destination: destination.destination
+		});
+		output += line.slice(linkStart, destination.destinationStart) + rewritten + line.slice(destination.destinationEnd, destination.endParen + 1);
+		cursor = destination.endParen + 1;
+	}
+	return output;
+}
+function rewriteLoadedSkillMarkdownDestinations({ content, packageRoot, skillFilePath }) {
+	const context = {
+		cwd: process.cwd(),
+		resolvedPackageRoot: resolveFromCwd(packageRoot),
+		skillDir: dirname(skillFilePath)
+	};
+	let inFence = null;
+	const parts = content.split(/(\r?\n)/);
+	let output = "";
+	for (let index = 0; index < parts.length; index += 2) {
+		const line = parts[index] ?? "";
+		const newline = parts[index + 1] ?? "";
+		const marker = getCodeFenceMarker(line);
+		if (inFence) {
+			output += line + newline;
+			if (marker === inFence) inFence = null;
+			continue;
+		}
+		if (marker) {
+			inFence = marker;
+			output += line + newline;
+			continue;
+		}
+		output += rewriteMarkdownLineDestinations({
+			context,
+			line
+		}) + newline;
+	}
+	return output;
+}
 async function runLoadCommand(use, options, scanIntentsOrFail$1) {
 	if (!use) fail("Missing skill use. Expected: intent load <package>#<skill>");
 	if (options.json && options.path) fail("Use either --json or --path, not both.");
@@ -112,7 +311,11 @@ async function runLoadCommand(use, options, scanIntentsOrFail$1) {
 		for (const warning of resolved.warnings) console.error(`Warning: ${warning}`);
 		return;
 	}
-	const content = readFileSync(resolvedPath, "utf8");
+	const content = rewriteLoadedSkillMarkdownDestinations({
+		content: readFileSync(resolvedPath, "utf8"),
+		packageRoot: resolved.packageRoot,
+		skillFilePath: resolvedPath
+	});
 	if (options.json) {
 		console.log(JSON.stringify({
 			package: resolved.packageName,

package/dist/index.mjs

@@ -1,6 +1,6 @@
 import { a as parseFrontmatter, n as findSkillFiles, o as resolveDepDir, r as getDeps } from "./utils-COlDcU72.mjs";
 import "./skill-paths-8k9K9y26.mjs";
-import { t as scanForIntents } from "./scanner-Dav1tzQK.mjs";
+import { t as scanForIntents } from "./scanner-B1j-wDhj.mjs";
 import "./workspace-patterns-BN2A_60g.mjs";
 import { t as readIntentArtifacts } from "./artifact-coverage-wLNVX8yC.mjs";
 import { n as checkStaleness } from "./staleness-PdgakrCQ.mjs";

package/dist/{install-QjryhQtg.mjs → install-2_wkomiT.mjs}

@@ -46,7 +46,7 @@ function getCheckSkillsWorkflowAdvisories(root) {
 	return [`Intent workflow update available: run \`npx @tanstack/intent@latest setup\` to refresh ${relative(process.cwd(), workflowPath) || workflowPath}.`];
 }
 async function scanIntentsOrFail(options) {
-	const { scanForIntents } = await import("./scanner-BAZxWeUk.mjs");
+	const { scanForIntents } = await import("./scanner-C2YjF4w_.mjs");
 	try {
 		return scanForIntents(void 0, options);
 	} catch (err) {

package/dist/intent-library.mjs

@@ -3,7 +3,7 @@ import "./utils-COlDcU72.mjs";
 import "./skill-paths-8k9K9y26.mjs";
 import "./workspace-patterns-BN2A_60g.mjs";
 import "./project-context-alYMNoNa.mjs";
-import { t as INSTALL_PROMPT } from "./install-QjryhQtg.mjs";
+import { t as INSTALL_PROMPT } from "./install-2_wkomiT.mjs";
 import { n as printSkillTree, r as printTable, t as computeSkillNameWidth } from "./display-CAof6doy.mjs";
 import { t as scanLibrary } from "./library-scanner-fexXlPXb.mjs";
 

package/dist/{scanner-Dav1tzQK.mjs → scanner-B1j-wDhj.mjs}

@@ -352,7 +352,6 @@ function scanForIntents(root, options = {}) {
 	const projectRoot = root ?? process.cwd();
 	const scanScope = getScanScope(options);
 	const packageManager = detectPackageManager(projectRoot);
-	const pnpApi = scanScope === "global" ? null : loadPnpApi(projectRoot);
 	const nodeModulesDir = join(projectRoot, "node_modules");
 	const explicitGlobalNodeModules = process.env.INTENT_GLOBAL_NODE_MODULES?.trim() || null;
 	const packages = [];
@@ -376,6 +375,12 @@ function scanForIntents(root, options = {}) {
 	const packageIndexes = /* @__PURE__ */ new Map();
 	const packageJsonCache = /* @__PURE__ */ new Map();
 	const packageVariants = /* @__PURE__ */ new Map();
+	let pnpApi;
+	function getPnpApi() {
+		if (scanScope === "global") return null;
+		if (pnpApi === void 0) pnpApi = loadPnpApi(projectRoot);
+		return pnpApi;
+	}
 	function rememberVariant(pkg) {
 		let variants = packageVariants.get(pkg.name);
 		if (!variants) {
@@ -427,9 +432,7 @@ function scanForIntents(root, options = {}) {
 		tryRegister,
 		warnings
 	});
-	function scanPnpPackages() {
-		if (!pnpApi) return;
-		const api = pnpApi;
+	function scanPnpPackages(api) {
 		const visited = /* @__PURE__ */ new Set();
 		const workspaceRoot = findWorkspaceRoot(projectRoot);
 		const projectLocator = api.findPackageLocator?.(projectRoot.endsWith(sep) ? projectRoot : `${projectRoot}${sep}`);
@@ -449,9 +452,12 @@ function scanForIntents(root, options = {}) {
 		for (const locator of roots) visit(locator);
 	}
 	function scanLocalPackages() {
-		if (pnpApi && !nodeModules.local.exists) {
-			scanPnpPackages();
-			return;
+		if (!nodeModules.local.exists) {
+			const api = getPnpApi();
+			if (api) {
+				scanPnpPackages(api);
+				return;
+			}
 		}
 		assertLocalNodeModulesSupported(projectRoot);
 		scanTarget(nodeModules.local);

package/dist/{scanner-BAZxWeUk.mjs → scanner-C2YjF4w_.mjs}

@@ -1,6 +1,6 @@
 import "./utils-COlDcU72.mjs";
 import "./skill-paths-8k9K9y26.mjs";
-import { t as scanForIntents } from "./scanner-Dav1tzQK.mjs";
+import { t as scanForIntents } from "./scanner-B1j-wDhj.mjs";
 import "./workspace-patterns-BN2A_60g.mjs";
 
 export { scanForIntents };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tanstack/intent",
-  "version": "0.0.34",
+  "version": "0.0.36",
   "description": "Ship compositional knowledge for AI coding agents alongside your npm packages",
   "license": "MIT",
   "type": "module",