@tanstack/intent 0.0.29 → 0.0.33

package/dist/intent-library.mjs

@@ -1,14 +1,17 @@
 #!/usr/bin/env node
 import "./utils-COlDcU72.mjs";
-import { t as INSTALL_PROMPT } from "./install-BzDmD5yI.mjs";
-import { n as printSkillTree, r as printTable, t as computeSkillNameWidth } from "./display-hdsqb4w-.mjs";
-import { t as scanLibrary } from "./library-scanner-B51qV5aX.mjs";
+import "./skill-paths-8k9K9y26.mjs";
+import "./workspace-patterns-BN2A_60g.mjs";
+import "./project-context-IDLpJU3S.mjs";
+import { t as INSTALL_PROMPT } from "./install-PUnIfBNC.mjs";
+import { n as printSkillTree, r as printTable, t as computeSkillNameWidth } from "./display-BTZWCjzT.mjs";
+import { t as scanLibrary } from "./library-scanner-Cl-XPEMf.mjs";
 
 //#region src/intent-library.ts
 function cmdList() {
 	let result;
 	try {
-		result = scanLibrary(process.argv[1]);
+		result = scanLibrary(process.argv[1], process.cwd());
 	} catch (err) {
 		console.error(err.message);
 		process.exit(1);
@@ -39,6 +42,7 @@ function cmdList() {
 		console.log(`  ${pkg.name}`);
 		printSkillTree(pkg.skills, {
 			nameWidth,
+			packageName: pkg.name,
 			showTypes
 		});
 		console.log();
@@ -60,7 +64,7 @@ const USAGE = `TanStack Intent
 Usage:
   intent list        List all available skills from this library and its dependencies
   intent install     Print a skill that guides your coding agent to scan the project
-                     and set up skill-to-task mappings in your agent config`;
+                     and set up skill loading guidance in your agent config`;
 const command = process.argv[2];
 switch (command) {
 	case "list":

package/dist/{library-scanner-B51qV5aX.mjs → library-scanner-Cl-XPEMf.mjs}

@@ -1,4 +1,5 @@
 import { a as parseFrontmatter, o as resolveDepDir, r as getDeps, s as toPosixPath } from "./utils-COlDcU72.mjs";
+import { r as rewriteSkillLoadPaths } from "./skill-paths-8k9K9y26.mjs";
 import { existsSync, readFileSync, readdirSync } from "node:fs";
 import { dirname, join, relative } from "node:path";
 
@@ -52,14 +53,14 @@ function discoverSkills(skillsDir) {
 					type: typeof fm?.type === "string" ? fm.type : void 0,
 					framework: typeof fm?.framework === "string" ? fm.framework : void 0
 				});
-				walk(childDir);
 			}
+			walk(childDir);
 		}
 	}
 	walk(skillsDir);
 	return skills;
 }
-function scanLibrary(scriptPath, _projectRoot) {
+function scanLibrary(scriptPath, projectRoot) {
 	const packages = [];
 	const warnings = [];
 	const visited = /* @__PURE__ */ new Set();
@@ -74,6 +75,7 @@ function scanLibrary(scriptPath, _projectRoot) {
 		warnings: ["Could not read home package.json"]
 	};
 	const homeName = typeof homePkg.name === "string" ? homePkg.name : "";
+	const scanRoot = projectRoot ?? homeDir;
 	function processPackage(name, dir) {
 		if (visited.has(name)) return;
 		visited.add(name);
@@ -84,7 +86,12 @@ function scanLibrary(scriptPath, _projectRoot) {
 		}
 		const skillsDir = join(dir, "skills");
 		const skills = existsSync(skillsDir) ? discoverSkills(skillsDir) : [];
-		if (name) for (const skill of skills) skill.path = `node_modules/${name}/${toPosixPath(relative(dir, skill.path))}`;
+		rewriteSkillLoadPaths({
+			packageName: name,
+			packageRoot: dir,
+			projectRoot: scanRoot,
+			skills
+		});
 		packages.push({
 			name,
 			version: typeof pkg.version === "string" ? pkg.version : "0.0.0",

package/dist/library-scanner.d.mts

@@ -1,4 +1,4 @@
-import { l as SkillEntry } from "./types-BTQ9efv-.mjs";
+import { h as SkillEntry } from "./types-_y9b00bI.mjs";
 
 //#region src/library-scanner.d.ts
 interface LibraryPackage {
@@ -11,6 +11,6 @@ interface LibraryScanResult {
   packages: Array<LibraryPackage>;
   warnings: Array<string>;
 }
-declare function scanLibrary(scriptPath: string, _projectRoot?: string): LibraryScanResult;
+declare function scanLibrary(scriptPath: string, projectRoot?: string): LibraryScanResult;
 //#endregion
 export { LibraryPackage, LibraryScanResult, scanLibrary };

package/dist/library-scanner.mjs

@@ -1,4 +1,5 @@
 import "./utils-COlDcU72.mjs";
-import { t as scanLibrary } from "./library-scanner-B51qV5aX.mjs";
+import "./skill-paths-8k9K9y26.mjs";
+import { t as scanLibrary } from "./library-scanner-Cl-XPEMf.mjs";
 
 export { scanLibrary };

package/dist/{project-context-D6A5sBBO.mjs → project-context-IDLpJU3S.mjs}

@@ -1,4 +1,4 @@
-import { n as findWorkspaceRoot, r as readWorkspacePatterns } from "./workspace-patterns-Cndd-7vB.mjs";
+import { i as readWorkspacePatterns, r as findWorkspaceRoot } from "./workspace-patterns-BN2A_60g.mjs";
 import { existsSync, statSync } from "node:fs";
 import { dirname, join, relative, resolve } from "node:path";
 

package/dist/resolver-D2CgIYGg.mjs

@@ -0,0 +1,70 @@
+import { i as parseSkillUse } from "./skill-use-uwGleSOz.mjs";
+
+//#region src/resolver.ts
+var ResolveSkillUseError = class extends Error {
+	constructor({ availablePackages = [], availableSkills = [], code, packageName, skillName, use }) {
+		super(formatResolveSkillUseErrorMessage({
+			availablePackages,
+			availableSkills,
+			code,
+			packageName,
+			skillName,
+			use
+		}));
+		this.name = "ResolveSkillUseError";
+		this.availablePackages = availablePackages;
+		this.availableSkills = availableSkills;
+		this.code = code;
+		this.packageName = packageName;
+		this.skillName = skillName;
+		this.use = use;
+	}
+};
+function isResolveSkillUseError(error) {
+	return error instanceof ResolveSkillUseError;
+}
+function resolveSkillUse(use, scanResult) {
+	const { packageName, skillName } = parseSkillUse(use);
+	const packages = scanResult.packages.filter((pkg$1) => pkg$1.name === packageName);
+	const pkg = packages.find((candidate) => candidate.source === "local") ?? packages[0];
+	if (!pkg) throw new ResolveSkillUseError({
+		availablePackages: scanResult.packages.map((candidate) => candidate.name),
+		code: "package-not-found",
+		packageName,
+		skillName,
+		use
+	});
+	const skill = pkg.skills.find((candidate) => candidate.name === skillName);
+	if (!skill) throw new ResolveSkillUseError({
+		availableSkills: pkg.skills.map((candidate) => candidate.name),
+		code: "skill-not-found",
+		packageName,
+		skillName,
+		use
+	});
+	const conflict = scanResult.conflicts.find((candidate) => candidate.packageName === packageName) ?? null;
+	return {
+		packageName,
+		skillName,
+		path: skill.path,
+		source: pkg.source,
+		version: pkg.version,
+		packageRoot: pkg.packageRoot,
+		warnings: scanResult.warnings.filter((warning) => {
+			const idx = warning.indexOf(packageName);
+			if (idx === -1) return false;
+			const after = warning[idx + packageName.length];
+			return after === void 0 || /[^a-zA-Z0-9_-]/.test(after);
+		}),
+		conflict
+	};
+}
+function formatResolveSkillUseErrorMessage({ availablePackages, availableSkills, code, packageName, skillName, use }) {
+	switch (code) {
+		case "package-not-found": return `Cannot resolve skill use "${use}": package "${packageName}" was not found.${availablePackages.length > 0 ? ` Available packages: ${availablePackages.join(", ")}.` : ""}`;
+		case "skill-not-found": return `Cannot resolve skill use "${use}": skill "${skillName}" was not found in package "${packageName}".${availableSkills.length > 0 ? ` Available skills: ${availableSkills.join(", ")}.` : ""}`;
+	}
+}
+
+//#endregion
+export { isResolveSkillUseError as n, resolveSkillUse as r, ResolveSkillUseError as t };

package/dist/{scanner-B-bbXBLY.mjs → scanner-CW59cxE_.mjs}

@@ -1,8 +1,136 @@
 import { a as parseFrontmatter, i as listNodeModulesPackageDirs, o as resolveDepDir, r as getDeps, s as toPosixPath, t as detectGlobalNodeModules } from "./utils-COlDcU72.mjs";
-import { i as resolveWorkspacePackages, n as findWorkspaceRoot, r as readWorkspacePatterns } from "./workspace-patterns-Cndd-7vB.mjs";
+import { r as rewriteSkillLoadPaths } from "./skill-paths-8k9K9y26.mjs";
+import { a as resolveWorkspacePackages, i as readWorkspacePatterns, r as findWorkspaceRoot } from "./workspace-patterns-BN2A_60g.mjs";
 import { existsSync, readFileSync, readdirSync } from "node:fs";
 import { join, relative, sep } from "node:path";
 
+//#region src/discovery/register.ts
+function isLocalToProject(dirPath, projectRoot) {
+	return dirPath.startsWith(projectRoot + sep) || dirPath.startsWith(projectRoot + "/");
+}
+function createPackageRegistrar(opts) {
+	function scanTarget(target, source = "local") {
+		if (!target.path || !target.exists || target.scanned) return;
+		target.scanned = true;
+		for (const dirPath of listNodeModulesPackageDirs(target.path)) tryRegister(dirPath, "unknown", source);
+	}
+	function tryRegister(dirPath, fallbackName, source = "local") {
+		const skillsDir = join(dirPath, "skills");
+		if (!existsSync(skillsDir)) return false;
+		const pkgJson = opts.readPkgJson(dirPath);
+		if (!pkgJson) {
+			opts.warnings.push(`Could not read package.json for ${dirPath}`);
+			return false;
+		}
+		const name = typeof pkgJson.name === "string" ? pkgJson.name : fallbackName;
+		const version = typeof pkgJson.version === "string" ? pkgJson.version : "0.0.0";
+		const intent = opts.validateIntentField(name, pkgJson.intent) ?? opts.deriveIntentConfig(pkgJson);
+		if (!intent) {
+			opts.warnings.push(`${name} has a skills/ directory but could not determine repo/docs from package.json (add a "repository" field or explicit "intent" config)`);
+			return false;
+		}
+		const skills = opts.discoverSkills(skillsDir, name);
+		if (isLocalToProject(dirPath, opts.projectRoot)) rewriteSkillLoadPaths({
+			packageName: name,
+			packageRoot: dirPath,
+			projectRoot: opts.projectRoot,
+			skills
+		});
+		const candidate = {
+			name,
+			version,
+			intent,
+			skills,
+			packageRoot: dirPath,
+			source
+		};
+		const existingIndex = opts.packageIndexes.get(name);
+		if (existingIndex === void 0) {
+			opts.rememberVariant(candidate);
+			opts.packageIndexes.set(name, opts.packages.push(candidate) - 1);
+			return true;
+		}
+		const existing = opts.packages[existingIndex];
+		if (existing.packageRoot === candidate.packageRoot) return false;
+		opts.rememberVariant(existing);
+		opts.rememberVariant(candidate);
+		const existingDepth = opts.getPackageDepth(existing.packageRoot, opts.projectRoot);
+		const candidateDepth = opts.getPackageDepth(candidate.packageRoot, opts.projectRoot);
+		if (candidateDepth < existingDepth || candidateDepth === existingDepth && opts.comparePackageVersions(candidate.version, existing.version) > 0) opts.packages[existingIndex] = candidate;
+		return true;
+	}
+	return {
+		scanTarget,
+		tryRegister
+	};
+}
+
+//#endregion
+//#region src/discovery/walk.ts
+function createDependencyWalker(opts) {
+	const walkVisited = /* @__PURE__ */ new Set();
+	const depDirCache = /* @__PURE__ */ new Map();
+	function resolveDepDirCached(depName, fromDir) {
+		let byDepName = depDirCache.get(fromDir);
+		if (!byDepName) {
+			byDepName = /* @__PURE__ */ new Map();
+			depDirCache.set(fromDir, byDepName);
+		}
+		if (!byDepName.has(depName)) byDepName.set(depName, resolveDepDir(depName, fromDir));
+		return byDepName.get(depName) ?? null;
+	}
+	function walkDepsOf(pkgJson, fromDir, includeDevDeps = false) {
+		for (const depName of getDeps(pkgJson, includeDevDeps)) {
+			const depDir = resolveDepDirCached(depName, fromDir);
+			if (!depDir || walkVisited.has(depDir)) continue;
+			opts.tryRegister(depDir, depName);
+			walkDeps(depDir, depName);
+		}
+	}
+	function walkDeps(pkgDir, pkgName) {
+		if (walkVisited.has(pkgDir)) return;
+		walkVisited.add(pkgDir);
+		const pkgJson = opts.readPkgJson(pkgDir);
+		if (!pkgJson) {
+			opts.warnings.push(`Could not read package.json for ${pkgName} (skipping dependency walk)`);
+			return;
+		}
+		walkDepsOf(pkgJson, pkgDir);
+	}
+	function walkKnownPackages() {
+		for (const pkg of [...opts.packages]) walkDeps(pkg.packageRoot, pkg.name);
+	}
+	function walkProjectDeps() {
+		const projectPkg = readPkgJsonWithWarning(opts.projectRoot, "project");
+		if (!projectPkg) return;
+		walkDepsOf(projectPkg, opts.projectRoot, true);
+	}
+	function readPkgJsonWithWarning(dirPath, label) {
+		try {
+			return JSON.parse(readFileSync(join(dirPath, "package.json"), "utf8"));
+		} catch (err) {
+			if (err.code !== "ENOENT") opts.warnings.push(`Could not read ${label} package.json at ${dirPath}: ${err.message}`);
+			return null;
+		}
+	}
+	function walkWorkspacePackages() {
+		const workspacePatterns = readWorkspacePatterns(opts.projectRoot);
+		if (!workspacePatterns) return;
+		for (const wsDir of resolveWorkspacePackages(opts.projectRoot, workspacePatterns)) {
+			const wsNodeModules = join(wsDir, "node_modules");
+			if (existsSync(wsNodeModules)) for (const dirPath of listNodeModulesPackageDirs(wsNodeModules)) opts.tryRegister(dirPath, "unknown");
+			const wsPkg = readPkgJsonWithWarning(wsDir, "workspace");
+			if (wsPkg) walkDepsOf(wsPkg, wsDir);
+		}
+	}
+	return {
+		walkKnownPackages,
+		walkProjectDeps,
+		walkWorkspacePackages
+	};
+}
+
+//#endregion
 //#region src/scanner.ts
 function detectPackageManager(root) {
 	if (existsSync(join(root, ".pnp.cjs")) || existsSync(join(root, ".pnp.js"))) throw new Error("Yarn PnP is not yet supported. Add `nodeLinker: node-modules` to your .yarnrc.yml to use intent.");
@@ -83,8 +211,8 @@ function discoverSkills(skillsDir, _baseName) {
 					type: typeof fm?.type === "string" ? fm.type : void 0,
 					framework: typeof fm?.framework === "string" ? fm.framework : void 0
 				});
-				walk(childDir);
 			}
+			walk(childDir);
 		}
 	}
 	walk(skillsDir);
@@ -169,8 +297,12 @@ function toVersionConflict(packageName, variants, chosen) {
 		variants
 	};
 }
-function scanForIntents(root) {
+function getScanScope(options) {
+	return options.scope ?? (options.includeGlobal ? "local-and-global" : "local");
+}
+function scanForIntents(root, options = {}) {
 	const projectRoot = root ?? process.cwd();
+	const scanScope = getScanScope(options);
 	const packageManager = detectPackageManager(projectRoot);
 	const nodeModulesDir = join(projectRoot, "node_modules");
 	const explicitGlobalNodeModules = process.env.INTENT_GLOBAL_NODE_MODULES?.trim() || null;
@@ -226,123 +358,50 @@ function scanForIntents(root) {
 			return null;
 		}
 	}
-	function scanTarget(target) {
-		if (!target.path || !target.exists || target.scanned) return;
-		target.scanned = true;
-		for (const dirPath of listNodeModulesPackageDirs(target.path)) tryRegister(dirPath, "unknown");
-	}
-	/**
-	* Try to register a package with a skills/ directory. Reads its
-	* package.json, validates intent config, discovers skills, and pushes
-	* to `packages`. Returns true if the package was registered.
-	*/
-	function tryRegister(dirPath, fallbackName) {
-		const skillsDir = join(dirPath, "skills");
-		if (!existsSync(skillsDir)) return false;
-		const pkgJson = readPkgJson(dirPath);
-		if (!pkgJson) {
-			warnings.push(`Could not read package.json for ${dirPath}`);
-			return false;
-		}
-		const name = typeof pkgJson.name === "string" ? pkgJson.name : fallbackName;
-		const version = typeof pkgJson.version === "string" ? pkgJson.version : "0.0.0";
-		const intent = validateIntentField(name, pkgJson.intent) ?? deriveIntentConfig(pkgJson);
-		if (!intent) {
-			warnings.push(`${name} has a skills/ directory but could not determine repo/docs from package.json (add a "repository" field or explicit "intent" config)`);
-			return false;
-		}
-		const skills = discoverSkills(skillsDir, name);
-		if (dirPath.startsWith(projectRoot + sep) || dirPath.startsWith(projectRoot + "/")) {
-			const hasStableSymlink = name !== "" && existsSync(join(projectRoot, "node_modules", name));
-			for (const skill of skills) if (hasStableSymlink) skill.path = `node_modules/${name}/${toPosixPath(relative(dirPath, skill.path))}`;
-			else skill.path = toPosixPath(relative(projectRoot, skill.path));
-		}
-		const candidate = {
-			name,
-			version,
-			intent,
-			skills,
-			packageRoot: dirPath
-		};
-		const existingIndex = packageIndexes.get(name);
-		if (existingIndex === void 0) {
-			rememberVariant(candidate);
-			packageIndexes.set(name, packages.push(candidate) - 1);
-			return true;
-		}
-		const existing = packages[existingIndex];
-		if (existing.packageRoot === candidate.packageRoot) return false;
-		rememberVariant(existing);
-		rememberVariant(candidate);
-		const existingDepth = getPackageDepth(existing.packageRoot, projectRoot);
-		const candidateDepth = getPackageDepth(candidate.packageRoot, projectRoot);
-		if (candidateDepth < existingDepth || candidateDepth === existingDepth && comparePackageVersions(candidate.version, existing.version) > 0) packages[existingIndex] = candidate;
-		return true;
-	}
-	scanTarget(nodeModules.local);
-	const walkVisited = /* @__PURE__ */ new Set();
-	function walkDeps(pkgDir, pkgName) {
-		if (walkVisited.has(pkgDir)) return;
-		walkVisited.add(pkgDir);
-		const pkgJson = readPkgJson(pkgDir);
-		if (!pkgJson) {
-			warnings.push(`Could not read package.json for ${pkgName} (skipping dependency walk)`);
-			return;
-		}
-		for (const depName of getDeps(pkgJson)) {
-			const depDir = resolveDepDir(depName, pkgDir);
-			if (!depDir || walkVisited.has(depDir)) continue;
-			tryRegister(depDir, depName);
-			walkDeps(depDir, depName);
-		}
-	}
-	function walkKnownPackages() {
-		for (const pkg of [...packages]) walkDeps(pkg.packageRoot, pkg.name);
-	}
-	function walkProjectDeps() {
-		let projectPkg = null;
-		try {
-			projectPkg = JSON.parse(readFileSync(join(projectRoot, "package.json"), "utf8"));
-		} catch (err) {
-			if (!(err && typeof err === "object" && "code" in err && err.code === "ENOENT")) warnings.push(`Could not read project package.json: ${err instanceof Error ? err.message : String(err)}`);
-		}
-		if (!projectPkg) return;
-		walkDepsFromPkgJson(projectPkg, projectRoot, true);
-	}
-	/** Resolve and walk deps listed in a package.json. */
-	function walkDepsFromPkgJson(pkgJson, fromDir, includeDevDeps = false) {
-		for (const depName of getDeps(pkgJson, includeDevDeps)) {
-			const depDir = resolveDepDir(depName, fromDir);
-			if (depDir && !walkVisited.has(depDir)) {
-				tryRegister(depDir, depName);
-				walkDeps(depDir, depName);
-			}
-		}
-	}
-	/**
-	* In monorepos, discover workspace packages and walk their deps.
-	* Handles pnpm monorepos (workspace-specific node_modules) and ensures
-	* transitive skills packages are found through workspace package dependencies.
-	*/
-	function walkWorkspacePackages() {
-		const workspacePatterns = readWorkspacePatterns(projectRoot);
-		if (!workspacePatterns) return;
-		for (const wsDir of resolveWorkspacePackages(projectRoot, workspacePatterns)) {
-			const wsNodeModules = join(wsDir, "node_modules");
-			if (existsSync(wsNodeModules)) for (const dirPath of listNodeModulesPackageDirs(wsNodeModules)) tryRegister(dirPath, "unknown");
-			const wsPkg = readPkgJson(wsDir);
-			if (wsPkg) walkDepsFromPkgJson(wsPkg, wsDir);
-		}
-	}
-	walkWorkspacePackages();
-	walkKnownPackages();
-	walkProjectDeps();
-	if (explicitGlobalNodeModules || packages.length === 0 || !nodeModules.local.exists) {
-		ensureGlobalNodeModules();
-		scanTarget(nodeModules.global);
+	const { scanTarget, tryRegister } = createPackageRegistrar({
+		comparePackageVersions,
+		deriveIntentConfig,
+		discoverSkills,
+		getPackageDepth,
+		packageIndexes,
+		packages,
+		projectRoot,
+		readPkgJson,
+		rememberVariant,
+		validateIntentField,
+		warnings
+	});
+	const { walkKnownPackages, walkProjectDeps, walkWorkspacePackages } = createDependencyWalker({
+		packages,
+		projectRoot,
+		readPkgJson,
+		tryRegister,
+		warnings
+	});
+	function scanLocalPackages() {
+		scanTarget(nodeModules.local);
+		walkWorkspacePackages();
 		walkKnownPackages();
 		walkProjectDeps();
 	}
+	function scanGlobalPackages() {
+		ensureGlobalNodeModules();
+		scanTarget(nodeModules.global, "global");
+	}
+	switch (scanScope) {
+		case "local":
+			scanLocalPackages();
+			break;
+		case "local-and-global":
+			scanLocalPackages();
+			scanGlobalPackages();
+			walkKnownPackages();
+			walkProjectDeps();
+			break;
+		case "global":
+			scanGlobalPackages();
+			break;
+	}
 	if (!nodeModules.local.exists && !nodeModules.global.exists) return {
 		packageManager,
 		packages,

package/dist/scanner-DlkcbVye.mjs

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

package/dist/{setup-B4ZwN5Hg.mjs → setup-DfLsziXU.mjs}

@@ -1,5 +1,5 @@
-import { n as findWorkspaceRoot, r as readWorkspacePatterns, t as findPackagesWithSkills } from "./workspace-patterns-Cndd-7vB.mjs";
-import { t as resolveProjectContext } from "./project-context-D6A5sBBO.mjs";
+import { i as readWorkspacePatterns, r as findWorkspaceRoot, t as findPackagesWithSkills } from "./workspace-patterns-BN2A_60g.mjs";
+import { t as resolveProjectContext } from "./project-context-IDLpJU3S.mjs";
 import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
 import { basename, join, relative } from "node:path";
 

package/dist/setup.d.mts

@@ -1,2 +1,2 @@
-import { a as runEditPackageJsonAll, c as findWorkspaceRoot, i as runEditPackageJson, l as readWorkspacePatterns, n as MonorepoResult, o as runSetupGithubActions, r as SetupGithubActionsResult, s as findPackagesWithSkills, t as EditPackageJsonResult, u as resolveWorkspacePackages } from "./setup-BA9RkENh.mjs";
+import { a as runEditPackageJsonAll, c as findWorkspaceRoot, i as runEditPackageJson, l as readWorkspacePatterns, n as MonorepoResult, o as runSetupGithubActions, r as SetupGithubActionsResult, s as findPackagesWithSkills, t as EditPackageJsonResult, u as resolveWorkspacePackages } from "./setup-D2CGdTsx.mjs";
 export { EditPackageJsonResult, MonorepoResult, SetupGithubActionsResult, findPackagesWithSkills, findWorkspaceRoot, readWorkspacePatterns, resolveWorkspacePackages, runEditPackageJson, runEditPackageJsonAll, runSetupGithubActions };

package/dist/setup.mjs

@@ -1,6 +1,6 @@
 import "./utils-COlDcU72.mjs";
-import { i as resolveWorkspacePackages, n as findWorkspaceRoot, r as readWorkspacePatterns, t as findPackagesWithSkills } from "./workspace-patterns-Cndd-7vB.mjs";
-import "./project-context-D6A5sBBO.mjs";
-import { n as runEditPackageJsonAll, r as runSetupGithubActions, t as runEditPackageJson } from "./setup-B4ZwN5Hg.mjs";
+import { a as resolveWorkspacePackages, i as readWorkspacePatterns, r as findWorkspaceRoot, t as findPackagesWithSkills } from "./workspace-patterns-BN2A_60g.mjs";
+import "./project-context-IDLpJU3S.mjs";
+import { n as runEditPackageJsonAll, r as runSetupGithubActions, t as runEditPackageJson } from "./setup-DfLsziXU.mjs";
 
 export { findPackagesWithSkills, findWorkspaceRoot, readWorkspacePatterns, resolveWorkspacePackages, runEditPackageJson, runEditPackageJsonAll, runSetupGithubActions };

package/dist/skill-paths-8k9K9y26.mjs

@@ -0,0 +1,33 @@
+import { s as toPosixPath } from "./utils-COlDcU72.mjs";
+import { existsSync } from "node:fs";
+import { join, relative } from "node:path";
+
+//#region src/skill-paths.ts
+function isAbsolutePath(path) {
+	return path.startsWith("/") || path.startsWith("\\") || /^[A-Za-z]:[\\/]/.test(path);
+}
+function getPathSegments(path) {
+	return path.replace(/\\/g, "/").split("/");
+}
+function isPackageManagerInternalSegment(segment) {
+	return segment === ".pnpm" || segment === ".bun" || segment === ".yarn";
+}
+function isStableLoadPath(path) {
+	const normalized = path.trim();
+	const segments = getPathSegments(normalized);
+	return normalized !== "" && !isAbsolutePath(normalized) && !segments.includes("..") && !segments.some(isPackageManagerInternalSegment);
+}
+function rewriteSkillLoadPaths({ packageName, packageRoot, projectRoot, skills }) {
+	const hasStableSymlink = packageName !== "" && existsSync(join(projectRoot, "node_modules", packageName));
+	for (const skill of skills) if (hasStableSymlink) skill.path = `node_modules/${packageName}/${toPosixPath(relative(packageRoot, skill.path))}`;
+	else skill.path = toPosixPath(relative(projectRoot, skill.path));
+}
+function formatRuntimeSkillLookupComment(target) {
+	return `Runtime lookup only: run \`npx @tanstack/intent@latest load ${target.packageName}#${target.skillName} --path\`, and load its reported path for this session. Do not copy the resolved path into this file.`;
+}
+function formatRuntimeSkillLookupHint(target) {
+	return `Lookup: ${formatRuntimeSkillLookupComment(target)}`;
+}
+
+//#endregion
+export { isStableLoadPath as n, rewriteSkillLoadPaths as r, formatRuntimeSkillLookupHint as t };

package/dist/skill-use-uwGleSOz.mjs

@@ -0,0 +1,42 @@
+//#region src/skill-use.ts
+var SkillUseParseError = class extends Error {
+	constructor(code, value) {
+		super(formatSkillUseParseErrorMessage(code, value));
+		this.name = "SkillUseParseError";
+		this.code = code;
+		this.value = value;
+	}
+};
+function isSkillUseParseError(error) {
+	return error instanceof SkillUseParseError;
+}
+function formatSkillUse(packageName, skillName) {
+	const pkg = packageName.trim();
+	const skill = skillName.trim();
+	if (pkg === "") throw new SkillUseParseError("empty-package", `${packageName}#${skillName}`);
+	if (skill === "") throw new SkillUseParseError("empty-skill", `${packageName}#${skillName}`);
+	return `${pkg}#${skill}`;
+}
+function parseSkillUse(value) {
+	const trimmed = value.trim();
+	const separatorIndex = trimmed.indexOf("#");
+	if (separatorIndex === -1) throw new SkillUseParseError("missing-separator", value);
+	const packageName = trimmed.slice(0, separatorIndex).trim();
+	const skillName = trimmed.slice(separatorIndex + 1).trim();
+	if (packageName === "") throw new SkillUseParseError("empty-package", value);
+	if (skillName === "") throw new SkillUseParseError("empty-skill", value);
+	return {
+		packageName,
+		skillName
+	};
+}
+function formatSkillUseParseErrorMessage(code, value) {
+	switch (code) {
+		case "missing-separator": return `Invalid skill use "${value}": expected <package>#<skill>.`;
+		case "empty-package": return `Invalid skill use "${value}": package is required.`;
+		case "empty-skill": return `Invalid skill use "${value}": skill is required.`;
+	}
+}
+
+//#endregion
+export { parseSkillUse as i, formatSkillUse as n, isSkillUseParseError as r, SkillUseParseError as t };

package/dist/staleness-DpbmYod4.mjs

@@ -0,0 +1,5 @@
+import "./utils-COlDcU72.mjs";
+import "./artifact-coverage-wLNVX8yC.mjs";
+import { n as checkStaleness, r as readPackageName, t as buildWorkspaceCoverageSignals } from "./staleness-PdgakrCQ.mjs";
+
+export { buildWorkspaceCoverageSignals, checkStaleness, readPackageName };