@tanstack/intent 0.0.35 → 0.0.36

package/dist/cli.mjs

@@ -1,5 +1,5 @@
 #!/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";
@@ -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/package.json

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