@tanstack/intent 0.0.35 → 0.0.37

package/dist/core-BlJqkv0a.mjs

@@ -0,0 +1,497 @@
+import { o as resolveDepDir, r as getDeps, s as toPosixPath } from "./utils-mdb4i6VA.mjs";
+import { n as scanIntentPackageAtRoot, t as scanForIntents } from "./scanner-W6797hWs.mjs";
+import { a as resolveWorkspacePackages } from "./workspace-patterns-CNhdqCO4.mjs";
+import { i as parseSkillUse, n as formatSkillUse } from "./skill-use-umYvZl94.mjs";
+import { t as resolveProjectContext } from "./project-context-CfSZGJFC.mjs";
+import { a as compileExcludePatterns, c as warningMentionsPackage, i as resolveSkillUse, l as readPackageJson, o as getEffectiveExcludePatterns, r as resolveSkillEntry, s as isPackageExcluded, t as ResolveSkillUseError } from "./resolver-BTeG2oyZ.mjs";
+import { existsSync, readFileSync, realpathSync } from "node:fs";
+import { dirname, isAbsolute, join, relative, resolve } from "node:path";
+
+//#region src/core/markdown.ts
+function resolveFromCwd$1(path) {
+	return resolve(process.cwd(), path);
+}
+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, cwd, packageRoot, skillFilePath }) {
+	const context = {
+		cwd,
+		resolvedPackageRoot: resolveFromCwd$1(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;
+}
+
+//#endregion
+//#region src/core/load-resolution.ts
+function readWorkspacePackageInfos(context) {
+	const dirs = /* @__PURE__ */ new Set();
+	if (context.packageRoot) dirs.add(context.packageRoot);
+	if (context.workspaceRoot) {
+		dirs.add(context.workspaceRoot);
+		for (const dir of resolveWorkspacePackages(context.workspaceRoot, context.workspacePatterns)) dirs.add(dir);
+	}
+	return [...dirs].flatMap((dir) => {
+		const packageJson = readPackageJson(dir);
+		if (!packageJson) return [];
+		return [{
+			dir,
+			name: typeof packageJson.name === "string" ? packageJson.name : null,
+			packageJson
+		}];
+	});
+}
+function addCandidateDir(candidates, seen, dir) {
+	if (!dir) return;
+	const key = resolve(dir);
+	if (seen.has(key)) return;
+	seen.add(key);
+	candidates.push(dir);
+}
+function findVisibleDependencyDir(packageName, fromDir) {
+	let dir = fromDir;
+	while (true) {
+		const candidate = join(dir, "node_modules", packageName);
+		if (existsSync(join(candidate, "package.json"))) return candidate;
+		const next = dirname(dir);
+		if (next === dir) return null;
+		dir = next;
+	}
+}
+function resolveDependencyPackageDir(packageName, fromDir) {
+	return findVisibleDependencyDir(packageName, fromDir) ?? resolveDepDir(packageName, fromDir);
+}
+function workspacePackageDeclaresDependency(packageJson, packageName) {
+	return getDeps(packageJson).includes(packageName);
+}
+function hasYarnPnpFile(dir) {
+	return dir !== null && (existsSync(join(dir, ".pnp.cjs")) || existsSync(join(dir, ".pnp.js")));
+}
+function shouldSkipFastPathForYarnPnp(context, cwd) {
+	return hasYarnPnpFile(cwd) || hasYarnPnpFile(context.workspaceRoot);
+}
+function getDirectLoadFastPathCandidateDirs(packageName, context, cwd) {
+	const candidates = [];
+	const seen = /* @__PURE__ */ new Set();
+	if (!context.workspaceRoot) {
+		addCandidateDir(candidates, seen, resolveDependencyPackageDir(packageName, context.packageRoot ?? cwd));
+		return candidates;
+	}
+	addCandidateDir(candidates, seen, resolveDependencyPackageDir(packageName, context.packageRoot ?? context.workspaceRoot ?? cwd));
+	if (context.workspaceRoot && context.workspaceRoot !== context.packageRoot) addCandidateDir(candidates, seen, resolveDependencyPackageDir(packageName, context.workspaceRoot));
+	return candidates;
+}
+function getWorkspaceLoadFastPathCandidateDirs(packageName, context) {
+	const candidates = [];
+	const seen = /* @__PURE__ */ new Set();
+	const workspacePackages = readWorkspacePackageInfos(context);
+	for (const pkg of workspacePackages) if (pkg.name === packageName) addCandidateDir(candidates, seen, pkg.dir);
+	for (const pkg of workspacePackages) {
+		if (!workspacePackageDeclaresDependency(pkg.packageJson, packageName)) continue;
+		addCandidateDir(candidates, seen, resolveDependencyPackageDir(packageName, pkg.dir));
+	}
+	return candidates;
+}
+function resolveScannedPackageSkill(scanned, parsedUse) {
+	const pkg = scanned.package;
+	if (!pkg || pkg.name !== parsedUse.packageName) return null;
+	const skill = resolveSkillEntry(pkg.name, parsedUse.skillName, pkg.skills).skill;
+	if (!skill) return null;
+	return {
+		packageName: pkg.name,
+		skillName: skill.name,
+		path: skill.path,
+		source: pkg.source,
+		version: pkg.version,
+		packageRoot: pkg.packageRoot,
+		warnings: scanned.warnings.filter((warning) => warningMentionsPackage(warning, pkg.name)),
+		conflict: null
+	};
+}
+function resolveFromPackageRoots(packageRoots, parsedUse, cwd) {
+	for (const packageRoot of packageRoots) {
+		const scanned = scanIntentPackageAtRoot(packageRoot, {
+			fallbackName: parsedUse.packageName,
+			projectRoot: cwd,
+			skillNameHint: parsedUse.skillName
+		});
+		const directResolved = resolveScannedPackageSkill(scanned, parsedUse);
+		if (directResolved) return directResolved;
+		if (scanned.package?.name === parsedUse.packageName) {
+			const fallbackResolved = resolveScannedPackageSkill(scanIntentPackageAtRoot(packageRoot, {
+				fallbackName: parsedUse.packageName,
+				projectRoot: cwd
+			}), parsedUse);
+			if (fallbackResolved) return fallbackResolved;
+		}
+	}
+	return null;
+}
+function resolveSkillUseFastPath(parsedUse, options, context = resolveProjectContext({ cwd: process.cwd() }), cwd = context.cwd) {
+	if (options.globalOnly) return null;
+	if (shouldSkipFastPathForYarnPnp(context, cwd)) return null;
+	const directResolved = resolveFromPackageRoots(getDirectLoadFastPathCandidateDirs(parsedUse.packageName, context, cwd), parsedUse, cwd);
+	if (directResolved) return directResolved;
+	if (!context.workspaceRoot) return null;
+	return resolveFromPackageRoots(getWorkspaceLoadFastPathCandidateDirs(parsedUse.packageName, context), parsedUse, cwd);
+}
+
+//#endregion
+//#region src/core.ts
+var IntentCoreError = class extends Error {
+	constructor(code, message, options = {}) {
+		super(message);
+		this.name = "IntentCoreError";
+		this.code = code;
+		if (options.suggestedSkills) this.suggestedSkills = options.suggestedSkills;
+	}
+};
+function toScanOptions(options) {
+	if (options.global && options.globalOnly) throw new IntentCoreError("invalid-options", "Use either global or globalOnly, not both.");
+	if (options.globalOnly) return { scope: "global" };
+	if (options.global) return { scope: "local-and-global" };
+	return { scope: "local" };
+}
+function getScanScope(options) {
+	return options.scope ?? (options.includeGlobal ? "local-and-global" : "local");
+}
+function resolveCoreCwd(options) {
+	return resolve(process.cwd(), options.cwd ?? process.cwd());
+}
+function listIntentSkills(options = {}) {
+	const cwd = resolveCoreCwd(options);
+	const scanOptions = toScanOptions(options);
+	const projectContext = resolveProjectContext({ cwd });
+	const scanResult = scanForIntents(cwd, scanOptions);
+	const excludePatterns = getEffectiveExcludePatterns(options, projectContext);
+	const excludeMatchers = compileExcludePatterns(excludePatterns);
+	const excludedPackages = scanResult.packages.filter((pkg) => isPackageExcluded(pkg.name, excludeMatchers)).map((pkg) => pkg.name);
+	const packages = scanResult.packages.filter((pkg) => !isPackageExcluded(pkg.name, excludeMatchers));
+	const result = {
+		skills: packages.flatMap((pkg) => pkg.skills.map((skill) => {
+			return {
+				use: formatSkillUse(pkg.name, skill.name),
+				packageName: pkg.name,
+				packageRoot: pkg.packageRoot,
+				packageVersion: pkg.version,
+				packageSource: pkg.source,
+				skillName: skill.name,
+				description: skill.description,
+				type: skill.type,
+				framework: skill.framework
+			};
+		})),
+		packages: packages.map((pkg) => ({
+			name: pkg.name,
+			version: pkg.version,
+			source: pkg.source,
+			packageRoot: pkg.packageRoot,
+			skillCount: pkg.skills.length
+		})),
+		warnings: scanResult.warnings.filter((warning) => !excludedPackages.some((packageName) => warningMentionsPackage(warning, packageName))),
+		conflicts: scanResult.conflicts.filter((conflict) => !isPackageExcluded(conflict.packageName, excludeMatchers))
+	};
+	if (options.debug) result.debug = {
+		cwd,
+		scope: getScanScope(scanOptions),
+		excludes: excludePatterns,
+		packageCount: result.packages.length,
+		skillCount: result.skills.length,
+		warningCount: result.warnings.length,
+		conflictCount: result.conflicts.length
+	};
+	return result;
+}
+function resolveFromCwd(cwd, path) {
+	return resolve(cwd, path);
+}
+function isResolvedPathInsidePackageRoot(path, packageRoot) {
+	const relativePath = relative(packageRoot, path);
+	return relativePath === "" || !relativePath.startsWith("..") && !isAbsolute(relativePath);
+}
+function toResolvedIntentSkill(cwd, use, resolved, debug) {
+	let realResolvedPath;
+	try {
+		realResolvedPath = realpathSync.native(resolveFromCwd(cwd, resolved.path));
+	} catch {
+		throw new IntentCoreError("skill-file-not-found", `Resolved skill file was not found: ${resolved.path}`);
+	}
+	const realPackageRoot = realpathSync.native(resolveFromCwd(cwd, resolved.packageRoot));
+	if (!isResolvedPathInsidePackageRoot(realResolvedPath, realPackageRoot)) throw new IntentCoreError("skill-path-outside-package", `Resolved skill path for "${use}" is outside package root: ${resolved.path}`);
+	const result = {
+		path: resolved.path,
+		packageRoot: resolved.packageRoot,
+		packageName: resolved.packageName,
+		skillName: resolved.skillName,
+		version: resolved.version,
+		source: resolved.source,
+		warnings: resolved.warnings,
+		conflict: resolved.conflict
+	};
+	if (debug) result.debug = debug;
+	return {
+		realPackageRoot,
+		realResolvedPath,
+		result
+	};
+}
+function createLoadedSkillDebug({ cwd, excludes, resolution, resolved, scope }) {
+	return {
+		cwd,
+		scope,
+		resolution,
+		excludes,
+		packageName: resolved.packageName,
+		skillName: resolved.skillName,
+		version: resolved.version,
+		source: resolved.source,
+		path: resolved.path,
+		warningCount: resolved.warnings.length
+	};
+}
+function resolveIntentSkillInCwd(cwd, use, options = {}) {
+	let parsedUse;
+	try {
+		parsedUse = parseSkillUse(use);
+	} catch (err) {
+		throw new IntentCoreError("invalid-skill-use", err instanceof Error ? err.message : String(err));
+	}
+	const projectContext = resolveProjectContext({ cwd });
+	const excludePatterns = getEffectiveExcludePatterns(options, projectContext);
+	const excludeMatchers = compileExcludePatterns(excludePatterns);
+	if (isPackageExcluded(parsedUse.packageName, excludeMatchers)) throw new IntentCoreError("package-excluded", `Cannot load skill use "${use}": package "${parsedUse.packageName}" is excluded by Intent configuration.`);
+	const scanOptions = toScanOptions(options);
+	const scope = getScanScope(scanOptions);
+	const fastPathResolved = resolveSkillUseFastPath(parsedUse, options, projectContext, cwd);
+	if (fastPathResolved) return toResolvedIntentSkill(cwd, use, fastPathResolved, options.debug ? createLoadedSkillDebug({
+		cwd,
+		excludes: excludePatterns,
+		resolution: "fast-path",
+		resolved: fastPathResolved,
+		scope
+	}) : void 0);
+	const scanResult = scanForIntents(cwd, scanOptions);
+	let resolved;
+	try {
+		resolved = resolveSkillUse(use, scanResult);
+	} catch (err) {
+		if (err instanceof ResolveSkillUseError) throw new IntentCoreError(err.code, err.message, { suggestedSkills: err.suggestedSkills });
+		throw err;
+	}
+	return toResolvedIntentSkill(cwd, use, resolved, options.debug ? createLoadedSkillDebug({
+		cwd,
+		excludes: excludePatterns,
+		resolution: "full-scan",
+		resolved,
+		scope
+	}) : void 0);
+}
+function resolveIntentSkill(use, options = {}) {
+	return resolveIntentSkillInCwd(resolveCoreCwd(options), use, options).result;
+}
+function loadIntentSkill(use, options = {}) {
+	const cwd = resolveCoreCwd(options);
+	const resolved = resolveIntentSkillInCwd(cwd, use, options);
+	const content = rewriteLoadedSkillMarkdownDestinations({
+		content: readFileSync(resolved.realResolvedPath, "utf8"),
+		cwd,
+		packageRoot: resolved.realPackageRoot,
+		skillFilePath: resolved.realResolvedPath
+	});
+	return {
+		...resolved.result,
+		content
+	};
+}
+
+//#endregion
+export { resolveIntentSkill as i, listIntentSkills as n, loadIntentSkill as r, IntentCoreError as t };

package/dist/core.d.mts

@@ -0,0 +1,85 @@
+import { b as VersionConflict, h as ScanScope, l as IntentPackage } from "./types-S2zpibHp.mjs";
+
+//#region src/core/types.d.ts
+interface IntentCoreOptions {
+  cwd?: string;
+  debug?: boolean;
+  global?: boolean;
+  globalOnly?: boolean;
+  exclude?: Array<string>;
+}
+interface IntentSkillSummary {
+  use: string;
+  packageName: string;
+  packageRoot: string;
+  packageVersion: string;
+  packageSource: IntentPackage['source'];
+  skillName: string;
+  description: string;
+  type?: string;
+  framework?: string;
+}
+interface IntentPackageSummary {
+  name: string;
+  version: string;
+  source: IntentPackage['source'];
+  packageRoot: string;
+  skillCount: number;
+}
+interface IntentSkillList {
+  skills: Array<IntentSkillSummary>;
+  packages: Array<IntentPackageSummary>;
+  warnings: Array<string>;
+  conflicts: Array<VersionConflict>;
+  debug?: IntentSkillListDebug;
+}
+interface ResolvedIntentSkill {
+  path: string;
+  packageRoot: string;
+  packageName: string;
+  skillName: string;
+  version: string;
+  source: IntentPackage['source'];
+  warnings: Array<string>;
+  conflict: VersionConflict | null;
+  debug?: LoadedIntentSkillDebug;
+}
+interface LoadedIntentSkill extends ResolvedIntentSkill {
+  content: string;
+}
+interface IntentSkillListDebug {
+  cwd: string;
+  scope: ScanScope;
+  excludes: Array<string>;
+  packageCount: number;
+  skillCount: number;
+  warningCount: number;
+  conflictCount: number;
+}
+interface LoadedIntentSkillDebug {
+  cwd: string;
+  scope: ScanScope;
+  resolution: 'fast-path' | 'full-scan';
+  excludes: Array<string>;
+  packageName: string;
+  skillName: string;
+  version: string;
+  source: IntentPackage['source'];
+  path: string;
+  warningCount: number;
+}
+type IntentCoreErrorCode = 'invalid-options' | 'invalid-skill-use' | 'package-not-found' | 'package-excluded' | 'skill-not-found' | 'skill-path-outside-package' | 'skill-file-not-found';
+//#endregion
+//#region src/core.d.ts
+declare class IntentCoreError extends Error {
+  readonly code: IntentCoreErrorCode;
+  readonly suggestedSkills?: Array<string>;
+  constructor(code: IntentCoreErrorCode, message: string, options?: {
+    suggestedSkills?: Array<string>;
+  });
+}
+declare function listIntentSkills(options?: IntentCoreOptions): IntentSkillList;
+declare function resolveIntentSkill(use: string, options?: IntentCoreOptions): ResolvedIntentSkill;
+declare function loadIntentSkill(use: string, options?: IntentCoreOptions): LoadedIntentSkill;
+//#endregion
+export { IntentCoreError, type IntentCoreErrorCode, type IntentCoreOptions, type IntentPackageSummary, type IntentSkillList, type IntentSkillListDebug, type IntentSkillSummary, type LoadedIntentSkill, type LoadedIntentSkillDebug, type ResolvedIntentSkill, listIntentSkills, loadIntentSkill, resolveIntentSkill };

package/dist/core.mjs

@@ -0,0 +1,9 @@
+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 { i as resolveIntentSkill, n as listIntentSkills, r as loadIntentSkill, t as IntentCoreError } from "./core-BlJqkv0a.mjs";
+
+export { IntentCoreError, listIntentSkills, loadIntentSkill, resolveIntentSkill };

package/dist/display-COlw5FaB.mjs

@@ -0,0 +1,5 @@
+import "./utils-mdb4i6VA.mjs";
+import "./skill-paths-DNOHrvL5.mjs";
+import { n as printSkillTree, r as printTable, t as computeSkillNameWidth } from "./display-CVeoAwBd.mjs";
+
+export { computeSkillNameWidth, printSkillTree, printTable };

package/dist/{display-CAof6doy.mjs → display-CVeoAwBd.mjs}

@@ -1,4 +1,4 @@
-import { n as isStableLoadPath, t as formatRuntimeSkillLookupHint } from "./skill-paths-8k9K9y26.mjs";
+import { n as isStableLoadPath, t as formatRuntimeSkillLookupHint } from "./skill-paths-DNOHrvL5.mjs";
 
 //#region src/display.ts
 function padColumn(text, width) {

package/dist/edit-package-json-CzWlMXOf.mjs

@@ -0,0 +1,8 @@
+//#region src/commands/edit-package-json.ts
+async function runEditPackageJsonCommand(root) {
+	const { runEditPackageJsonAll } = await import("./setup.mjs");
+	runEditPackageJsonAll(root);
+}
+
+//#endregion
+export { runEditPackageJsonCommand };

package/dist/index.d.mts

@@ -1,5 +1,5 @@
-import { _ as StalenessReport, a as IntentArtifactSet, c as IntentConfig, d as MetaFeedbackPayload, f as MetaSkillName, g as SkillStaleness, h as SkillEntry, i as IntentArtifactFile, l as IntentPackage, m as ScanResult, n as FeedbackPayload, o as IntentArtifactSkill, p as ScanOptions, r as IntentArtifactCoverageIgnore, s as IntentArtifactWarning, t as AgentName, u as IntentProjectConfig, v as StalenessSignal, y as VersionConflict } from "./types-DT7Y6TFz.mjs";
-import { i as runEditPackageJson, o as runSetupGithubActions, r as SetupGithubActionsResult, t as EditPackageJsonResult } from "./setup-t1i2o2-h.mjs";
+import { _ as SkillStaleness, a as IntentArtifactSet, b as VersionConflict, c as IntentConfig, d as MetaFeedbackPayload, f as MetaSkillName, g as SkillEntry, i as IntentArtifactFile, l as IntentPackage, m as ScanResult, n as FeedbackPayload, o as IntentArtifactSkill, p as ScanOptions, r as IntentArtifactCoverageIgnore, s as IntentArtifactWarning, t as AgentName, u as IntentProjectConfig, v as StalenessReport, y as StalenessSignal } from "./types-S2zpibHp.mjs";
+import { i as runEditPackageJson, o as runSetupGithubActions, r as SetupGithubActionsResult, t as EditPackageJsonResult } from "./setup-ldoQOQot.mjs";
 
 //#region src/scanner.d.ts
 declare function scanForIntents(root?: string, options?: ScanOptions): ScanResult;
@@ -107,12 +107,14 @@ declare class ResolveSkillUseError extends Error {
   readonly skillName: string;
   readonly availablePackages: Array<string>;
   readonly availableSkills: Array<string>;
+  readonly suggestedSkills: Array<string>;
   constructor({
     availablePackages,
     availableSkills,
     code,
     packageName,
     skillName,
+    suggestedSkills,
     use
   }: {
     availablePackages?: Array<string>;
@@ -120,6 +122,7 @@ declare class ResolveSkillUseError extends Error {
     code: ResolveSkillUseErrorCode;
     packageName: string;
     skillName: string;
+    suggestedSkills?: Array<string>;
     use: string;
   });
 }

package/dist/index.mjs

@@ -1,14 +1,14 @@
-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-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";
-import { n as collectStaleReviewItems, r as createFailedStaleReviewItem, t as buildStaleReviewBody } from "./workflow-review-CwkPVIQf.mjs";
-import { i as parseSkillUse, n as formatSkillUse, r as isSkillUseParseError, t as SkillUseParseError } from "./skill-use-BzuuvLM7.mjs";
-import { n as isResolveSkillUseError, r as resolveSkillUse, t as ResolveSkillUseError } from "./resolver-Whd12ksO.mjs";
-import "./project-context-alYMNoNa.mjs";
-import { r as runSetupGithubActions, t as runEditPackageJson } from "./setup-Dp-W8y0Y.mjs";
+import { a as parseFrontmatter, n as findSkillFiles, o as resolveDepDir, r as getDeps } from "./utils-mdb4i6VA.mjs";
+import "./skill-paths-DNOHrvL5.mjs";
+import { t as scanForIntents } from "./scanner-W6797hWs.mjs";
+import "./workspace-patterns-CNhdqCO4.mjs";
+import { t as readIntentArtifacts } from "./artifact-coverage-DgWuVqUp.mjs";
+import { n as checkStaleness } from "./staleness-CFr3W-RI.mjs";
+import { n as collectStaleReviewItems, r as createFailedStaleReviewItem, t as buildStaleReviewBody } from "./workflow-review-CwcR2ge4.mjs";
+import { i as parseSkillUse, n as formatSkillUse, r as isSkillUseParseError, t as SkillUseParseError } from "./skill-use-umYvZl94.mjs";
+import "./project-context-CfSZGJFC.mjs";
+import { i as resolveSkillUse, n as isResolveSkillUseError, t as ResolveSkillUseError } from "./resolver-BTeG2oyZ.mjs";
+import { r as runSetupGithubActions, t as runEditPackageJson } from "./setup-B-1hsdmA.mjs";
 import { readFileSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { execFileSync, execSync } from "node:child_process";

package/dist/install-BAUG1FD8.mjs

@@ -0,0 +1,7 @@
+import "./utils-mdb4i6VA.mjs";
+import "./workspace-patterns-CNhdqCO4.mjs";
+import "./project-context-CfSZGJFC.mjs";
+import "./cli-support-Dk2rgYli.mjs";
+import { n as runInstallCommand, t as INSTALL_PROMPT } from "./install-DA19Vg17.mjs";
+
+export { INSTALL_PROMPT, runInstallCommand };