@tanstack/intent 0.0.36 → 0.0.37

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

@@ -1,114 +1,10 @@
-import { i as parseSkillUse, n as formatSkillUse } from "./skill-use-BzuuvLM7.mjs";
-import { t as resolveProjectContext } from "./project-context-alYMNoNa.mjs";
+import { i as parseSkillUse, n as formatSkillUse } from "./skill-use-umYvZl94.mjs";
+import { t as fail } from "./cli-error-BrMXlbtx.mjs";
+import { c as scanOptionsFromGlobalFlags, l as printWarnings } from "./cli-support-Dk2rgYli.mjs";
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { dirname, join, relative, resolve } from "node:path";
+import { dirname, join, relative } from "node:path";
 import { parse } from "yaml";
-import { fileURLToPath } from "node:url";
 
-//#region src/cli-error.ts
-const CLI_FAILURE = Symbol("CliFailure");
-function fail(message, exitCode = 1) {
-	throw {
-		[CLI_FAILURE]: true,
-		message,
-		exitCode
-	};
-}
-function isCliFailure(value) {
-	return !!value && typeof value === "object" && CLI_FAILURE in value;
-}
-
-//#endregion
-//#region src/cli-output.ts
-function printWarnings(warnings) {
-	if (warnings.length === 0) return;
-	console.log("Warnings:");
-	for (const warning of warnings) console.log(`  ⚠ ${warning}`);
-}
-
-//#endregion
-//#region src/cli-support.ts
-const INTENT_CHECK_SKILLS_WORKFLOW_VERSION = 3;
-function getMetaDir() {
-	return join(dirname(fileURLToPath(import.meta.url)), "..", "meta");
-}
-function getCheckSkillsWorkflowAdvisories(root) {
-	const workflowPath = join(root, ".github", "workflows", "check-skills.yml");
-	if (!existsSync(workflowPath)) return [];
-	let content;
-	try {
-		content = readFileSync(workflowPath, "utf8");
-	} catch {
-		return [];
-	}
-	const versionMatch = content.match(/intent-workflow-version:\s*(\d+)/);
-	if ((versionMatch ? Number(versionMatch[1]) : 0) >= INTENT_CHECK_SKILLS_WORKFLOW_VERSION) return [];
-	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-C2YjF4w_.mjs");
-	try {
-		return scanForIntents(void 0, options);
-	} catch (err) {
-		fail(err instanceof Error ? err.message : String(err));
-	}
-}
-function scanOptionsFromGlobalFlags(options) {
-	if (options.global && options.globalOnly) fail("Use either --global or --global-only, not both.");
-	if (options.globalOnly) return { scope: "global" };
-	if (options.global) return { scope: "local-and-global" };
-	return { scope: "local" };
-}
-async function resolveStaleTargets(targetDir) {
-	const resolvedRoot = targetDir ? resolve(process.cwd(), targetDir) : process.cwd();
-	const context = resolveProjectContext({
-		cwd: process.cwd(),
-		targetPath: targetDir
-	});
-	const workflowAdvisories = getCheckSkillsWorkflowAdvisories(context.workspaceRoot ?? context.packageRoot ?? resolvedRoot);
-	const { buildWorkspaceCoverageSignals, checkStaleness, readPackageName } = await import("./staleness-DpbmYod4.mjs");
-	const isWorkspaceRootTarget = context.workspaceRoot !== null && resolvedRoot === context.workspaceRoot;
-	if (context.packageRoot && !isWorkspaceRootTarget && (context.targetSkillsDir !== null || context.workspaceRoot === null)) return {
-		reports: [await checkStaleness(context.packageRoot, readPackageName(context.packageRoot), context.workspaceRoot ?? context.packageRoot)],
-		workflowAdvisories
-	};
-	const { findPackagesWithSkills, findWorkspacePackages, findWorkspaceRoot } = await import("./workspace-patterns-x-dLZxx4.mjs");
-	const workspaceRoot = findWorkspaceRoot(resolvedRoot);
-	if (workspaceRoot) {
-		const packageDirsWithSkills = findPackagesWithSkills(workspaceRoot);
-		const allPackageDirs = findWorkspacePackages(workspaceRoot);
-		const reports = await Promise.all(packageDirsWithSkills.map((packageDir) => checkStaleness(packageDir, readPackageName(packageDir), workspaceRoot)));
-		const { readIntentArtifacts } = await import("./artifact-coverage-BAN2W6aH.mjs");
-		const coverageSignals = buildWorkspaceCoverageSignals({
-			artifactRoot: workspaceRoot,
-			artifacts: existsSync(join(workspaceRoot, "_artifacts")) ? readIntentArtifacts(workspaceRoot) : null,
-			packageDirs: allPackageDirs
-		});
-		if (coverageSignals.length > 0) reports.push({
-			library: relative(process.cwd(), workspaceRoot) || "workspace",
-			currentVersion: null,
-			skillVersion: null,
-			versionDrift: null,
-			skills: [],
-			signals: coverageSignals
-		});
-		if (reports.length > 0) return {
-			reports,
-			workflowAdvisories
-		};
-	}
-	if (existsSync(join(resolvedRoot, "skills"))) return {
-		reports: [await checkStaleness(resolvedRoot, readPackageName(resolvedRoot))],
-		workflowAdvisories
-	};
-	const staleResult = await scanIntentsOrFail();
-	return {
-		reports: await Promise.all(staleResult.packages.map((pkg) => checkStaleness(pkg.packageRoot, pkg.name))),
-		workflowAdvisories
-	};
-}
-
-//#endregion
 //#region src/commands/install-writer.ts
 const INTENT_SKILLS_START = "<!-- intent-skills:start -->";
 const INTENT_SKILLS_END = "<!-- intent-skills:end -->";
@@ -475,7 +371,7 @@ function printWriteResult({ mappingCount, status, targetPath }) {
 			break;
 	}
 }
-async function runInstallCommand(options, scanIntentsOrFail$1) {
+async function runInstallCommand(options, scanIntentsOrFail) {
 	if (options.printPrompt) {
 		console.log(INSTALL_PROMPT);
 		return;
@@ -505,7 +401,7 @@ async function runInstallCommand(options, scanIntentsOrFail$1) {
 		printPlacementTip(result$1.targetPath);
 		return;
 	}
-	const scanResult = await scanIntentsOrFail$1(scanOptionsFromGlobalFlags(options));
+	const scanResult = await scanIntentsOrFail(scanOptionsFromGlobalFlags(options));
 	const generated = buildIntentSkillsBlock(scanResult);
 	if (options.dryRun) {
 		const targetPath = resolveIntentSkillsBlockTargetPath(process.cwd(), generated.mappingCount);
@@ -539,4 +435,4 @@ async function runInstallCommand(options, scanIntentsOrFail$1) {
 }
 
 //#endregion
-export { scanIntentsOrFail as a, fail as c, resolveStaleTargets as i, isCliFailure as l, runInstallCommand as n, scanOptionsFromGlobalFlags as o, getMetaDir as r, printWarnings as s, INSTALL_PROMPT as t };
+export { runInstallCommand as n, INSTALL_PROMPT as t };

package/dist/intent-library.mjs

@@ -1,11 +1,12 @@
 #!/usr/bin/env node
-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-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";
+import "./utils-mdb4i6VA.mjs";
+import "./skill-paths-DNOHrvL5.mjs";
+import "./workspace-patterns-CNhdqCO4.mjs";
+import "./project-context-CfSZGJFC.mjs";
+import { n as printSkillTree, r as printTable, t as computeSkillNameWidth } from "./display-CVeoAwBd.mjs";
+import "./cli-support-Dk2rgYli.mjs";
+import { t as INSTALL_PROMPT } from "./install-DA19Vg17.mjs";
+import { t as scanLibrary } from "./library-scanner-CHepLJQJ.mjs";
 
 //#region src/intent-library.ts
 function cmdList() {

package/dist/{library-scanner-fexXlPXb.mjs → library-scanner-CHepLJQJ.mjs}

@@ -1,5 +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 { a as parseFrontmatter, o as resolveDepDir, r as getDeps, s as toPosixPath } from "./utils-mdb4i6VA.mjs";
+import { r as rewriteSkillLoadPaths } from "./skill-paths-DNOHrvL5.mjs";
 import { existsSync, readFileSync, readdirSync } from "node:fs";
 import { dirname, join, relative } from "node:path";
 

package/dist/library-scanner.d.mts

@@ -1,4 +1,4 @@
-import { h as SkillEntry } from "./types-DT7Y6TFz.mjs";
+import { g as SkillEntry } from "./types-S2zpibHp.mjs";
 
 //#region src/library-scanner.d.ts
 interface LibraryPackage {

package/dist/library-scanner.mjs

@@ -1,5 +1,5 @@
-import "./utils-COlDcU72.mjs";
-import "./skill-paths-8k9K9y26.mjs";
-import { t as scanLibrary } from "./library-scanner-fexXlPXb.mjs";
+import "./utils-mdb4i6VA.mjs";
+import "./skill-paths-DNOHrvL5.mjs";
+import { t as scanLibrary } from "./library-scanner-CHepLJQJ.mjs";
 
 export { scanLibrary };

package/dist/list-D6osUZl7.mjs

@@ -0,0 +1,107 @@
+import "./utils-mdb4i6VA.mjs";
+import "./skill-paths-DNOHrvL5.mjs";
+import "./scanner-W6797hWs.mjs";
+import "./workspace-patterns-CNhdqCO4.mjs";
+import "./project-context-CfSZGJFC.mjs";
+import "./resolver-BTeG2oyZ.mjs";
+import { a as printDebugInfo, l as printWarnings, n as coreOptionsFromGlobalFlags } from "./cli-support-Dk2rgYli.mjs";
+import { n as listIntentSkills } from "./core-BlJqkv0a.mjs";
+
+//#region src/commands/list.ts
+function printListDebug(result) {
+	if (!result.debug) return;
+	printDebugInfo("intent list", [
+		["cwd", result.debug.cwd],
+		["scope", result.debug.scope],
+		["excludes", result.debug.excludes],
+		["packages", result.debug.packageCount],
+		["skills", result.debug.skillCount],
+		["warnings", result.debug.warningCount],
+		["conflicts", result.debug.conflictCount]
+	]);
+}
+function printVersionConflicts(result) {
+	if (result.conflicts.length === 0) return;
+	console.log("\nVersion conflicts:\n");
+	for (const conflict of result.conflicts) {
+		console.log(`  ${conflict.packageName} -> using ${conflict.chosen.version}`);
+		console.log(`    chosen: ${conflict.chosen.packageRoot}`);
+		for (const variant of conflict.variants) {
+			if (variant.packageRoot === conflict.chosen.packageRoot) continue;
+			console.log(`    also found: ${variant.version} at ${variant.packageRoot}`);
+		}
+		console.log();
+	}
+}
+function groupSkillsByPackageRoot(skills) {
+	const grouped = /* @__PURE__ */ new Map();
+	for (const skill of skills) {
+		const packageSkills = grouped.get(skill.packageRoot);
+		if (packageSkills) packageSkills.push(skill);
+		else grouped.set(skill.packageRoot, [skill]);
+	}
+	return grouped;
+}
+function getPackageSkills(pkg, skillsByPackageRoot) {
+	return skillsByPackageRoot.get(pkg.packageRoot) ?? [];
+}
+async function runListCommand(options, _scanIntentsOrFail) {
+	const result = listIntentSkills(coreOptionsFromGlobalFlags(options));
+	printListDebug(result);
+	if (options.json) {
+		const { debug: _debug, ...jsonResult } = result;
+		console.log(JSON.stringify(jsonResult, null, 2));
+		return;
+	}
+	const { computeSkillNameWidth, printSkillTree, printTable } = await import("./display-COlw5FaB.mjs");
+	if (result.packages.length === 0) {
+		console.log("No intent-enabled packages found.");
+		if (result.warnings.length > 0) {
+			console.log();
+			printWarnings(result.warnings);
+		}
+		return;
+	}
+	console.log(`\n${result.packages.length} intent-enabled packages, ${result.skills.length} skills\n`);
+	printTable([
+		"PACKAGE",
+		"SOURCE",
+		"VERSION",
+		"SKILLS"
+	], result.packages.map((pkg) => [
+		pkg.name,
+		pkg.source,
+		pkg.version,
+		String(pkg.skillCount)
+	]));
+	printVersionConflicts(result);
+	const skillsByPackageRoot = groupSkillsByPackageRoot(result.skills);
+	const nameWidth = computeSkillNameWidth(result.packages.map((pkg) => getPackageSkills(pkg, skillsByPackageRoot).map((skill) => ({
+		name: skill.skillName,
+		description: skill.description,
+		type: skill.type
+	}))));
+	const showTypes = result.skills.some((skill) => skill.type);
+	console.log(`\nSkills:\n`);
+	for (const pkg of result.packages) {
+		console.log(`  ${pkg.name}`);
+		printSkillTree(getPackageSkills(pkg, skillsByPackageRoot).map((skill) => ({
+			name: skill.skillName,
+			description: skill.description,
+			type: skill.type
+		})), {
+			nameWidth,
+			packageName: pkg.name,
+			showTypes
+		});
+		console.log();
+	}
+	console.log("Feedback:");
+	console.log("  Submit feedback on skill usage to help maintainers improve the skills.");
+	console.log("  Load: node_modules/@tanstack/intent/meta/feedback-collection/SKILL.md");
+	console.log();
+	printWarnings(result.warnings);
+}
+
+//#endregion
+export { runListCommand };

package/dist/load-CzvLUFur.mjs

@@ -0,0 +1,70 @@
+import "./utils-mdb4i6VA.mjs";
+import "./skill-paths-DNOHrvL5.mjs";
+import "./scanner-W6797hWs.mjs";
+import "./workspace-patterns-CNhdqCO4.mjs";
+import "./project-context-CfSZGJFC.mjs";
+import "./resolver-BTeG2oyZ.mjs";
+import { t as fail } from "./cli-error-BrMXlbtx.mjs";
+import { a as printDebugInfo, n as coreOptionsFromGlobalFlags } from "./cli-support-Dk2rgYli.mjs";
+import { i as resolveIntentSkill, r as loadIntentSkill, t as IntentCoreError } from "./core-BlJqkv0a.mjs";
+
+//#region src/commands/load.ts
+function printLoadDebug(loaded) {
+	if (!loaded.debug) return;
+	printDebugInfo("intent load", [
+		["cwd", loaded.debug.cwd],
+		["scope", loaded.debug.scope],
+		["resolution", loaded.debug.resolution],
+		["excludes", loaded.debug.excludes],
+		["package", loaded.debug.packageName],
+		["version", loaded.debug.version],
+		["source", loaded.debug.source],
+		["skill", loaded.debug.skillName],
+		["path", loaded.debug.path],
+		["warnings", loaded.debug.warningCount]
+	]);
+}
+async function runLoadCommand(use, options, _scanIntentsOrFail) {
+	if (!use) fail("Missing skill use. Expected: intent load <package>#<skill>");
+	if (options.json && options.path) fail("Use either --json or --path, not both.");
+	const coreOptions = coreOptionsFromGlobalFlags(options);
+	if (options.path) {
+		let resolved;
+		try {
+			resolved = resolveIntentSkill(use, coreOptions);
+		} catch (err) {
+			if (err instanceof IntentCoreError) fail(err.message);
+			throw err;
+		}
+		printLoadDebug(resolved);
+		console.log(resolved.path);
+		for (const warning of resolved.warnings) console.error(`Warning: ${warning}`);
+		return;
+	}
+	let loaded;
+	try {
+		loaded = loadIntentSkill(use, coreOptions);
+	} catch (err) {
+		if (err instanceof IntentCoreError) fail(err.message);
+		throw err;
+	}
+	printLoadDebug(loaded);
+	if (options.json) {
+		console.log(JSON.stringify({
+			package: loaded.packageName,
+			skill: loaded.skillName,
+			path: loaded.path,
+			packageRoot: loaded.packageRoot,
+			source: loaded.source,
+			version: loaded.version,
+			content: loaded.content,
+			warnings: loaded.warnings
+		}, null, 2));
+		return;
+	}
+	process.stdout.write(loaded.content);
+	for (const warning of loaded.warnings) console.error(`Warning: ${warning}`);
+}
+
+//#endregion
+export { runLoadCommand };

package/dist/meta-CYV9EzM8.mjs

@@ -0,0 +1,38 @@
+import { t as fail } from "./cli-error-BrMXlbtx.mjs";
+import { existsSync, readFileSync, readdirSync } from "node:fs";
+import { join } from "node:path";
+
+//#region src/commands/meta.ts
+async function runMetaCommand(name, metaDir) {
+	if (!existsSync(metaDir)) fail("Meta-skills directory not found.");
+	if (name) {
+		if (name.includes("..") || name.includes("/") || name.includes("\\")) fail(`Invalid meta-skill name: "${name}"`);
+		const skillFile = join(metaDir, name, "SKILL.md");
+		if (!existsSync(skillFile)) fail(`Meta-skill "${name}" not found. Run \`intent meta\` to list available meta-skills.`);
+		try {
+			console.log(readFileSync(skillFile, "utf8"));
+		} catch (err) {
+			fail(`Failed to read meta-skill "${name}": ${err instanceof Error ? err.message : String(err)}`);
+		}
+		return;
+	}
+	const { parseFrontmatter } = await import("./utils-BHzSyNeJ.mjs");
+	const entries = readdirSync(metaDir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).filter((entry) => existsSync(join(metaDir, entry.name, "SKILL.md")));
+	if (entries.length === 0) {
+		console.log("No meta-skills found.");
+		return;
+	}
+	console.log("Meta-skills (for library maintainers):\n");
+	for (const entry of entries) {
+		const fm = parseFrontmatter(join(metaDir, entry.name, "SKILL.md"));
+		let description = "";
+		if (typeof fm?.description === "string") description = fm.description.replace(/\s+/g, " ").trim();
+		const shortDesc = description.length > 60 ? `${description.slice(0, 57)}...` : description;
+		console.log(`  ${entry.name.padEnd(28)} ${shortDesc}`);
+	}
+	console.log("\nUsage: load the SKILL.md into your AI agent conversation.");
+	console.log("Path: node_modules/@tanstack/intent/meta/<name>/SKILL.md");
+}
+
+//#endregion
+export { runMetaCommand };

package/dist/{project-context-alYMNoNa.mjs → project-context-CfSZGJFC.mjs}

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

package/dist/resolver-BTeG2oyZ.mjs

@@ -0,0 +1,196 @@
+import { i as parseSkillUse } from "./skill-use-umYvZl94.mjs";
+import { t as resolveProjectContext } from "./project-context-CfSZGJFC.mjs";
+import { readFileSync } from "node:fs";
+import { dirname, isAbsolute, join, relative, resolve } from "node:path";
+
+//#region src/core/package-json.ts
+function readPackageJson(dir) {
+	try {
+		return JSON.parse(readFileSync(join(dir, "package.json"), "utf8"));
+	} catch {
+		return null;
+	}
+}
+
+//#endregion
+//#region src/core/excludes.ts
+const MAX_EXCLUDE_PATTERN_LENGTH = 200;
+const PACKAGE_NAME_BOUNDARY = /[^a-zA-Z0-9_.-]/;
+function normalizeExcludePatterns(value) {
+	if (!Array.isArray(value)) return [];
+	return value.filter((pattern) => typeof pattern === "string").map((pattern) => pattern.trim()).filter(Boolean);
+}
+function isWithinOrEqual(path, parentDir) {
+	const rel = relative(parentDir, path);
+	return rel === "" || !rel.startsWith("..") && !isAbsolute(rel);
+}
+function readPackageExcludes(dir) {
+	const intent = readPackageJson(dir)?.intent;
+	if (!intent || typeof intent !== "object") return [];
+	return normalizeExcludePatterns(intent.exclude);
+}
+function getConfigExcludePatterns(cwd, context = resolveProjectContext({ cwd })) {
+	const root = context.workspaceRoot ?? context.packageRoot ?? cwd;
+	const dirs = [];
+	let dir = cwd;
+	while (isWithinOrEqual(dir, root)) {
+		dirs.push(dir);
+		if (dir === root) break;
+		const next = dirname(dir);
+		if (next === dir) break;
+		dir = next;
+	}
+	return dirs.reverse().flatMap(readPackageExcludes);
+}
+function getEffectiveExcludePatterns(options = {}, context) {
+	return [...getConfigExcludePatterns(context?.cwd ?? resolve(process.cwd(), options.cwd ?? process.cwd()), context), ...normalizeExcludePatterns(options.exclude)];
+}
+function normalizeGlobPattern(pattern) {
+	if (pattern.length > MAX_EXCLUDE_PATTERN_LENGTH) throw new Error(`Intent exclude pattern is too long: ${pattern.length} characters. Maximum is ${MAX_EXCLUDE_PATTERN_LENGTH}.`);
+	return pattern.replace(/\*+/g, "*");
+}
+function globToRegExp(pattern) {
+	const source = normalizeGlobPattern(pattern).split("*").map((part) => part.replace(/[\\^$+?.()|[\]{}]/g, "\\$&")).join(".*");
+	return /* @__PURE__ */ new RegExp(`^${source}$`);
+}
+function compileExcludePatterns(patterns) {
+	return patterns.map((pattern) => {
+		if (!pattern.includes("*")) {
+			normalizeGlobPattern(pattern);
+			return {
+				pattern,
+				matches: (packageName) => packageName === pattern
+			};
+		}
+		const regex = globToRegExp(pattern);
+		return {
+			pattern,
+			matches: (packageName) => regex.test(packageName)
+		};
+	});
+}
+function isPackageExcluded(packageName, matchers) {
+	return matchers.some((matcher) => matcher.matches(packageName));
+}
+function warningMentionsPackage(warning, packageName) {
+	let fromIndex = 0;
+	while (true) {
+		const idx = warning.indexOf(packageName, fromIndex);
+		if (idx === -1) return false;
+		const before = warning[idx - 1];
+		const after = warning[idx + packageName.length];
+		if ((before === void 0 || PACKAGE_NAME_BOUNDARY.test(before)) && (after === void 0 || PACKAGE_NAME_BOUNDARY.test(after))) return true;
+		fromIndex = idx + packageName.length;
+	}
+}
+
+//#endregion
+//#region src/resolver.ts
+var ResolveSkillUseError = class extends Error {
+	constructor({ availablePackages = [], availableSkills = [], code, packageName, skillName, suggestedSkills = [], use }) {
+		super(formatResolveSkillUseErrorMessage({
+			availablePackages,
+			availableSkills,
+			code,
+			packageName,
+			skillName,
+			suggestedSkills,
+			use
+		}));
+		this.name = "ResolveSkillUseError";
+		this.availablePackages = availablePackages;
+		this.availableSkills = availableSkills;
+		this.suggestedSkills = suggestedSkills;
+		this.code = code;
+		this.packageName = packageName;
+		this.skillName = skillName;
+		this.use = use;
+	}
+};
+function isResolveSkillUseError(error) {
+	return error instanceof ResolveSkillUseError;
+}
+function getPackageShortName(packageName) {
+	return packageName.split("/").pop() ?? packageName;
+}
+function getPackagePrefixedSkillAlias(packageName, skillName) {
+	const prefix = `${getPackageShortName(packageName)}/`;
+	return skillName.startsWith(prefix) ? skillName.slice(prefix.length) : null;
+}
+function getSuggestedSkills(packageName, skillName, skills) {
+	const lowerSkillName = skillName.toLowerCase();
+	const suggestions = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const skill of skills) {
+		const alias = getPackagePrefixedSkillAlias(packageName, skill.name);
+		const lowerName = skill.name.toLowerCase();
+		const lowerAlias = alias?.toLowerCase();
+		if (!(lowerAlias === lowerSkillName || lowerName.includes(lowerSkillName) || lowerAlias?.includes(lowerSkillName)) || seen.has(skill.name)) continue;
+		seen.add(skill.name);
+		suggestions.push(skill.name);
+	}
+	return suggestions.slice(0, 3);
+}
+function resolveSkillEntry(packageName, skillName, skills) {
+	const exact = skills.find((candidate) => candidate.name === skillName);
+	if (exact) return {
+		skill: exact,
+		suggestedSkills: []
+	};
+	const aliasMatches = skills.filter((candidate) => getPackagePrefixedSkillAlias(packageName, candidate.name) === skillName);
+	if (aliasMatches.length === 1) return {
+		skill: aliasMatches[0],
+		suggestedSkills: []
+	};
+	return {
+		skill: null,
+		suggestedSkills: getSuggestedSkills(packageName, skillName, skills)
+	};
+}
+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 resolvedSkill = resolveSkillEntry(packageName, skillName, pkg.skills);
+	const skill = resolvedSkill.skill;
+	if (!skill) throw new ResolveSkillUseError({
+		availableSkills: pkg.skills.map((candidate) => candidate.name),
+		code: "skill-not-found",
+		packageName,
+		skillName,
+		suggestedSkills: resolvedSkill.suggestedSkills,
+		use
+	});
+	const conflict = scanResult.conflicts.find((candidate) => candidate.packageName === packageName) ?? null;
+	return {
+		packageName,
+		skillName: skill.name,
+		path: skill.path,
+		source: pkg.source,
+		version: pkg.version,
+		packageRoot: pkg.packageRoot,
+		warnings: scanResult.warnings.filter((warning) => warningMentionsPackage(warning, packageName)),
+		conflict
+	};
+}
+function formatResolveSkillUseErrorMessage({ availablePackages, availableSkills, code, packageName, skillName, suggestedSkills, 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}".${suggestedSkills.length > 0 ? ` Did you mean ${formatSkillSuggestions(packageName, suggestedSkills)}?` : ""}${availableSkills.length > 0 ? ` Available skills: ${availableSkills.join(", ")}.` : ""}`;
+	}
+}
+function formatSkillSuggestions(packageName, skillNames) {
+	const uses = skillNames.map((skillName) => `${packageName}#${skillName}`);
+	if (uses.length <= 2) return uses.join(" or ");
+	return `${uses.slice(0, -1).join(", ")}, or ${uses.at(-1)}`;
+}
+
+//#endregion
+export { compileExcludePatterns as a, warningMentionsPackage as c, resolveSkillUse as i, readPackageJson as l, isResolveSkillUseError as n, getEffectiveExcludePatterns as o, resolveSkillEntry as r, isPackageExcluded as s, ResolveSkillUseError as t };