@mcp-s/skills 1.0.5 → 1.3.1

package/dist/cli.mjs

@@ -0,0 +1,4258 @@
+#!/usr/bin/env node
+import { r as __toESM } from "./_chunks/rolldown-runtime.mjs";
+import { l as pD, u as require_picocolors } from "./_chunks/libs/@clack/core.mjs";
+import { a as Y, c as xe, i as Se, l as ye, n as M, o as fe, r as Me, s as ve, t as Ie } from "./_chunks/libs/@clack/prompts.mjs";
+import "./_chunks/libs/@kwsites/file-exists.mjs";
+import "./_chunks/libs/@kwsites/promise-deferred.mjs";
+import { t as esm_default } from "./_chunks/libs/simple-git.mjs";
+import { t as require_gray_matter } from "./_chunks/libs/gray-matter.mjs";
+import "./_chunks/libs/extend-shallow.mjs";
+import "./_chunks/libs/esprima.mjs";
+import { t as xdgConfig } from "./_chunks/libs/xdg-basedir.mjs";
+import { spawn, spawnSync } from "child_process";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { basename, dirname, isAbsolute, join, normalize, relative, resolve, sep } from "path";
+import { homedir, platform, tmpdir } from "os";
+import "crypto";
+import { fileURLToPath } from "url";
+import * as readline from "readline";
+import { Writable } from "stream";
+import { access, cp, lstat, mkdir, mkdtemp, readFile, readdir, readlink, rm, stat, symlink, writeFile } from "fs/promises";
+var import_picocolors = /* @__PURE__ */ __toESM(require_picocolors(), 1);
+function getOwnerRepo(parsed) {
+	if (parsed.type === "local") return null;
+	const match = parsed.url.match(/(?:github|gitlab)\.com\/([^/]+)\/([^/]+?)(?:\.git)?$/);
+	if (match) return `${match[1]}/${match[2]}`;
+	return null;
+}
+function parseOwnerRepo(ownerRepo) {
+	const match = ownerRepo.match(/^([^/]+)\/([^/]+)$/);
+	if (match) return {
+		owner: match[1],
+		repo: match[2]
+	};
+	return null;
+}
+async function isRepoPrivate(owner, repo) {
+	try {
+		const res = await fetch(`https://api.github.com/repos/${owner}/${repo}`);
+		if (!res.ok) return null;
+		return (await res.json()).private === true;
+	} catch {
+		return null;
+	}
+}
+function isLocalPath(input) {
+	return isAbsolute(input) || input.startsWith("./") || input.startsWith("../") || input === "." || input === ".." || /^[a-zA-Z]:[/\\]/.test(input);
+}
+function isDirectSkillUrl(input) {
+	if (!input.startsWith("http://") && !input.startsWith("https://")) return false;
+	if (!input.toLowerCase().endsWith("/skill.md")) return false;
+	if (input.includes("github.com/") && !input.includes("raw.githubusercontent.com")) {
+		if (!input.includes("/blob/") && !input.includes("/raw/")) return false;
+	}
+	if (input.includes("gitlab.com/") && !input.includes("/-/raw/")) return false;
+	return true;
+}
+function isZipUrl(input) {
+	if (!input.startsWith("http://") && !input.startsWith("https://")) return false;
+	return input.toLowerCase().endsWith(".zip");
+}
+function parseSource(input) {
+	if (isLocalPath(input)) {
+		const resolvedPath = resolve(input);
+		return {
+			type: "local",
+			url: resolvedPath,
+			localPath: resolvedPath
+		};
+	}
+	if (isDirectSkillUrl(input)) return {
+		type: "direct-url",
+		url: input
+	};
+	if (isZipUrl(input)) return {
+		type: "direct-url",
+		url: input
+	};
+	const githubTreeWithPathMatch = input.match(/github\.com\/([^/]+)\/([^/]+)\/tree\/([^/]+)\/(.+)/);
+	if (githubTreeWithPathMatch) {
+		const [, owner, repo, ref, subpath] = githubTreeWithPathMatch;
+		return {
+			type: "github",
+			url: `https://github.com/${owner}/${repo}.git`,
+			ref,
+			subpath
+		};
+	}
+	const githubTreeMatch = input.match(/github\.com\/([^/]+)\/([^/]+)\/tree\/([^/]+)$/);
+	if (githubTreeMatch) {
+		const [, owner, repo, ref] = githubTreeMatch;
+		return {
+			type: "github",
+			url: `https://github.com/${owner}/${repo}.git`,
+			ref
+		};
+	}
+	const githubRepoMatch = input.match(/github\.com\/([^/]+)\/([^/]+)/);
+	if (githubRepoMatch) {
+		const [, owner, repo] = githubRepoMatch;
+		return {
+			type: "github",
+			url: `https://github.com/${owner}/${repo.replace(/\.git$/, "")}.git`
+		};
+	}
+	const gitlabTreeWithPathMatch = input.match(/^(https?):\/\/([^/]+)\/(.+?)\/-\/tree\/([^/]+)\/(.+)/);
+	if (gitlabTreeWithPathMatch) {
+		const [, protocol, hostname, repoPath, ref, subpath] = gitlabTreeWithPathMatch;
+		if (hostname !== "github.com" && repoPath) return {
+			type: "gitlab",
+			url: `${protocol}://${hostname}/${repoPath.replace(/\.git$/, "")}.git`,
+			ref,
+			subpath
+		};
+	}
+	const gitlabTreeMatch = input.match(/^(https?):\/\/([^/]+)\/(.+?)\/-\/tree\/([^/]+)$/);
+	if (gitlabTreeMatch) {
+		const [, protocol, hostname, repoPath, ref] = gitlabTreeMatch;
+		if (hostname !== "github.com" && repoPath) return {
+			type: "gitlab",
+			url: `${protocol}://${hostname}/${repoPath.replace(/\.git$/, "")}.git`,
+			ref
+		};
+	}
+	const gitlabRepoMatch = input.match(/gitlab\.com\/([^/]+)\/([^/]+)/);
+	if (gitlabRepoMatch) {
+		const [, owner, repo] = gitlabRepoMatch;
+		return {
+			type: "gitlab",
+			url: `https://gitlab.com/${owner}/${repo.replace(/\.git$/, "")}.git`
+		};
+	}
+	const atSkillMatch = input.match(/^([^/]+)\/([^/@]+)@(.+)$/);
+	if (atSkillMatch && !input.includes(":") && !input.startsWith(".") && !input.startsWith("/")) {
+		const [, owner, repo, skillFilter] = atSkillMatch;
+		return {
+			type: "github",
+			url: `https://github.com/${owner}/${repo}.git`,
+			skillFilter
+		};
+	}
+	const shorthandMatch = input.match(/^([^/]+)\/([^/]+)(?:\/(.+))?$/);
+	if (shorthandMatch && !input.includes(":") && !input.startsWith(".") && !input.startsWith("/")) {
+		const [, owner, repo, subpath] = shorthandMatch;
+		return {
+			type: "github",
+			url: `https://github.com/${owner}/${repo}.git`,
+			subpath
+		};
+	}
+	if (isWellKnownUrl(input)) return {
+		type: "well-known",
+		url: input
+	};
+	return {
+		type: "git",
+		url: input
+	};
+}
+function isWellKnownUrl(input) {
+	if (!input.startsWith("http://") && !input.startsWith("https://")) return false;
+	try {
+		const parsed = new URL(input);
+		if ([
+			"github.com",
+			"gitlab.com",
+			"huggingface.co",
+			"raw.githubusercontent.com"
+		].includes(parsed.hostname)) return false;
+		if (input.toLowerCase().endsWith("/skill.md")) return false;
+		if (input.endsWith(".git")) return false;
+		return true;
+	} catch {
+		return false;
+	}
+}
+const silentOutput = new Writable({ write(_chunk, _encoding, callback) {
+	callback();
+} });
+const S_STEP_ACTIVE = import_picocolors.default.green("◆");
+const S_STEP_CANCEL = import_picocolors.default.red("■");
+const S_STEP_SUBMIT = import_picocolors.default.green("◇");
+const S_RADIO_ACTIVE = import_picocolors.default.green("●");
+const S_RADIO_INACTIVE = import_picocolors.default.dim("○");
+const S_BAR = import_picocolors.default.dim("│");
+const cancelSymbol = Symbol("cancel");
+async function searchMultiselect(options) {
+	const { message, items, maxVisible = 8, initialSelected = [] } = options;
+	return new Promise((resolve) => {
+		const rl = readline.createInterface({
+			input: process.stdin,
+			output: silentOutput,
+			terminal: false
+		});
+		if (process.stdin.isTTY) process.stdin.setRawMode(true);
+		readline.emitKeypressEvents(process.stdin, rl);
+		let query = "";
+		let cursor = 0;
+		const selected = new Set(initialSelected);
+		let lastRenderHeight = 0;
+		const filter = (item, q) => {
+			if (!q) return true;
+			const lowerQ = q.toLowerCase();
+			return item.label.toLowerCase().includes(lowerQ) || String(item.value).toLowerCase().includes(lowerQ);
+		};
+		const getFiltered = () => {
+			return items.filter((item) => filter(item, query));
+		};
+		const clearRender = () => {
+			if (lastRenderHeight > 0) {
+				process.stdout.write(`\x1b[${lastRenderHeight}A`);
+				for (let i = 0; i < lastRenderHeight; i++) process.stdout.write("\x1B[2K\x1B[1B");
+				process.stdout.write(`\x1b[${lastRenderHeight}A`);
+			}
+		};
+		const render = (state = "active") => {
+			clearRender();
+			const lines = [];
+			const filtered = getFiltered();
+			const icon = state === "active" ? S_STEP_ACTIVE : state === "cancel" ? S_STEP_CANCEL : S_STEP_SUBMIT;
+			lines.push(`${icon}  ${import_picocolors.default.bold(message)}`);
+			if (state === "active") {
+				const searchLine = `${S_BAR}  ${import_picocolors.default.dim("Search:")} ${query}${import_picocolors.default.inverse(" ")}`;
+				lines.push(searchLine);
+				lines.push(`${S_BAR}  ${import_picocolors.default.dim("↑↓ move, space select, enter confirm")}`);
+				lines.push(`${S_BAR}`);
+				const visibleStart = Math.max(0, Math.min(cursor - Math.floor(maxVisible / 2), filtered.length - maxVisible));
+				const visibleEnd = Math.min(filtered.length, visibleStart + maxVisible);
+				const visibleItems = filtered.slice(visibleStart, visibleEnd);
+				if (filtered.length === 0) lines.push(`${S_BAR}  ${import_picocolors.default.dim("No matches found")}`);
+				else {
+					for (let i = 0; i < visibleItems.length; i++) {
+						const item = visibleItems[i];
+						const actualIndex = visibleStart + i;
+						const isSelected = selected.has(item.value);
+						const isCursor = actualIndex === cursor;
+						const radio = isSelected ? S_RADIO_ACTIVE : S_RADIO_INACTIVE;
+						const label = isCursor ? import_picocolors.default.underline(item.label) : item.label;
+						const hint = item.hint ? import_picocolors.default.dim(` (${item.hint})`) : "";
+						const prefix = isCursor ? import_picocolors.default.cyan("❯") : " ";
+						lines.push(`${S_BAR} ${prefix} ${radio} ${label}${hint}`);
+					}
+					const hiddenBefore = visibleStart;
+					const hiddenAfter = filtered.length - visibleEnd;
+					if (hiddenBefore > 0 || hiddenAfter > 0) {
+						const parts = [];
+						if (hiddenBefore > 0) parts.push(`↑ ${hiddenBefore} more`);
+						if (hiddenAfter > 0) parts.push(`↓ ${hiddenAfter} more`);
+						lines.push(`${S_BAR}  ${import_picocolors.default.dim(parts.join("  "))}`);
+					}
+				}
+				lines.push(`${S_BAR}`);
+				if (selected.size === 0) lines.push(`${S_BAR}  ${import_picocolors.default.dim("Selected: (none)")}`);
+				else {
+					const selectedLabels = items.filter((item) => selected.has(item.value)).map((item) => item.label);
+					const summary = selectedLabels.length <= 3 ? selectedLabels.join(", ") : `${selectedLabels.slice(0, 3).join(", ")} +${selectedLabels.length - 3} more`;
+					lines.push(`${S_BAR}  ${import_picocolors.default.green("Selected:")} ${summary}`);
+				}
+				lines.push(`${import_picocolors.default.dim("└")}`);
+			} else if (state === "submit") {
+				const selectedLabels = items.filter((item) => selected.has(item.value)).map((item) => item.label);
+				lines.push(`${S_BAR}  ${import_picocolors.default.dim(selectedLabels.join(", "))}`);
+			} else if (state === "cancel") lines.push(`${S_BAR}  ${import_picocolors.default.strikethrough(import_picocolors.default.dim("Cancelled"))}`);
+			process.stdout.write(lines.join("\n") + "\n");
+			lastRenderHeight = lines.length;
+		};
+		const cleanup = () => {
+			process.stdin.removeListener("keypress", keypressHandler);
+			if (process.stdin.isTTY) process.stdin.setRawMode(false);
+			rl.close();
+		};
+		const submit = () => {
+			render("submit");
+			cleanup();
+			resolve(Array.from(selected));
+		};
+		const cancel = () => {
+			render("cancel");
+			cleanup();
+			resolve(cancelSymbol);
+		};
+		const keypressHandler = (_str, key) => {
+			if (!key) return;
+			const filtered = getFiltered();
+			if (key.name === "return") {
+				submit();
+				return;
+			}
+			if (key.name === "escape" || key.ctrl && key.name === "c") {
+				cancel();
+				return;
+			}
+			if (key.name === "up") {
+				cursor = Math.max(0, cursor - 1);
+				render();
+				return;
+			}
+			if (key.name === "down") {
+				cursor = Math.min(filtered.length - 1, cursor + 1);
+				render();
+				return;
+			}
+			if (key.name === "space") {
+				const item = filtered[cursor];
+				if (item) if (selected.has(item.value)) selected.delete(item.value);
+				else selected.add(item.value);
+				render();
+				return;
+			}
+			if (key.name === "backspace") {
+				query = query.slice(0, -1);
+				cursor = 0;
+				render();
+				return;
+			}
+			if (key.sequence && !key.ctrl && !key.meta && key.sequence.length === 1) {
+				query += key.sequence;
+				cursor = 0;
+				render();
+				return;
+			}
+		};
+		process.stdin.on("keypress", keypressHandler);
+		render();
+	});
+}
+const CLONE_TIMEOUT_MS = 6e4;
+var GitCloneError = class extends Error {
+	url;
+	isTimeout;
+	isAuthError;
+	constructor(message, url, isTimeout = false, isAuthError = false) {
+		super(message);
+		this.name = "GitCloneError";
+		this.url = url;
+		this.isTimeout = isTimeout;
+		this.isAuthError = isAuthError;
+	}
+};
+async function cloneRepo(url, ref) {
+	const tempDir = await mkdtemp(join(tmpdir(), "skills-"));
+	const git = esm_default({ timeout: { block: CLONE_TIMEOUT_MS } });
+	const cloneOptions = ref ? [
+		"--depth",
+		"1",
+		"--branch",
+		ref
+	] : ["--depth", "1"];
+	try {
+		await git.clone(url, tempDir, cloneOptions);
+		return tempDir;
+	} catch (error) {
+		await rm(tempDir, {
+			recursive: true,
+			force: true
+		}).catch(() => {});
+		const errorMessage = error instanceof Error ? error.message : String(error);
+		const isTimeout = errorMessage.includes("block timeout") || errorMessage.includes("timed out");
+		const isAuthError = errorMessage.includes("Authentication failed") || errorMessage.includes("could not read Username") || errorMessage.includes("Permission denied") || errorMessage.includes("Repository not found");
+		if (isTimeout) throw new GitCloneError("Clone timed out after 60s. This often happens with private repos that require authentication.\n  Ensure you have access and your SSH keys or credentials are configured:\n  - For SSH: ssh-add -l (to check loaded keys)\n  - For HTTPS: gh auth status (if using GitHub CLI)", url, true, false);
+		if (isAuthError) throw new GitCloneError(`Authentication failed for ${url}.\n  - For private repos, ensure you have access\n  - For SSH: Check your keys with 'ssh -T git@github.com'\n  - For HTTPS: Run 'gh auth login' or configure git credentials`, url, false, true);
+		throw new GitCloneError(`Failed to clone ${url}: ${errorMessage}`, url, false, false);
+	}
+}
+async function cleanupTempDir(dir) {
+	const normalizedDir = normalize(resolve(dir));
+	const normalizedTmpDir = normalize(resolve(tmpdir()));
+	if (!normalizedDir.startsWith(normalizedTmpDir + sep) && normalizedDir !== normalizedTmpDir) throw new Error("Attempted to clean up directory outside of temp directory");
+	await rm(dir, {
+		recursive: true,
+		force: true
+	});
+}
+var import_gray_matter = /* @__PURE__ */ __toESM(require_gray_matter(), 1);
+const SKIP_DIRS = [
+	"node_modules",
+	".git",
+	"dist",
+	"build",
+	"__pycache__"
+];
+function shouldInstallInternalSkills() {
+	const envValue = process.env.INSTALL_INTERNAL_SKILLS;
+	return envValue === "1" || envValue === "true";
+}
+async function hasSkillMd(dir) {
+	try {
+		return (await stat(join(dir, "SKILL.md"))).isFile();
+	} catch {
+		return false;
+	}
+}
+async function parseSkillMd(skillMdPath, options) {
+	try {
+		const content = await readFile(skillMdPath, "utf-8");
+		const { data } = (0, import_gray_matter.default)(content);
+		if (!data.name || !data.description) return null;
+		if (data.metadata?.internal === true && !shouldInstallInternalSkills() && !options?.includeInternal) return null;
+		return {
+			name: data.name,
+			description: data.description,
+			path: dirname(skillMdPath),
+			rawContent: content,
+			metadata: data.metadata
+		};
+	} catch {
+		return null;
+	}
+}
+async function findSkillDirs(dir, depth = 0, maxDepth = 5) {
+	if (depth > maxDepth) return [];
+	try {
+		const [hasSkill, entries] = await Promise.all([hasSkillMd(dir), readdir(dir, { withFileTypes: true }).catch(() => [])]);
+		const currentDir = hasSkill ? [dir] : [];
+		const subDirResults = await Promise.all(entries.filter((entry) => entry.isDirectory() && !SKIP_DIRS.includes(entry.name)).map((entry) => findSkillDirs(join(dir, entry.name), depth + 1, maxDepth)));
+		return [...currentDir, ...subDirResults.flat()];
+	} catch {
+		return [];
+	}
+}
+async function discoverSkills(basePath, subpath, options) {
+	const skills = [];
+	const seenNames = /* @__PURE__ */ new Set();
+	const searchPath = subpath ? join(basePath, subpath) : basePath;
+	if (await hasSkillMd(searchPath)) {
+		const skill = await parseSkillMd(join(searchPath, "SKILL.md"), options);
+		if (skill) {
+			skills.push(skill);
+			seenNames.add(skill.name);
+			if (!options?.fullDepth) return skills;
+		}
+	}
+	const prioritySearchDirs = [
+		searchPath,
+		join(searchPath, "skills"),
+		join(searchPath, "skills/.curated"),
+		join(searchPath, "skills/.experimental"),
+		join(searchPath, "skills/.system"),
+		join(searchPath, ".agent/skills"),
+		join(searchPath, ".agents/skills"),
+		join(searchPath, ".claude/skills"),
+		join(searchPath, ".cline/skills"),
+		join(searchPath, ".codebuddy/skills"),
+		join(searchPath, ".codex/skills"),
+		join(searchPath, ".commandcode/skills"),
+		join(searchPath, ".continue/skills"),
+		join(searchPath, ".cursor/skills"),
+		join(searchPath, ".github/skills"),
+		join(searchPath, ".goose/skills"),
+		join(searchPath, ".iflow/skills"),
+		join(searchPath, ".junie/skills"),
+		join(searchPath, ".kilocode/skills"),
+		join(searchPath, ".kiro/skills"),
+		join(searchPath, ".mux/skills"),
+		join(searchPath, ".neovate/skills"),
+		join(searchPath, ".openclaude/skills"),
+		join(searchPath, ".opencode/skills"),
+		join(searchPath, ".openhands/skills"),
+		join(searchPath, ".pi/skills"),
+		join(searchPath, ".qoder/skills"),
+		join(searchPath, ".roo/skills"),
+		join(searchPath, ".trae/skills"),
+		join(searchPath, ".windsurf/skills"),
+		join(searchPath, ".zencoder/skills")
+	];
+	for (const dir of prioritySearchDirs) try {
+		const entries = await readdir(dir, { withFileTypes: true });
+		for (const entry of entries) if (entry.isDirectory()) {
+			const skillDir = join(dir, entry.name);
+			if (await hasSkillMd(skillDir)) {
+				const skill = await parseSkillMd(join(skillDir, "SKILL.md"), options);
+				if (skill && !seenNames.has(skill.name)) {
+					skills.push(skill);
+					seenNames.add(skill.name);
+				}
+			}
+		}
+	} catch {}
+	if (skills.length === 0) {
+		const allSkillDirs = await findSkillDirs(searchPath);
+		for (const skillDir of allSkillDirs) {
+			const skill = await parseSkillMd(join(skillDir, "SKILL.md"), options);
+			if (skill && !seenNames.has(skill.name)) {
+				skills.push(skill);
+				seenNames.add(skill.name);
+			}
+		}
+	}
+	return skills;
+}
+function getSkillDisplayName(skill) {
+	return skill.name || basename(skill.path);
+}
+function filterSkills(skills, inputNames) {
+	const normalizedInputs = inputNames.map((n) => n.toLowerCase());
+	return skills.filter((skill) => {
+		const name = skill.name.toLowerCase();
+		const displayName = getSkillDisplayName(skill).toLowerCase();
+		return normalizedInputs.some((input) => input === name || input === displayName);
+	});
+}
+const home = homedir();
+const configHome = xdgConfig ?? join(home, ".config");
+const codexHome = process.env.CODEX_HOME?.trim() || join(home, ".codex");
+const claudeHome = process.env.CLAUDE_CONFIG_DIR?.trim() || join(home, ".claude");
+const agents = {
+	amp: {
+		name: "amp",
+		displayName: "Amp",
+		skillsDir: ".agents/skills",
+		globalSkillsDir: join(configHome, "agents/skills"),
+		detectInstalled: async () => {
+			return existsSync(join(configHome, "amp"));
+		}
+	},
+	antigravity: {
+		name: "antigravity",
+		displayName: "Antigravity",
+		skillsDir: ".agent/skills",
+		globalSkillsDir: join(home, ".gemini/antigravity/global_skills"),
+		detectInstalled: async () => {
+			return existsSync(join(process.cwd(), ".agent")) || existsSync(join(home, ".gemini/antigravity"));
+		}
+	},
+	augment: {
+		name: "augment",
+		displayName: "Augment",
+		skillsDir: ".augment/rules",
+		globalSkillsDir: join(home, ".augment/rules"),
+		detectInstalled: async () => {
+			return existsSync(join(home, ".augment"));
+		}
+	},
+	"claude-code": {
+		name: "claude-code",
+		displayName: "Claude Code",
+		skillsDir: ".claude/skills",
+		globalSkillsDir: join(claudeHome, "skills"),
+		detectInstalled: async () => {
+			return existsSync(claudeHome);
+		}
+	},
+	openclaw: {
+		name: "openclaw",
+		displayName: "OpenClaw",
+		skillsDir: "skills",
+		globalSkillsDir: existsSync(join(home, ".openclaw")) ? join(home, ".openclaw/skills") : existsSync(join(home, ".clawdbot")) ? join(home, ".clawdbot/skills") : join(home, ".moltbot/skills"),
+		detectInstalled: async () => {
+			return existsSync(join(home, ".openclaw")) || existsSync(join(home, ".clawdbot")) || existsSync(join(home, ".moltbot"));
+		}
+	},
+	cline: {
+		name: "cline",
+		displayName: "Cline",
+		skillsDir: ".cline/skills",
+		globalSkillsDir: join(home, ".cline/skills"),
+		detectInstalled: async () => {
+			return existsSync(join(home, ".cline"));
+		}
+	},
+	codebuddy: {
+		name: "codebuddy",
+		displayName: "CodeBuddy",
+		skillsDir: ".codebuddy/skills",
+		globalSkillsDir: join(home, ".codebuddy/skills"),
+		detectInstalled: async () => {
+			return existsSync(join(process.cwd(), ".codebuddy")) || existsSync(join(home, ".codebuddy"));
+		}
+	},
+	codex: {
+		name: "codex",
+		displayName: "Codex",
+		skillsDir: ".codex/skills",
+		globalSkillsDir: join(codexHome, "skills"),
+		detectInstalled: async () => {
+			return existsSync(codexHome) || existsSync("/etc/codex");
+		}
+	},
+	"command-code": {
+		name: "command-code",
+		displayName: "Command Code",
+		skillsDir: ".commandcode/skills",
+		globalSkillsDir: join(home, ".commandcode/skills"),
+		detectInstalled: async () => {
+			return existsSync(join(home, ".commandcode"));
+		}
+	},
+	continue: {
+		name: "continue",
+		displayName: "Continue",
+		skillsDir: ".continue/skills",
+		globalSkillsDir: join(home, ".continue/skills"),
+		detectInstalled: async () => {
+			return existsSync(join(process.cwd(), ".continue")) || existsSync(join(home, ".continue"));
+		}
+	},
+	crush: {
+		name: "crush",
+		displayName: "Crush",
+		skillsDir: ".crush/skills",
+		globalSkillsDir: join(home, ".config/crush/skills"),
+		detectInstalled: async () => {
+			return existsSync(join(home, ".config/crush"));
+		}
+	},
+	cursor: {
+		name: "cursor",
+		displayName: "Cursor",
+		skillsDir: ".cursor/skills",
+		globalSkillsDir: join(home, ".cursor/skills"),
+		detectInstalled: async () => {
+			return existsSync(join(home, ".cursor"));
+		}
+	},
+	droid: {
+		name: "droid",
+		displayName: "Droid",
+		skillsDir: ".factory/skills",
+		globalSkillsDir: join(home, ".factory/skills"),
+		detectInstalled: async () => {
+			return existsSync(join(home, ".factory"));
+		}
+	},
+	"gemini-cli": {
+		name: "gemini-cli",
+		displayName: "Gemini CLI",
+		skillsDir: ".gemini/skills",
+		globalSkillsDir: join(home, ".gemini/skills"),
+		detectInstalled: async () => {
+			return existsSync(join(home, ".gemini"));
+		}
+	},
+	"github-copilot": {
+		name: "github-copilot",
+		displayName: "GitHub Copilot",
+		skillsDir: ".github/skills",
+		globalSkillsDir: join(home, ".copilot/skills"),
+		detectInstalled: async () => {
+			return existsSync(join(process.cwd(), ".github")) || existsSync(join(home, ".copilot"));
+		}
+	},
+	goose: {
+		name: "goose",
+		displayName: "Goose",
+		skillsDir: ".goose/skills",
+		globalSkillsDir: join(configHome, "goose/skills"),
+		detectInstalled: async () => {
+			return existsSync(join(configHome, "goose"));
+		}
+	},
+	junie: {
+		name: "junie",
+		displayName: "Junie",
+		skillsDir: ".junie/skills",
+		globalSkillsDir: join(home, ".junie/skills"),
+		detectInstalled: async () => {
+			return existsSync(join(home, ".junie"));
+		}
+	},
+	"iflow-cli": {
+		name: "iflow-cli",
+		displayName: "iFlow CLI",
+		skillsDir: ".iflow/skills",
+		globalSkillsDir: join(home, ".iflow/skills"),
+		detectInstalled: async () => {
+			return existsSync(join(home, ".iflow"));
+		}
+	},
+	kilo: {
+		name: "kilo",
+		displayName: "Kilo Code",
+		skillsDir: ".kilocode/skills",
+		globalSkillsDir: join(home, ".kilocode/skills"),
+		detectInstalled: async () => {
+			return existsSync(join(home, ".kilocode"));
+		}
+	},
+	"kimi-cli": {
+		name: "kimi-cli",
+		displayName: "Kimi Code CLI",
+		skillsDir: ".agents/skills",
+		globalSkillsDir: join(home, ".config/agents/skills"),
+		detectInstalled: async () => {
+			return existsSync(join(home, ".kimi"));
+		}
+	},
+	"kiro-cli": {
+		name: "kiro-cli",
+		displayName: "Kiro CLI",
+		skillsDir: ".kiro/skills",
+		globalSkillsDir: join(home, ".kiro/skills"),
+		detectInstalled: async () => {
+			return existsSync(join(home, ".kiro"));
+		}
+	},
+	kode: {
+		name: "kode",
+		displayName: "Kode",
+		skillsDir: ".kode/skills",
+		globalSkillsDir: join(home, ".kode/skills"),
+		detectInstalled: async () => {
+			return existsSync(join(home, ".kode"));
+		}
+	},
+	mcpjam: {
+		name: "mcpjam",
+		displayName: "MCPJam",
+		skillsDir: ".mcpjam/skills",
+		globalSkillsDir: join(home, ".mcpjam/skills"),
+		detectInstalled: async () => {
+			return existsSync(join(home, ".mcpjam"));
+		}
+	},
+	"mistral-vibe": {
+		name: "mistral-vibe",
+		displayName: "Mistral Vibe",
+		skillsDir: ".vibe/skills",
+		globalSkillsDir: join(home, ".vibe/skills"),
+		detectInstalled: async () => {
+			return existsSync(join(home, ".vibe"));
+		}
+	},
+	mux: {
+		name: "mux",
+		displayName: "Mux",
+		skillsDir: ".mux/skills",
+		globalSkillsDir: join(home, ".mux/skills"),
+		detectInstalled: async () => {
+			return existsSync(join(home, ".mux"));
+		}
+	},
+	opencode: {
+		name: "opencode",
+		displayName: "OpenCode",
+		skillsDir: ".opencode/skills",
+		globalSkillsDir: join(configHome, "opencode/skills"),
+		detectInstalled: async () => {
+			return existsSync(join(configHome, "opencode")) || existsSync(join(claudeHome, "skills"));
+		}
+	},
+	openclaude: {
+		name: "openclaude",
+		displayName: "OpenClaude IDE",
+		skillsDir: ".openclaude/skills",
+		globalSkillsDir: join(home, ".openclaude/skills"),
+		detectInstalled: async () => {
+			return existsSync(join(home, ".openclaude")) || existsSync(join(process.cwd(), ".openclaude"));
+		}
+	},
+	openhands: {
+		name: "openhands",
+		displayName: "OpenHands",
+		skillsDir: ".openhands/skills",
+		globalSkillsDir: join(home, ".openhands/skills"),
+		detectInstalled: async () => {
+			return existsSync(join(home, ".openhands"));
+		}
+	},
+	pi: {
+		name: "pi",
+		displayName: "Pi",
+		skillsDir: ".pi/skills",
+		globalSkillsDir: join(home, ".pi/agent/skills"),
+		detectInstalled: async () => {
+			return existsSync(join(home, ".pi/agent"));
+		}
+	},
+	qoder: {
+		name: "qoder",
+		displayName: "Qoder",
+		skillsDir: ".qoder/skills",
+		globalSkillsDir: join(home, ".qoder/skills"),
+		detectInstalled: async () => {
+			return existsSync(join(home, ".qoder"));
+		}
+	},
+	"qwen-code": {
+		name: "qwen-code",
+		displayName: "Qwen Code",
+		skillsDir: ".qwen/skills",
+		globalSkillsDir: join(home, ".qwen/skills"),
+		detectInstalled: async () => {
+			return existsSync(join(home, ".qwen"));
+		}
+	},
+	replit: {
+		name: "replit",
+		displayName: "Replit",
+		skillsDir: ".agent/skills",
+		globalSkillsDir: void 0,
+		detectInstalled: async () => {
+			return existsSync(join(process.cwd(), ".agent"));
+		}
+	},
+	roo: {
+		name: "roo",
+		displayName: "Roo Code",
+		skillsDir: ".roo/skills",
+		globalSkillsDir: join(home, ".roo/skills"),
+		detectInstalled: async () => {
+			return existsSync(join(home, ".roo"));
+		}
+	},
+	trae: {
+		name: "trae",
+		displayName: "Trae",
+		skillsDir: ".trae/skills",
+		globalSkillsDir: join(home, ".trae/skills"),
+		detectInstalled: async () => {
+			return existsSync(join(home, ".trae"));
+		}
+	},
+	"trae-cn": {
+		name: "trae-cn",
+		displayName: "Trae CN",
+		skillsDir: ".trae/skills",
+		globalSkillsDir: join(home, ".trae-cn/skills"),
+		detectInstalled: async () => {
+			return existsSync(join(home, ".trae-cn"));
+		}
+	},
+	windsurf: {
+		name: "windsurf",
+		displayName: "Windsurf",
+		skillsDir: ".windsurf/skills",
+		globalSkillsDir: join(home, ".codeium/windsurf/skills"),
+		detectInstalled: async () => {
+			return existsSync(join(home, ".codeium/windsurf"));
+		}
+	},
+	zencoder: {
+		name: "zencoder",
+		displayName: "Zencoder",
+		skillsDir: ".zencoder/skills",
+		globalSkillsDir: join(home, ".zencoder/skills"),
+		detectInstalled: async () => {
+			return existsSync(join(home, ".zencoder"));
+		}
+	},
+	neovate: {
+		name: "neovate",
+		displayName: "Neovate",
+		skillsDir: ".neovate/skills",
+		globalSkillsDir: join(home, ".neovate/skills"),
+		detectInstalled: async () => {
+			return existsSync(join(home, ".neovate"));
+		}
+	},
+	pochi: {
+		name: "pochi",
+		displayName: "Pochi",
+		skillsDir: ".pochi/skills",
+		globalSkillsDir: join(home, ".pochi/skills"),
+		detectInstalled: async () => {
+			return existsSync(join(home, ".pochi"));
+		}
+	},
+	adal: {
+		name: "adal",
+		displayName: "AdaL",
+		skillsDir: ".adal/skills",
+		globalSkillsDir: join(home, ".adal/skills"),
+		detectInstalled: async () => {
+			return existsSync(join(home, ".adal"));
+		}
+	}
+};
+async function detectInstalledAgents() {
+	return (await Promise.all(Object.entries(agents).map(async ([type, config]) => ({
+		type,
+		installed: await config.detectInstalled()
+	})))).filter((r) => r.installed).map((r) => r.type);
+}
+const AGENTS_DIR$2 = ".agents";
+const SKILLS_SUBDIR = "skills";
+function sanitizeName(name) {
+	return name.toLowerCase().replace(/[^a-z0-9._]+/g, "-").replace(/^[.\-]+|[.\-]+$/g, "").substring(0, 255) || "unnamed-skill";
+}
+function isPathSafe(basePath, targetPath) {
+	const normalizedBase = normalize(resolve(basePath));
+	const normalizedTarget = normalize(resolve(targetPath));
+	return normalizedTarget.startsWith(normalizedBase + sep) || normalizedTarget === normalizedBase;
+}
+function getCanonicalSkillsDir(global, cwd) {
+	return join(global ? homedir() : cwd || process.cwd(), AGENTS_DIR$2, SKILLS_SUBDIR);
+}
+function resolveSymlinkTarget(linkPath, linkTarget) {
+	return resolve(dirname(linkPath), linkTarget);
+}
+async function cleanAndCreateDirectory(path) {
+	try {
+		await rm(path, {
+			recursive: true,
+			force: true
+		});
+	} catch {}
+	await mkdir(path, { recursive: true });
+}
+async function createSymlink(target, linkPath) {
+	try {
+		const resolvedTarget = resolve(target);
+		if (resolvedTarget === resolve(linkPath)) return true;
+		try {
+			if ((await lstat(linkPath)).isSymbolicLink()) {
+				if (resolveSymlinkTarget(linkPath, await readlink(linkPath)) === resolvedTarget) return true;
+				await rm(linkPath);
+			} else await rm(linkPath, { recursive: true });
+		} catch (err) {
+			if (err && typeof err === "object" && "code" in err && err.code === "ELOOP") try {
+				await rm(linkPath, { force: true });
+			} catch {}
+		}
+		const linkDir = dirname(linkPath);
+		await mkdir(linkDir, { recursive: true });
+		await symlink(relative(linkDir, target), linkPath, platform() === "win32" ? "junction" : void 0);
+		return true;
+	} catch {
+		return false;
+	}
+}
+async function installSkillForAgent(skill, agentType, options = {}) {
+	const agent = agents[agentType];
+	const isGlobal = options.global ?? false;
+	const cwd = options.cwd || process.cwd();
+	if (isGlobal && agent.globalSkillsDir === void 0) return {
+		success: false,
+		path: "",
+		mode: options.mode ?? "symlink",
+		error: `${agent.displayName} does not support global skill installation`
+	};
+	const skillName = sanitizeName(skill.name || basename(skill.path));
+	const canonicalBase = getCanonicalSkillsDir(isGlobal, cwd);
+	const canonicalDir = join(canonicalBase, skillName);
+	const agentBase = isGlobal ? agent.globalSkillsDir : join(cwd, agent.skillsDir);
+	const agentDir = join(agentBase, skillName);
+	const installMode = options.mode ?? "symlink";
+	if (!isPathSafe(canonicalBase, canonicalDir)) return {
+		success: false,
+		path: agentDir,
+		mode: installMode,
+		error: "Invalid skill name: potential path traversal detected"
+	};
+	if (!isPathSafe(agentBase, agentDir)) return {
+		success: false,
+		path: agentDir,
+		mode: installMode,
+		error: "Invalid skill name: potential path traversal detected"
+	};
+	try {
+		if (installMode === "copy") {
+			await cleanAndCreateDirectory(agentDir);
+			await copyDirectory(skill.path, agentDir);
+			return {
+				success: true,
+				path: agentDir,
+				mode: "copy"
+			};
+		}
+		await cleanAndCreateDirectory(canonicalDir);
+		await copyDirectory(skill.path, canonicalDir);
+		if (!await createSymlink(canonicalDir, agentDir)) {
+			await cleanAndCreateDirectory(agentDir);
+			await copyDirectory(skill.path, agentDir);
+			return {
+				success: true,
+				path: agentDir,
+				canonicalPath: canonicalDir,
+				mode: "symlink",
+				symlinkFailed: true
+			};
+		}
+		return {
+			success: true,
+			path: agentDir,
+			canonicalPath: canonicalDir,
+			mode: "symlink"
+		};
+	} catch (error) {
+		return {
+			success: false,
+			path: agentDir,
+			mode: installMode,
+			error: error instanceof Error ? error.message : "Unknown error"
+		};
+	}
+}
+const EXCLUDE_FILES = new Set(["README.md", "metadata.json"]);
+const EXCLUDE_DIRS = new Set([".git"]);
+const isExcluded = (name, isDirectory = false) => {
+	if (EXCLUDE_FILES.has(name)) return true;
+	if (name.startsWith("_")) return true;
+	if (isDirectory && EXCLUDE_DIRS.has(name)) return true;
+	return false;
+};
+async function copyDirectory(src, dest) {
+	await mkdir(dest, { recursive: true });
+	const entries = await readdir(src, { withFileTypes: true });
+	await Promise.all(entries.filter((entry) => !isExcluded(entry.name, entry.isDirectory())).map(async (entry) => {
+		const srcPath = join(src, entry.name);
+		const destPath = join(dest, entry.name);
+		if (entry.isDirectory()) await copyDirectory(srcPath, destPath);
+		else await cp(srcPath, destPath, {
+			dereference: true,
+			recursive: true
+		});
+	}));
+}
+async function isSkillInstalled(skillName, agentType, options = {}) {
+	const agent = agents[agentType];
+	const sanitized = sanitizeName(skillName);
+	if (options.global && agent.globalSkillsDir === void 0) return false;
+	const targetBase = options.global ? agent.globalSkillsDir : join(options.cwd || process.cwd(), agent.skillsDir);
+	const skillDir = join(targetBase, sanitized);
+	if (!isPathSafe(targetBase, skillDir)) return false;
+	try {
+		await access(skillDir);
+		return true;
+	} catch {
+		return false;
+	}
+}
+function getInstallPath(skillName, agentType, options = {}) {
+	const agent = agents[agentType];
+	const cwd = options.cwd || process.cwd();
+	const sanitized = sanitizeName(skillName);
+	const targetBase = options.global && agent.globalSkillsDir !== void 0 ? agent.globalSkillsDir : join(cwd, agent.skillsDir);
+	const installPath = join(targetBase, sanitized);
+	if (!isPathSafe(targetBase, installPath)) throw new Error("Invalid skill name: potential path traversal detected");
+	return installPath;
+}
+function getCanonicalPath(skillName, options = {}) {
+	const sanitized = sanitizeName(skillName);
+	const canonicalBase = getCanonicalSkillsDir(options.global ?? false, options.cwd);
+	const canonicalPath = join(canonicalBase, sanitized);
+	if (!isPathSafe(canonicalBase, canonicalPath)) throw new Error("Invalid skill name: potential path traversal detected");
+	return canonicalPath;
+}
+async function installRemoteSkillForAgent(skill, agentType, options = {}) {
+	const agent = agents[agentType];
+	const isGlobal = options.global ?? false;
+	const cwd = options.cwd || process.cwd();
+	const installMode = options.mode ?? "symlink";
+	if (isGlobal && agent.globalSkillsDir === void 0) return {
+		success: false,
+		path: "",
+		mode: installMode,
+		error: `${agent.displayName} does not support global skill installation`
+	};
+	const skillName = sanitizeName(skill.installName);
+	const canonicalBase = getCanonicalSkillsDir(isGlobal, cwd);
+	const canonicalDir = join(canonicalBase, skillName);
+	const agentBase = isGlobal ? agent.globalSkillsDir : join(cwd, agent.skillsDir);
+	const agentDir = join(agentBase, skillName);
+	if (!isPathSafe(canonicalBase, canonicalDir)) return {
+		success: false,
+		path: agentDir,
+		mode: installMode,
+		error: "Invalid skill name: potential path traversal detected"
+	};
+	if (!isPathSafe(agentBase, agentDir)) return {
+		success: false,
+		path: agentDir,
+		mode: installMode,
+		error: "Invalid skill name: potential path traversal detected"
+	};
+	try {
+		if (installMode === "copy") {
+			await cleanAndCreateDirectory(agentDir);
+			await writeFile(join(agentDir, "SKILL.md"), skill.content, "utf-8");
+			return {
+				success: true,
+				path: agentDir,
+				mode: "copy"
+			};
+		}
+		await cleanAndCreateDirectory(canonicalDir);
+		await writeFile(join(canonicalDir, "SKILL.md"), skill.content, "utf-8");
+		if (!await createSymlink(canonicalDir, agentDir)) {
+			await cleanAndCreateDirectory(agentDir);
+			await writeFile(join(agentDir, "SKILL.md"), skill.content, "utf-8");
+			return {
+				success: true,
+				path: agentDir,
+				canonicalPath: canonicalDir,
+				mode: "symlink",
+				symlinkFailed: true
+			};
+		}
+		return {
+			success: true,
+			path: agentDir,
+			canonicalPath: canonicalDir,
+			mode: "symlink"
+		};
+	} catch (error) {
+		return {
+			success: false,
+			path: agentDir,
+			mode: installMode,
+			error: error instanceof Error ? error.message : "Unknown error"
+		};
+	}
+}
+async function installZipSkillForAgent(skill, agentType, options = {}) {
+	const agent = agents[agentType];
+	const isGlobal = options.global ?? false;
+	const cwd = options.cwd || process.cwd();
+	const installMode = options.mode ?? "symlink";
+	if (isGlobal && agent.globalSkillsDir === void 0) return {
+		success: false,
+		path: "",
+		mode: installMode,
+		error: `${agent.displayName} does not support global skill installation`
+	};
+	const skillName = sanitizeName(skill.installName);
+	const canonicalBase = getCanonicalSkillsDir(isGlobal, cwd);
+	const canonicalDir = join(canonicalBase, skillName);
+	const agentBase = isGlobal ? agent.globalSkillsDir : join(cwd, agent.skillsDir);
+	const agentDir = join(agentBase, skillName);
+	if (!isPathSafe(canonicalBase, canonicalDir)) return {
+		success: false,
+		path: agentDir,
+		mode: installMode,
+		error: "Invalid skill name: potential path traversal detected"
+	};
+	if (!isPathSafe(agentBase, agentDir)) return {
+		success: false,
+		path: agentDir,
+		mode: installMode,
+		error: "Invalid skill name: potential path traversal detected"
+	};
+	async function writeSkillFiles(targetDir) {
+		for (const [filePath, content] of skill.files) {
+			const fullPath = join(targetDir, filePath);
+			if (!isPathSafe(targetDir, fullPath)) continue;
+			const parentDir = dirname(fullPath);
+			if (parentDir !== targetDir) await mkdir(parentDir, { recursive: true });
+			await writeFile(fullPath, content, "utf-8");
+		}
+	}
+	try {
+		if (installMode === "copy") {
+			await cleanAndCreateDirectory(agentDir);
+			await writeSkillFiles(agentDir);
+			return {
+				success: true,
+				path: agentDir,
+				mode: "copy"
+			};
+		}
+		await cleanAndCreateDirectory(canonicalDir);
+		await writeSkillFiles(canonicalDir);
+		if (!await createSymlink(canonicalDir, agentDir)) {
+			await cleanAndCreateDirectory(agentDir);
+			await writeSkillFiles(agentDir);
+			return {
+				success: true,
+				path: agentDir,
+				canonicalPath: canonicalDir,
+				mode: "symlink",
+				symlinkFailed: true
+			};
+		}
+		return {
+			success: true,
+			path: agentDir,
+			canonicalPath: canonicalDir,
+			mode: "symlink"
+		};
+	} catch (error) {
+		return {
+			success: false,
+			path: agentDir,
+			mode: installMode,
+			error: error instanceof Error ? error.message : "Unknown error"
+		};
+	}
+}
+async function installWellKnownSkillForAgent(skill, agentType, options = {}) {
+	const agent = agents[agentType];
+	const isGlobal = options.global ?? false;
+	const cwd = options.cwd || process.cwd();
+	const installMode = options.mode ?? "symlink";
+	if (isGlobal && agent.globalSkillsDir === void 0) return {
+		success: false,
+		path: "",
+		mode: installMode,
+		error: `${agent.displayName} does not support global skill installation`
+	};
+	const skillName = sanitizeName(skill.installName);
+	const canonicalBase = getCanonicalSkillsDir(isGlobal, cwd);
+	const canonicalDir = join(canonicalBase, skillName);
+	const agentBase = isGlobal ? agent.globalSkillsDir : join(cwd, agent.skillsDir);
+	const agentDir = join(agentBase, skillName);
+	if (!isPathSafe(canonicalBase, canonicalDir)) return {
+		success: false,
+		path: agentDir,
+		mode: installMode,
+		error: "Invalid skill name: potential path traversal detected"
+	};
+	if (!isPathSafe(agentBase, agentDir)) return {
+		success: false,
+		path: agentDir,
+		mode: installMode,
+		error: "Invalid skill name: potential path traversal detected"
+	};
+	async function writeSkillFiles(targetDir) {
+		for (const [filePath, content] of skill.files) {
+			const fullPath = join(targetDir, filePath);
+			if (!isPathSafe(targetDir, fullPath)) continue;
+			const parentDir = dirname(fullPath);
+			if (parentDir !== targetDir) await mkdir(parentDir, { recursive: true });
+			await writeFile(fullPath, content, "utf-8");
+		}
+	}
+	try {
+		if (installMode === "copy") {
+			await cleanAndCreateDirectory(agentDir);
+			await writeSkillFiles(agentDir);
+			return {
+				success: true,
+				path: agentDir,
+				mode: "copy"
+			};
+		}
+		await cleanAndCreateDirectory(canonicalDir);
+		await writeSkillFiles(canonicalDir);
+		if (!await createSymlink(canonicalDir, agentDir)) {
+			await cleanAndCreateDirectory(agentDir);
+			await writeSkillFiles(agentDir);
+			return {
+				success: true,
+				path: agentDir,
+				canonicalPath: canonicalDir,
+				mode: "symlink",
+				symlinkFailed: true
+			};
+		}
+		return {
+			success: true,
+			path: agentDir,
+			canonicalPath: canonicalDir,
+			mode: "symlink"
+		};
+	} catch (error) {
+		return {
+			success: false,
+			path: agentDir,
+			mode: installMode,
+			error: error instanceof Error ? error.message : "Unknown error"
+		};
+	}
+}
+async function listInstalledSkills(options = {}) {
+	const cwd = options.cwd || process.cwd();
+	const installedSkills = [];
+	const scopes = [];
+	const detectedAgents = await detectInstalledAgents();
+	if (options.global === void 0) {
+		scopes.push({
+			global: false,
+			path: getCanonicalSkillsDir(false, cwd)
+		});
+		scopes.push({
+			global: true,
+			path: getCanonicalSkillsDir(true, cwd)
+		});
+	} else scopes.push({
+		global: options.global,
+		path: getCanonicalSkillsDir(options.global, cwd)
+	});
+	for (const scope of scopes) try {
+		const entries = await readdir(scope.path, { withFileTypes: true });
+		for (const entry of entries) {
+			if (!entry.isDirectory()) continue;
+			const skillDir = join(scope.path, entry.name);
+			const skillMdPath = join(skillDir, "SKILL.md");
+			try {
+				await stat(skillMdPath);
+			} catch {
+				continue;
+			}
+			const skill = await parseSkillMd(skillMdPath);
+			if (!skill) continue;
+			const sanitizedSkillName = sanitizeName(skill.name);
+			const installedAgents = [];
+			const agentFilter = options.agentFilter;
+			const agentsToCheck = agentFilter ? detectedAgents.filter((a) => agentFilter.includes(a)) : detectedAgents;
+			for (const agentType of agentsToCheck) {
+				const agent = agents[agentType];
+				if (scope.global && agent.globalSkillsDir === void 0) continue;
+				const agentBase = scope.global ? agent.globalSkillsDir : join(cwd, agent.skillsDir);
+				let found = false;
+				const possibleNames = [
+					entry.name,
+					sanitizedSkillName,
+					skill.name.toLowerCase().replace(/\s+/g, "-").replace(/[\/\\:\0]/g, "")
+				];
+				const uniqueNames = Array.from(new Set(possibleNames));
+				for (const possibleName of uniqueNames) {
+					const agentSkillDir = join(agentBase, possibleName);
+					if (!isPathSafe(agentBase, agentSkillDir)) continue;
+					try {
+						await access(agentSkillDir);
+						found = true;
+						break;
+					} catch {}
+				}
+				if (!found) try {
+					const agentEntries = await readdir(agentBase, { withFileTypes: true });
+					for (const agentEntry of agentEntries) {
+						if (!agentEntry.isDirectory()) continue;
+						const candidateDir = join(agentBase, agentEntry.name);
+						if (!isPathSafe(agentBase, candidateDir)) continue;
+						try {
+							const candidateSkillMd = join(candidateDir, "SKILL.md");
+							await stat(candidateSkillMd);
+							const candidateSkill = await parseSkillMd(candidateSkillMd);
+							if (candidateSkill && candidateSkill.name === skill.name) {
+								found = true;
+								break;
+							}
+						} catch {}
+					}
+				} catch {}
+				if (found) installedAgents.push(agentType);
+			}
+			installedSkills.push({
+				name: skill.name,
+				description: skill.description,
+				path: skillDir,
+				canonicalPath: skillDir,
+				scope: scope.global ? "global" : "project",
+				agents: installedAgents
+			});
+		}
+	} catch {}
+	return installedSkills;
+}
+const TELEMETRY_URL = "https://add-skill.vercel.sh/t";
+let cliVersion = null;
+function isCI() {
+	return !!(process.env.CI || process.env.GITHUB_ACTIONS || process.env.GITLAB_CI || process.env.CIRCLECI || process.env.TRAVIS || process.env.BUILDKITE || process.env.JENKINS_URL || process.env.TEAMCITY_VERSION);
+}
+function isEnabled() {
+	return !process.env.DISABLE_TELEMETRY && !process.env.DO_NOT_TRACK;
+}
+function setVersion(version) {
+	cliVersion = version;
+}
+function track(data) {
+	if (!isEnabled()) return;
+	try {
+		const params = new URLSearchParams();
+		if (cliVersion) params.set("v", cliVersion);
+		if (isCI()) params.set("ci", "1");
+		for (const [key, value] of Object.entries(data)) if (value !== void 0 && value !== null) params.set(key, String(value));
+		fetch(`${TELEMETRY_URL}?${params.toString()}`).catch(() => {});
+	} catch {}
+}
+var ProviderRegistryImpl = class {
+	providers = [];
+	register(provider) {
+		if (this.providers.some((p) => p.id === provider.id)) throw new Error(`Provider with id "${provider.id}" already registered`);
+		this.providers.push(provider);
+	}
+	findProvider(url) {
+		for (const provider of this.providers) if (provider.match(url).matches) return provider;
+		return null;
+	}
+	getProviders() {
+		return [...this.providers];
+	}
+};
+const registry = new ProviderRegistryImpl();
+function registerProvider(provider) {
+	registry.register(provider);
+}
+function findProvider(url) {
+	return registry.findProvider(url);
+}
+let tokenStorage = null;
+let clientStorage = null;
+async function getAuthFilePath() {
+	const os = await import("os");
+	return (await import("path")).join(os.homedir(), ".skills-auth");
+}
+async function loadAuthData() {
+	if (tokenStorage !== null && clientStorage !== null) return;
+	tokenStorage = /* @__PURE__ */ new Map();
+	clientStorage = /* @__PURE__ */ new Map();
+	try {
+		const fs = await import("fs/promises");
+		const authPath = await getAuthFilePath();
+		const data = await fs.readFile(authPath, "utf-8");
+		const parsed = JSON.parse(data);
+		if (parsed.tokens) for (const [key, value] of Object.entries(parsed.tokens)) tokenStorage.set(key, value);
+		if (parsed.clients) for (const [key, value] of Object.entries(parsed.clients)) clientStorage.set(key, value);
+	} catch {}
+}
+async function saveAuthData() {
+	if (!tokenStorage || !clientStorage) return;
+	try {
+		const fs = await import("fs/promises");
+		const authPath = await getAuthFilePath();
+		const data = {
+			tokens: Object.fromEntries(tokenStorage),
+			clients: Object.fromEntries(clientStorage)
+		};
+		await fs.writeFile(authPath, JSON.stringify(data, null, 2), { mode: 384 });
+	} catch {}
+}
+async function getTokenStorage() {
+	await loadAuthData();
+	return tokenStorage;
+}
+async function getClientStorage() {
+	await loadAuthData();
+	return clientStorage;
+}
+function generateCodeVerifier() {
+	const array = new Uint8Array(32);
+	crypto.getRandomValues(array);
+	return Array.from(array, (byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+async function generateCodeChallenge(verifier) {
+	const data = new TextEncoder().encode(verifier);
+	const hashBuffer = await crypto.subtle.digest("SHA-256", data);
+	const hashArray = new Uint8Array(hashBuffer);
+	return btoa(String.fromCharCode(...hashArray)).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+function parseWWWAuthenticateHeader(header) {
+	const challenge = {};
+	const bearerMatch = header.match(/Bearer\s+(.*)/i);
+	if (!bearerMatch) return challenge;
+	const params = bearerMatch[1];
+	const paramRegex = /(\w+)="([^"]*)"/g;
+	let match;
+	while ((match = paramRegex.exec(params)) !== null) {
+		const [, key, value] = match;
+		if (key === "error") challenge.error = value;
+		else if (key === "error_description") challenge.error_description = value;
+		else if (key === "resource_metadata") challenge.resource_metadata = value;
+	}
+	return challenge;
+}
+async function fetchProtectedResourceMetadata(metadataUrl) {
+	try {
+		const response = await fetch(metadataUrl, { signal: AbortSignal.timeout(1e4) });
+		if (!response.ok) return null;
+		return await response.json();
+	} catch {
+		return null;
+	}
+}
+async function fetchAuthServerMetadata(authServerUrl) {
+	try {
+		const parsed = new URL(authServerUrl);
+		const metadataUrl = `${parsed.protocol}//${parsed.host}/.well-known/oauth-authorization-server`;
+		const response = await fetch(metadataUrl, { signal: AbortSignal.timeout(1e4) });
+		if (!response.ok) return null;
+		return await response.json();
+	} catch {
+		return null;
+	}
+}
+async function registerOAuthClient(registrationEndpoint, redirectUri) {
+	try {
+		const clientMetadata = {
+			client_name: "skills-cli",
+			redirect_uris: [redirectUri],
+			grant_types: ["authorization_code"],
+			response_types: ["code"],
+			token_endpoint_auth_method: "none"
+		};
+		const response = await fetch(registrationEndpoint, {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify(clientMetadata),
+			signal: AbortSignal.timeout(1e4)
+		});
+		if (!response.ok) return null;
+		return await response.json();
+	} catch {
+		return null;
+	}
+}
+async function exchangeAuthorizationCode(tokenEndpoint, clientId, code, codeVerifier, redirectUri) {
+	try {
+		const params = new URLSearchParams({
+			grant_type: "authorization_code",
+			code,
+			client_id: clientId,
+			code_verifier: codeVerifier,
+			redirect_uri: redirectUri
+		});
+		const response = await fetch(tokenEndpoint, {
+			method: "POST",
+			headers: { "Content-Type": "application/x-www-form-urlencoded" },
+			body: params.toString(),
+			signal: AbortSignal.timeout(1e4)
+		});
+		if (!response.ok) return null;
+		return await response.json();
+	} catch {
+		return null;
+	}
+}
+async function startCallbackServer(port) {
+	const http = await import("http");
+	return new Promise((resolve, reject) => {
+		const server = http.createServer((req, res) => {
+			const url = new URL(req.url, `http://localhost:${port}`);
+			const code = url.searchParams.get("code");
+			const error = url.searchParams.get("error");
+			if (error) {
+				res.writeHead(400, { "Content-Type": "text/html" });
+				res.end(`
+          <html>
+            <body>
+              <h1>Authorization Failed</h1>
+              <p>Error: ${error}</p>
+              <p>You can close this window.</p>
+            </body>
+          </html>
+        `);
+				server.close();
+				reject(/* @__PURE__ */ new Error(`OAuth error: ${error}`));
+				return;
+			}
+			if (code) {
+				res.writeHead(200, { "Content-Type": "text/html" });
+				res.end(`
+          <html>
+            <body>
+              <h1>Authorization Successful</h1>
+              <p>You can close this window and return to the CLI.</p>
+            </body>
+          </html>
+        `);
+				server.close();
+				resolve(code);
+				return;
+			}
+			res.writeHead(400, { "Content-Type": "text/html" });
+			res.end("<html><body><h1>Invalid Request</h1></body></html>");
+		});
+		server.listen(port, "127.0.0.1", () => {});
+		setTimeout(() => {
+			server.close();
+			reject(/* @__PURE__ */ new Error("OAuth callback timeout"));
+		}, 300 * 1e3);
+	});
+}
+async function getOpenCommand() {
+	const platform = process.platform;
+	if (platform === "darwin") return "open";
+	else if (platform === "win32") return "start";
+	else if (platform === "linux") return "xdg-open";
+	return null;
+}
+async function performOAuthFlow(authServerUrl, resourceUrl) {
+	const authMetadata = await fetchAuthServerMetadata(authServerUrl);
+	if (!authMetadata) {
+		console.error("Failed to fetch authorization server metadata");
+		return null;
+	}
+	if (!authMetadata.registration_endpoint) {
+		console.error("Authorization server does not support dynamic client registration");
+		return null;
+	}
+	const callbackPort = 8085;
+	const redirectUri = `http://127.0.0.1:${callbackPort}/callback`;
+	const serverKey = new URL(authServerUrl).origin;
+	const clients = await getClientStorage();
+	let clientInfo = clients.get(serverKey);
+	if (!clientInfo) {
+		const newClientInfo = await registerOAuthClient(authMetadata.registration_endpoint, redirectUri);
+		if (!newClientInfo) {
+			console.error("Failed to register OAuth client");
+			return null;
+		}
+		clientInfo = newClientInfo;
+		clients.set(serverKey, clientInfo);
+		await saveAuthData();
+	}
+	const codeVerifier = generateCodeVerifier();
+	const codeChallenge = await generateCodeChallenge(codeVerifier);
+	const authUrl = new URL(authMetadata.authorization_endpoint);
+	authUrl.searchParams.set("response_type", "code");
+	authUrl.searchParams.set("client_id", clientInfo.client_id);
+	authUrl.searchParams.set("redirect_uri", redirectUri);
+	authUrl.searchParams.set("code_challenge", codeChallenge);
+	authUrl.searchParams.set("code_challenge_method", "S256");
+	authUrl.searchParams.set("resource", resourceUrl);
+	console.log("\n🔐 Authentication required. Opening browser for authorization...");
+	console.log(`If the browser doesn't open, visit: ${authUrl.toString()}\n`);
+	const open = await getOpenCommand();
+	if (open) try {
+		const { spawn } = await import("child_process");
+		spawn(open, [authUrl.toString()], {
+			detached: true,
+			stdio: "ignore"
+		}).unref();
+	} catch {
+		console.log("Could not open browser automatically.");
+	}
+	try {
+		const code = await startCallbackServer(callbackPort);
+		const tokens = await exchangeAuthorizationCode(authMetadata.token_endpoint, clientInfo.client_id, code, codeVerifier, redirectUri);
+		if (tokens) {
+			const resourceOrigin = new URL(resourceUrl).origin;
+			(await getTokenStorage()).set(resourceOrigin, tokens);
+			await saveAuthData();
+		}
+		return tokens;
+	} catch (error) {
+		console.error("OAuth flow failed:", error);
+		return null;
+	}
+}
+async function getStoredTokens(url) {
+	const origin = new URL(url).origin;
+	return (await getTokenStorage()).get(origin);
+}
+async function fetchWithAuth(url, options = {}) {
+	const { timeout = 6e4, ...fetchOptions } = options;
+	const tokens = await getStoredTokens(url);
+	if (tokens) fetchOptions.headers = {
+		...fetchOptions.headers,
+		Authorization: `Bearer ${tokens.access_token}`
+	};
+	let response = await fetch(url, {
+		...fetchOptions,
+		signal: AbortSignal.timeout(timeout)
+	});
+	if (response.status === 401) {
+		const wwwAuthHeader = response.headers.get("WWW-Authenticate");
+		if (wwwAuthHeader) {
+			const challenge = parseWWWAuthenticateHeader(wwwAuthHeader);
+			if (challenge.resource_metadata) {
+				const resourceMetadata = await fetchProtectedResourceMetadata(challenge.resource_metadata);
+				if (resourceMetadata?.authorization_servers?.[0]) {
+					const newTokens = await performOAuthFlow(resourceMetadata.authorization_servers[0], resourceMetadata.resource);
+					if (newTokens) {
+						fetchOptions.headers = {
+							...fetchOptions.headers,
+							Authorization: `Bearer ${newTokens.access_token}`
+						};
+						response = await fetch(url, {
+							...fetchOptions,
+							signal: AbortSignal.timeout(timeout)
+						});
+					}
+				}
+			}
+		}
+	}
+	return response;
+}
+var MintlifyProvider = class {
+	id = "mintlify";
+	displayName = "Mintlify";
+	match(url) {
+		if (!url.startsWith("http://") && !url.startsWith("https://")) return { matches: false };
+		if (!url.toLowerCase().endsWith("/skill.md")) return { matches: false };
+		if (url.includes("github.com") || url.includes("gitlab.com")) return { matches: false };
+		if (url.includes("huggingface.co")) return { matches: false };
+		return { matches: true };
+	}
+	async fetchSkill(url) {
+		try {
+			const response = await fetch(url, { signal: AbortSignal.timeout(3e4) });
+			if (!response.ok) return null;
+			const content = await response.text();
+			const { data } = (0, import_gray_matter.default)(content);
+			const mintlifySite = data.metadata?.["mintlify-proj"];
+			if (!mintlifySite) return null;
+			if (!data.name || !data.description) return null;
+			return {
+				name: data.name,
+				description: data.description,
+				content,
+				installName: mintlifySite,
+				sourceUrl: url,
+				metadata: data.metadata
+			};
+		} catch {
+			return null;
+		}
+	}
+	toRawUrl(url) {
+		return url;
+	}
+	getSourceIdentifier(url) {
+		return "mintlify/com";
+	}
+};
+const mintlifyProvider = new MintlifyProvider();
+var HuggingFaceProvider = class {
+	id = "huggingface";
+	displayName = "HuggingFace";
+	HOST = "huggingface.co";
+	match(url) {
+		if (!url.startsWith("http://") && !url.startsWith("https://")) return { matches: false };
+		try {
+			if (new URL(url).hostname !== this.HOST) return { matches: false };
+		} catch {
+			return { matches: false };
+		}
+		if (!url.toLowerCase().endsWith("/skill.md")) return { matches: false };
+		if (!url.includes("/spaces/")) return { matches: false };
+		return { matches: true };
+	}
+	async fetchSkill(url) {
+		try {
+			const rawUrl = this.toRawUrl(url);
+			const response = await fetch(rawUrl, { signal: AbortSignal.timeout(3e4) });
+			if (!response.ok) return null;
+			const content = await response.text();
+			const { data } = (0, import_gray_matter.default)(content);
+			if (!data.name || !data.description) return null;
+			const parsed = this.parseUrl(url);
+			if (!parsed) return null;
+			const installName = data.metadata?.["install-name"] || parsed.repo;
+			return {
+				name: data.name,
+				description: data.description,
+				content,
+				installName,
+				sourceUrl: url,
+				metadata: data.metadata
+			};
+		} catch {
+			return null;
+		}
+	}
+	toRawUrl(url) {
+		return url.replace("/blob/", "/raw/");
+	}
+	getSourceIdentifier(url) {
+		const parsed = this.parseUrl(url);
+		if (!parsed) return "huggingface/unknown";
+		return `huggingface/${parsed.owner}/${parsed.repo}`;
+	}
+	parseUrl(url) {
+		const match = url.match(/\/spaces\/([^/]+)\/([^/]+)/);
+		if (!match || !match[1] || !match[2]) return null;
+		return {
+			owner: match[1],
+			repo: match[2]
+		};
+	}
+};
+const huggingFaceProvider = new HuggingFaceProvider();
+var WellKnownProvider = class {
+	id = "well-known";
+	displayName = "Well-Known Skills";
+	WELL_KNOWN_PATH = ".well-known/skills";
+	INDEX_FILE = "index.json";
+	match(url) {
+		if (!url.startsWith("http://") && !url.startsWith("https://")) return { matches: false };
+		try {
+			const parsed = new URL(url);
+			if ([
+				"github.com",
+				"gitlab.com",
+				"huggingface.co"
+			].includes(parsed.hostname)) return { matches: false };
+			return {
+				matches: true,
+				sourceIdentifier: `wellknown/${parsed.hostname}`
+			};
+		} catch {
+			return { matches: false };
+		}
+	}
+	async fetchIndex(baseUrl) {
+		try {
+			const parsed = new URL(baseUrl);
+			const basePath = parsed.pathname.replace(/\/$/, "");
+			const urlsToTry = [{
+				indexUrl: `${parsed.protocol}//${parsed.host}${basePath}/${this.WELL_KNOWN_PATH}/${this.INDEX_FILE}`,
+				baseUrl: `${parsed.protocol}//${parsed.host}${basePath}`
+			}];
+			if (basePath && basePath !== "") urlsToTry.push({
+				indexUrl: `${parsed.protocol}//${parsed.host}/${this.WELL_KNOWN_PATH}/${this.INDEX_FILE}`,
+				baseUrl: `${parsed.protocol}//${parsed.host}`
+			});
+			for (const { indexUrl, baseUrl: resolvedBase } of urlsToTry) try {
+				const response = await fetch(indexUrl);
+				if (!response.ok) continue;
+				const index = await response.json();
+				if (!index.skills || !Array.isArray(index.skills)) continue;
+				let allValid = true;
+				for (const entry of index.skills) if (!this.isValidSkillEntry(entry)) {
+					allValid = false;
+					break;
+				}
+				if (allValid) return {
+					index,
+					resolvedBaseUrl: resolvedBase
+				};
+			} catch {
+				continue;
+			}
+			return null;
+		} catch {
+			return null;
+		}
+	}
+	isValidSkillEntry(entry) {
+		if (!entry || typeof entry !== "object") return false;
+		const e = entry;
+		if (typeof e.name !== "string" || !e.name) return false;
+		if (typeof e.description !== "string" || !e.description) return false;
+		if (!Array.isArray(e.files) || e.files.length === 0) return false;
+		if (!/^[a-z0-9]([a-z0-9-]{0,62}[a-z0-9])?$/.test(e.name) && e.name.length > 1) {
+			if (e.name.length === 1 && !/^[a-z0-9]$/.test(e.name)) return false;
+		}
+		for (const file of e.files) {
+			if (typeof file !== "string") return false;
+			if (file.startsWith("/") || file.startsWith("\\") || file.includes("..")) return false;
+		}
+		if (!e.files.some((f) => typeof f === "string" && f.toLowerCase() === "skill.md")) return false;
+		return true;
+	}
+	async fetchSkill(url) {
+		try {
+			const parsed = new URL(url);
+			const result = await this.fetchIndex(url);
+			if (!result) return null;
+			const { index, resolvedBaseUrl } = result;
+			let skillName = null;
+			const pathMatch = parsed.pathname.match(/\/.well-known\/skills\/([^/]+)\/?$/);
+			if (pathMatch && pathMatch[1] && pathMatch[1] !== "index.json") skillName = pathMatch[1];
+			else if (index.skills.length === 1) skillName = index.skills[0].name;
+			if (!skillName) return null;
+			const skillEntry = index.skills.find((s) => s.name === skillName);
+			if (!skillEntry) return null;
+			return this.fetchSkillByEntry(resolvedBaseUrl, skillEntry);
+		} catch {
+			return null;
+		}
+	}
+	async fetchSkillByEntry(baseUrl, entry) {
+		try {
+			const skillBaseUrl = `${baseUrl.replace(/\/$/, "")}/${this.WELL_KNOWN_PATH}/${entry.name}`;
+			const skillMdUrl = `${skillBaseUrl}/SKILL.md`;
+			const response = await fetch(skillMdUrl);
+			if (!response.ok) return null;
+			const content = await response.text();
+			const { data } = (0, import_gray_matter.default)(content);
+			if (!data.name || !data.description) return null;
+			const files = /* @__PURE__ */ new Map();
+			files.set("SKILL.md", content);
+			const filePromises = entry.files.filter((f) => f.toLowerCase() !== "skill.md").map(async (filePath) => {
+				try {
+					const fileUrl = `${skillBaseUrl}/${filePath}`;
+					const fileResponse = await fetch(fileUrl);
+					if (fileResponse.ok) return {
+						path: filePath,
+						content: await fileResponse.text()
+					};
+				} catch {}
+				return null;
+			});
+			const fileResults = await Promise.all(filePromises);
+			for (const result of fileResults) if (result) files.set(result.path, result.content);
+			return {
+				name: data.name,
+				description: data.description,
+				content,
+				installName: entry.name,
+				sourceUrl: skillMdUrl,
+				metadata: data.metadata,
+				files,
+				indexEntry: entry
+			};
+		} catch {
+			return null;
+		}
+	}
+	async fetchAllSkills(url) {
+		try {
+			const result = await this.fetchIndex(url);
+			if (!result) return [];
+			const { index, resolvedBaseUrl } = result;
+			const skillPromises = index.skills.map((entry) => this.fetchSkillByEntry(resolvedBaseUrl, entry));
+			return (await Promise.all(skillPromises)).filter((s) => s !== null);
+		} catch {
+			return [];
+		}
+	}
+	toRawUrl(url) {
+		try {
+			const parsed = new URL(url);
+			if (url.toLowerCase().endsWith("/skill.md")) return url;
+			const pathMatch = parsed.pathname.match(/\/.well-known\/skills\/([^/]+)\/?$/);
+			if (pathMatch && pathMatch[1]) {
+				const basePath = parsed.pathname.replace(/\/.well-known\/skills\/.*$/, "");
+				return `${parsed.protocol}//${parsed.host}${basePath}/${this.WELL_KNOWN_PATH}/${pathMatch[1]}/SKILL.md`;
+			}
+			const basePath = parsed.pathname.replace(/\/$/, "");
+			return `${parsed.protocol}//${parsed.host}${basePath}/${this.WELL_KNOWN_PATH}/${this.INDEX_FILE}`;
+		} catch {
+			return url;
+		}
+	}
+	getSourceIdentifier(url) {
+		try {
+			const parsed = new URL(url);
+			const hostParts = parsed.hostname.split(".");
+			if (hostParts.length >= 2) {
+				const tld = hostParts[hostParts.length - 1];
+				return `${hostParts[hostParts.length - 2]}/${tld}`;
+			}
+			return parsed.hostname.replace(".", "/");
+		} catch {
+			return "unknown/unknown";
+		}
+	}
+	async hasSkillsIndex(url) {
+		return await this.fetchIndex(url) !== null;
+	}
+};
+const wellKnownProvider = new WellKnownProvider();
+async function extractZip(zipPath, extractDir) {
+	const unzipper = await import("./_chunks/libs/unzipper.mjs").then((n) => /* @__PURE__ */ __toESM(n.t(), 1));
+	await mkdir(extractDir, { recursive: true });
+	const directory = await unzipper.Open.file(zipPath);
+	for (const file of directory.files) {
+		if (file.type === "Directory" || file.path.includes("__MACOSX")) continue;
+		const normalizedPath = file.path.replace(/\\/g, "/");
+		if (normalizedPath.includes("..")) continue;
+		const filePath = join(extractDir, normalizedPath);
+		await mkdir(dirname(filePath), { recursive: true });
+		await writeFile(filePath, await file.buffer());
+	}
+}
+async function findSkillRoot(extractDir) {
+	const rootSkillMd = join(extractDir, "SKILL.md");
+	try {
+		await stat(rootSkillMd);
+		return extractDir;
+	} catch {}
+	const entries = await readdir(extractDir, { withFileTypes: true });
+	for (const entry of entries) if (entry.isDirectory()) {
+		const subdir = join(extractDir, entry.name);
+		const skillMdPath = join(subdir, "SKILL.md");
+		try {
+			await stat(skillMdPath);
+			return subdir;
+		} catch {}
+	}
+	return null;
+}
+async function readSkillFiles(skillDir) {
+	const files = /* @__PURE__ */ new Map();
+	async function readDir(dir, prefix = "") {
+		const entries = await readdir(dir, { withFileTypes: true });
+		for (const entry of entries) {
+			const fullPath = join(dir, entry.name);
+			const relativePath = prefix ? `${prefix}/${entry.name}` : entry.name;
+			if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
+			if (entry.isDirectory()) await readDir(fullPath, relativePath);
+			else try {
+				const content = await readFile(fullPath, "utf-8");
+				files.set(relativePath, content);
+			} catch {}
+		}
+	}
+	await readDir(skillDir);
+	return files;
+}
+var ZipProvider = class {
+	id = "zip";
+	displayName = "ZIP Archive";
+	match(url) {
+		if (!url.startsWith("http://") && !url.startsWith("https://")) return { matches: false };
+		if (!url.toLowerCase().endsWith(".zip")) return { matches: false };
+		try {
+			return {
+				matches: true,
+				sourceIdentifier: `zip/${new URL(url).hostname}`
+			};
+		} catch {
+			return { matches: false };
+		}
+	}
+	async fetchSkill(url) {
+		let tempDir = null;
+		let zipPath = null;
+		try {
+			tempDir = join(tmpdir(), `skills-zip-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+			await mkdir(tempDir, { recursive: true });
+			zipPath = join(tempDir, "skill.zip");
+			const response = await fetchWithAuth(url);
+			if (!response.ok) {
+				if (response.status === 401) console.error("Authentication required but OAuth flow failed or was not available");
+				return null;
+			}
+			const arrayBuffer = await response.arrayBuffer();
+			await writeFile(zipPath, Buffer.from(arrayBuffer));
+			const extractDir = join(tempDir, "extracted");
+			await extractZip(zipPath, extractDir);
+			const skillRoot = await findSkillRoot(extractDir);
+			if (!skillRoot) return null;
+			const content = await readFile(join(skillRoot, "SKILL.md"), "utf-8");
+			const { data } = (0, import_gray_matter.default)(content);
+			if (!data.name || !data.description) return null;
+			const files = await readSkillFiles(skillRoot);
+			const installName = data.metadata?.["install-name"] || data.name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+			return {
+				name: data.name,
+				description: data.description,
+				content,
+				installName,
+				sourceUrl: url,
+				metadata: data.metadata,
+				files
+			};
+		} catch (error) {
+			console.error("Error fetching ZIP skill:", error);
+			return null;
+		} finally {
+			if (tempDir) try {
+				await rm(tempDir, {
+					recursive: true,
+					force: true
+				});
+			} catch {}
+		}
+	}
+	toRawUrl(url) {
+		return url;
+	}
+	getSourceIdentifier(url) {
+		try {
+			const parsed = new URL(url);
+			const pathname = parsed.pathname;
+			const filename = basename(pathname, ".zip");
+			return `zip/${parsed.hostname}/${filename}`;
+		} catch {
+			return "zip/unknown";
+		}
+	}
+};
+const zipProvider = new ZipProvider();
+registerProvider(mintlifyProvider);
+registerProvider(huggingFaceProvider);
+registerProvider(zipProvider);
+async function fetchMintlifySkill(url) {
+	try {
+		const response = await fetch(url, { signal: AbortSignal.timeout(3e4) });
+		if (!response.ok) return null;
+		const content = await response.text();
+		const { data } = (0, import_gray_matter.default)(content);
+		const mintlifySite = data.metadata?.["mintlify-proj"];
+		if (!mintlifySite) return null;
+		if (!data.name || !data.description) return null;
+		return {
+			name: data.name,
+			description: data.description,
+			content,
+			mintlifySite,
+			sourceUrl: url
+		};
+	} catch {
+		return null;
+	}
+}
+const AGENTS_DIR$1 = ".agents";
+const LOCK_FILE$1 = ".skill-lock.json";
+const CURRENT_VERSION = 3;
+function getSkillLockPath$1() {
+	return join(homedir(), AGENTS_DIR$1, LOCK_FILE$1);
+}
+async function readSkillLock$1() {
+	const lockPath = getSkillLockPath$1();
+	try {
+		const content = await readFile(lockPath, "utf-8");
+		const parsed = JSON.parse(content);
+		if (typeof parsed.version !== "number" || !parsed.skills) return createEmptyLockFile();
+		if (parsed.version < CURRENT_VERSION) return createEmptyLockFile();
+		return parsed;
+	} catch (error) {
+		return createEmptyLockFile();
+	}
+}
+async function writeSkillLock(lock) {
+	const lockPath = getSkillLockPath$1();
+	await mkdir(dirname(lockPath), { recursive: true });
+	await writeFile(lockPath, JSON.stringify(lock, null, 2), "utf-8");
+}
+async function fetchSkillFolderHash(ownerRepo, skillPath) {
+	let folderPath = skillPath.replace(/\\/g, "/");
+	if (folderPath.endsWith("/SKILL.md")) folderPath = folderPath.slice(0, -9);
+	else if (folderPath.endsWith("SKILL.md")) folderPath = folderPath.slice(0, -8);
+	if (folderPath.endsWith("/")) folderPath = folderPath.slice(0, -1);
+	for (const branch of ["main", "master"]) try {
+		const url = `https://api.github.com/repos/${ownerRepo}/git/trees/${branch}?recursive=1`;
+		const response = await fetch(url, { headers: {
+			Accept: "application/vnd.github.v3+json",
+			"User-Agent": "skills-cli"
+		} });
+		if (!response.ok) continue;
+		const data = await response.json();
+		if (!folderPath) return data.sha;
+		const folderEntry = data.tree.find((entry) => entry.type === "tree" && entry.path === folderPath);
+		if (folderEntry) return folderEntry.sha;
+	} catch {
+		continue;
+	}
+	return null;
+}
+async function addSkillToLock(skillName, entry) {
+	const lock = await readSkillLock$1();
+	const now = (/* @__PURE__ */ new Date()).toISOString();
+	const existingEntry = lock.skills[skillName];
+	lock.skills[skillName] = {
+		...entry,
+		installedAt: existingEntry?.installedAt ?? now,
+		updatedAt: now
+	};
+	await writeSkillLock(lock);
+}
+async function removeSkillFromLock(skillName) {
+	const lock = await readSkillLock$1();
+	if (!(skillName in lock.skills)) return false;
+	delete lock.skills[skillName];
+	await writeSkillLock(lock);
+	return true;
+}
+async function getSkillFromLock(skillName) {
+	return (await readSkillLock$1()).skills[skillName] ?? null;
+}
+function createEmptyLockFile() {
+	return {
+		version: CURRENT_VERSION,
+		skills: {},
+		dismissed: {}
+	};
+}
+async function isPromptDismissed(promptKey) {
+	return (await readSkillLock$1()).dismissed?.[promptKey] === true;
+}
+async function dismissPrompt(promptKey) {
+	const lock = await readSkillLock$1();
+	if (!lock.dismissed) lock.dismissed = {};
+	lock.dismissed[promptKey] = true;
+	await writeSkillLock(lock);
+}
+async function getLastSelectedAgents() {
+	return (await readSkillLock$1()).lastSelectedAgents;
+}
+async function saveSelectedAgents(agents) {
+	const lock = await readSkillLock$1();
+	lock.lastSelectedAgents = agents;
+	await writeSkillLock(lock);
+}
+var version$1 = "1.3.1";
+const isCancelled = (value) => typeof value === "symbol";
+async function isSourcePrivate(source) {
+	const ownerRepo = parseOwnerRepo(source);
+	if (!ownerRepo) return false;
+	return isRepoPrivate(ownerRepo.owner, ownerRepo.repo);
+}
+function initTelemetry(version) {
+	setVersion(version);
+}
+function shortenPath$1(fullPath, cwd) {
+	const home = homedir();
+	if (fullPath === home || fullPath.startsWith(home + sep)) return "~" + fullPath.slice(home.length);
+	if (fullPath === cwd || fullPath.startsWith(cwd + sep)) return "." + fullPath.slice(cwd.length);
+	return fullPath;
+}
+function formatList$1(items, maxShow = 5) {
+	if (items.length <= maxShow) return items.join(", ");
+	const shown = items.slice(0, maxShow);
+	const remaining = items.length - maxShow;
+	return `${shown.join(", ")} +${remaining} more`;
+}
+function multiselect(opts) {
+	return fe({
+		...opts,
+		options: opts.options,
+		message: `${opts.message} ${import_picocolors.default.dim("(space to toggle)")}`
+	});
+}
+async function promptForAgents(message, choices) {
+	let lastSelected;
+	try {
+		lastSelected = await getLastSelectedAgents();
+	} catch {}
+	const validAgents = choices.map((c) => c.value);
+	let initialValues = [];
+	if (lastSelected && lastSelected.length > 0) initialValues = lastSelected.filter((a) => validAgents.includes(a));
+	const selected = await searchMultiselect({
+		message,
+		items: choices,
+		initialSelected: initialValues
+	});
+	if (!isCancelled(selected)) try {
+		await saveSelectedAgents(selected);
+	} catch {}
+	return selected;
+}
+async function selectAgentsInteractive(options) {
+	return promptForAgents("Which agents do you want to install to?", Object.keys(agents).map((a) => ({
+		value: a,
+		label: agents[a].displayName,
+		hint: `${options.global ? agents[a].globalSkillsDir : agents[a].skillsDir}`
+	})));
+}
+setVersion(version$1);
+async function handleRemoteSkill(source, url, options, spinner) {
+	const provider = findProvider(url);
+	if (!provider) {
+		await handleDirectUrlSkillLegacy(source, url, options, spinner);
+		return;
+	}
+	spinner.start(`Fetching skill from ${provider.displayName}...`);
+	const providerSkill = await provider.fetchSkill(url);
+	if (!providerSkill) {
+		spinner.stop(import_picocolors.default.red("Invalid skill"));
+		Se(import_picocolors.default.red("Could not fetch skill or missing required frontmatter (name, description)."));
+		process.exit(1);
+	}
+	const isZipSkill = "files" in providerSkill && providerSkill.files instanceof Map;
+	const remoteSkill = {
+		name: providerSkill.name,
+		description: providerSkill.description,
+		content: providerSkill.content,
+		installName: providerSkill.installName,
+		sourceUrl: providerSkill.sourceUrl,
+		providerId: provider.id,
+		sourceIdentifier: provider.getSourceIdentifier(url),
+		metadata: providerSkill.metadata
+	};
+	const zipSkill = isZipSkill ? providerSkill : null;
+	spinner.stop(`Found skill: ${import_picocolors.default.cyan(remoteSkill.installName)}${zipSkill ? ` (${zipSkill.files.size} files)` : ""}`);
+	M.info(`Skill: ${import_picocolors.default.cyan(remoteSkill.name)}`);
+	M.message(import_picocolors.default.dim(remoteSkill.description));
+	M.message(import_picocolors.default.dim(`Source: ${remoteSkill.sourceIdentifier}`));
+	if (options.list) {
+		console.log();
+		M.step(import_picocolors.default.bold("Skill Details"));
+		M.message(`  ${import_picocolors.default.cyan("Name:")} ${remoteSkill.name}`);
+		M.message(`  ${import_picocolors.default.cyan("Install as:")} ${remoteSkill.installName}`);
+		M.message(`  ${import_picocolors.default.cyan("Provider:")} ${provider.displayName}`);
+		M.message(`  ${import_picocolors.default.cyan("Description:")} ${remoteSkill.description}`);
+		console.log();
+		Se("Run without --list to install");
+		process.exit(0);
+	}
+	let targetAgents;
+	const validAgents = Object.keys(agents);
+	if (options.agent?.includes("*")) {
+		targetAgents = validAgents;
+		M.info(`Installing to all ${targetAgents.length} agents`);
+	} else if (options.agent && options.agent.length > 0) {
+		const invalidAgents = options.agent.filter((a) => !validAgents.includes(a));
+		if (invalidAgents.length > 0) {
+			M.error(`Invalid agents: ${invalidAgents.join(", ")}`);
+			M.info(`Valid agents: ${validAgents.join(", ")}`);
+			process.exit(1);
+		}
+		targetAgents = options.agent;
+	} else {
+		spinner.start("Loading agents...");
+		const installedAgents = await detectInstalledAgents();
+		const totalAgents = Object.keys(agents).length;
+		spinner.stop(`${totalAgents} agents`);
+		if (installedAgents.length === 0) if (options.yes) {
+			targetAgents = validAgents;
+			M.info("Installing to all agents");
+		} else {
+			M.info("Select agents to install skills to");
+			const selected = await promptForAgents("Which agents do you want to install to?", Object.entries(agents).map(([key, config]) => ({
+				value: key,
+				label: config.displayName
+			})));
+			if (pD(selected)) {
+				xe("Installation cancelled");
+				process.exit(0);
+			}
+			targetAgents = selected;
+		}
+		else if (installedAgents.length === 1 || options.yes) {
+			targetAgents = installedAgents;
+			if (installedAgents.length === 1) {
+				const firstAgent = installedAgents[0];
+				M.info(`Installing to: ${import_picocolors.default.cyan(agents[firstAgent].displayName)}`);
+			} else M.info(`Installing to: ${installedAgents.map((a) => import_picocolors.default.cyan(agents[a].displayName)).join(", ")}`);
+		} else {
+			const selected = await selectAgentsInteractive({ global: options.global });
+			if (pD(selected)) {
+				xe("Installation cancelled");
+				process.exit(0);
+			}
+			targetAgents = selected;
+		}
+	}
+	let installGlobally = options.global ?? false;
+	const supportsGlobal = targetAgents.some((a) => agents[a].globalSkillsDir !== void 0);
+	if (options.global === void 0 && !options.yes && supportsGlobal) {
+		const scope = await ve({
+			message: "Installation scope",
+			options: [{
+				value: false,
+				label: "Project",
+				hint: "Install in current directory (committed with your project)"
+			}, {
+				value: true,
+				label: "Global",
+				hint: "Install in home directory (available across all projects)"
+			}]
+		});
+		if (pD(scope)) {
+			xe("Installation cancelled");
+			process.exit(0);
+		}
+		installGlobally = scope;
+	}
+	let installMode = "symlink";
+	if (!options.yes) {
+		const modeChoice = await ve({
+			message: "Installation method",
+			options: [{
+				value: "symlink",
+				label: "Symlink (Recommended)",
+				hint: "Single source of truth, easy updates"
+			}, {
+				value: "copy",
+				label: "Copy to all agents",
+				hint: "Independent copies for each agent"
+			}]
+		});
+		if (pD(modeChoice)) {
+			xe("Installation cancelled");
+			process.exit(0);
+		}
+		installMode = modeChoice;
+	}
+	const cwd = process.cwd();
+	const overwriteChecks = await Promise.all(targetAgents.map(async (agent) => ({
+		agent,
+		installed: await isSkillInstalled(remoteSkill.installName, agent, { global: installGlobally })
+	})));
+	const overwriteStatus = new Map(overwriteChecks.map(({ agent, installed }) => [agent, installed]));
+	const summaryLines = [];
+	const agentNames = targetAgents.map((a) => agents[a].displayName);
+	if (installMode === "symlink") {
+		const shortCanonical = shortenPath$1(getCanonicalPath(remoteSkill.installName, { global: installGlobally }), cwd);
+		summaryLines.push(`${import_picocolors.default.cyan(shortCanonical)}`);
+		summaryLines.push(`  ${import_picocolors.default.dim("symlink →")} ${formatList$1(agentNames)}`);
+	} else {
+		summaryLines.push(`${import_picocolors.default.cyan(remoteSkill.installName)}`);
+		summaryLines.push(`  ${import_picocolors.default.dim("copy →")} ${formatList$1(agentNames)}`);
+	}
+	const overwriteAgents = targetAgents.filter((a) => overwriteStatus.get(a)).map((a) => agents[a].displayName);
+	if (overwriteAgents.length > 0) summaryLines.push(`  ${import_picocolors.default.yellow("overwrites:")} ${formatList$1(overwriteAgents)}`);
+	console.log();
+	Me(summaryLines.join("\n"), "Installation Summary");
+	if (!options.yes) {
+		const confirmed = await ye({ message: "Proceed with installation?" });
+		if (pD(confirmed) || !confirmed) {
+			xe("Installation cancelled");
+			process.exit(0);
+		}
+	}
+	spinner.start("Installing skill...");
+	const results = [];
+	for (const agent of targetAgents) {
+		const result = zipSkill ? await installZipSkillForAgent(zipSkill, agent, {
+			global: installGlobally,
+			mode: installMode
+		}) : await installRemoteSkillForAgent(remoteSkill, agent, {
+			global: installGlobally,
+			mode: installMode
+		});
+		results.push({
+			skill: remoteSkill.installName,
+			agent: agents[agent].displayName,
+			...result
+		});
+	}
+	spinner.stop("Installation complete");
+	console.log();
+	const successful = results.filter((r) => r.success);
+	const failed = results.filter((r) => !r.success);
+	if (await isSourcePrivate(remoteSkill.sourceIdentifier) !== true) track({
+		event: "install",
+		source: remoteSkill.sourceIdentifier,
+		skills: remoteSkill.installName,
+		agents: targetAgents.join(","),
+		...installGlobally && { global: "1" },
+		skillFiles: JSON.stringify({ [remoteSkill.installName]: url }),
+		sourceType: remoteSkill.providerId
+	});
+	if (successful.length > 0 && installGlobally) try {
+		let skillFolderHash = "";
+		if (remoteSkill.providerId === "github") {
+			const hash = await fetchSkillFolderHash(remoteSkill.sourceIdentifier, url);
+			if (hash) skillFolderHash = hash;
+		}
+		await addSkillToLock(remoteSkill.installName, {
+			source: remoteSkill.sourceIdentifier,
+			sourceType: remoteSkill.providerId,
+			sourceUrl: url,
+			skillFolderHash
+		});
+	} catch {}
+	if (successful.length > 0) {
+		const resultLines = [];
+		const firstResult = successful[0];
+		if (firstResult.mode === "copy") {
+			resultLines.push(`${import_picocolors.default.green("✓")} ${remoteSkill.installName} ${import_picocolors.default.dim("(copied)")}`);
+			for (const r of successful) {
+				const shortPath = shortenPath$1(r.path, cwd);
+				resultLines.push(`  ${import_picocolors.default.dim("→")} ${shortPath}`);
+			}
+		} else {
+			if (firstResult.canonicalPath) {
+				const shortPath = shortenPath$1(firstResult.canonicalPath, cwd);
+				resultLines.push(`${import_picocolors.default.green("✓")} ${shortPath}`);
+			} else resultLines.push(`${import_picocolors.default.green("✓")} ${remoteSkill.installName}`);
+			const symlinked = successful.filter((r) => !r.symlinkFailed).map((r) => r.agent);
+			const copied = successful.filter((r) => r.symlinkFailed).map((r) => r.agent);
+			if (symlinked.length > 0) resultLines.push(`  ${import_picocolors.default.dim("symlink →")} ${formatList$1(symlinked)}`);
+			if (copied.length > 0) resultLines.push(`  ${import_picocolors.default.yellow("copied →")} ${formatList$1(copied)}`);
+		}
+		const title = import_picocolors.default.green(`Installed 1 skill to ${successful.length} agent${successful.length !== 1 ? "s" : ""}`);
+		Me(resultLines.join("\n"), title);
+		const symlinkFailures = successful.filter((r) => r.mode === "symlink" && r.symlinkFailed);
+		if (symlinkFailures.length > 0) {
+			const copiedAgentNames = symlinkFailures.map((r) => r.agent);
+			M.warn(import_picocolors.default.yellow(`Symlinks failed for: ${formatList$1(copiedAgentNames)}`));
+			M.message(import_picocolors.default.dim("  Files were copied instead. On Windows, enable Developer Mode for symlink support."));
+		}
+	}
+	if (failed.length > 0) {
+		console.log();
+		M.error(import_picocolors.default.red(`Failed to install ${failed.length}`));
+		for (const r of failed) M.message(`  ${import_picocolors.default.red("✗")} ${r.skill} → ${r.agent}: ${import_picocolors.default.dim(r.error)}`);
+	}
+	console.log();
+	Se(import_picocolors.default.green("Done!"));
+	await promptForFindSkills(options, targetAgents);
+}
+async function handleWellKnownSkills(source, url, options, spinner) {
+	spinner.start("Discovering skills from well-known endpoint...");
+	const skills = await wellKnownProvider.fetchAllSkills(url);
+	if (skills.length === 0) {
+		spinner.stop(import_picocolors.default.red("No skills found"));
+		Se(import_picocolors.default.red("No skills found at this URL. Make sure the server has a /.well-known/skills/index.json file."));
+		process.exit(1);
+	}
+	spinner.stop(`Found ${import_picocolors.default.green(skills.length)} skill${skills.length > 1 ? "s" : ""}`);
+	for (const skill of skills) {
+		M.info(`Skill: ${import_picocolors.default.cyan(skill.installName)}`);
+		M.message(import_picocolors.default.dim(skill.description));
+		if (skill.files.size > 1) M.message(import_picocolors.default.dim(`  Files: ${Array.from(skill.files.keys()).join(", ")}`));
+	}
+	if (options.list) {
+		console.log();
+		M.step(import_picocolors.default.bold("Available Skills"));
+		for (const skill of skills) {
+			M.message(`  ${import_picocolors.default.cyan(skill.installName)}`);
+			M.message(`    ${import_picocolors.default.dim(skill.description)}`);
+			if (skill.files.size > 1) M.message(`    ${import_picocolors.default.dim(`Files: ${skill.files.size}`)}`);
+		}
+		console.log();
+		Se("Run without --list to install");
+		process.exit(0);
+	}
+	let selectedSkills;
+	if (options.skill?.includes("*")) {
+		selectedSkills = skills;
+		M.info(`Installing all ${skills.length} skills`);
+	} else if (options.skill && options.skill.length > 0) {
+		selectedSkills = skills.filter((s) => options.skill.some((name) => s.installName.toLowerCase() === name.toLowerCase() || s.name.toLowerCase() === name.toLowerCase()));
+		if (selectedSkills.length === 0) {
+			M.error(`No matching skills found for: ${options.skill.join(", ")}`);
+			M.info("Available skills:");
+			for (const s of skills) M.message(`  - ${s.installName}`);
+			process.exit(1);
+		}
+		M.info(`Selected ${selectedSkills.length} skill${selectedSkills.length !== 1 ? "s" : ""}: ${selectedSkills.map((s) => import_picocolors.default.cyan(s.installName)).join(", ")}`);
+	} else if (skills.length === 1) {
+		selectedSkills = skills;
+		const firstSkill = skills[0];
+		M.info(`Skill: ${import_picocolors.default.cyan(firstSkill.installName)}`);
+	} else if (options.yes) {
+		selectedSkills = skills;
+		M.info(`Installing all ${skills.length} skills`);
+	} else {
+		const selected = await multiselect({
+			message: "Select skills to install",
+			options: skills.map((s) => ({
+				value: s,
+				label: s.installName,
+				hint: s.description.length > 60 ? s.description.slice(0, 57) + "..." : s.description
+			})),
+			required: true
+		});
+		if (pD(selected)) {
+			xe("Installation cancelled");
+			process.exit(0);
+		}
+		selectedSkills = selected;
+	}
+	let targetAgents;
+	const validAgents = Object.keys(agents);
+	if (options.agent?.includes("*")) {
+		targetAgents = validAgents;
+		M.info(`Installing to all ${targetAgents.length} agents`);
+	} else if (options.agent && options.agent.length > 0) {
+		const invalidAgents = options.agent.filter((a) => !validAgents.includes(a));
+		if (invalidAgents.length > 0) {
+			M.error(`Invalid agents: ${invalidAgents.join(", ")}`);
+			M.info(`Valid agents: ${validAgents.join(", ")}`);
+			process.exit(1);
+		}
+		targetAgents = options.agent;
+	} else {
+		spinner.start("Loading agents...");
+		const installedAgents = await detectInstalledAgents();
+		const totalAgents = Object.keys(agents).length;
+		spinner.stop(`${totalAgents} agents`);
+		if (installedAgents.length === 0) if (options.yes) {
+			targetAgents = validAgents;
+			M.info("Installing to all agents");
+		} else {
+			M.info("Select agents to install skills to");
+			const selected = await promptForAgents("Which agents do you want to install to?", Object.entries(agents).map(([key, config]) => ({
+				value: key,
+				label: config.displayName
+			})));
+			if (pD(selected)) {
+				xe("Installation cancelled");
+				process.exit(0);
+			}
+			targetAgents = selected;
+		}
+		else if (installedAgents.length === 1 || options.yes) {
+			targetAgents = installedAgents;
+			if (installedAgents.length === 1) {
+				const firstAgent = installedAgents[0];
+				M.info(`Installing to: ${import_picocolors.default.cyan(agents[firstAgent].displayName)}`);
+			} else M.info(`Installing to: ${installedAgents.map((a) => import_picocolors.default.cyan(agents[a].displayName)).join(", ")}`);
+		} else {
+			const selected = await selectAgentsInteractive({ global: options.global });
+			if (pD(selected)) {
+				xe("Installation cancelled");
+				process.exit(0);
+			}
+			targetAgents = selected;
+		}
+	}
+	let installGlobally = options.global ?? false;
+	const supportsGlobal = targetAgents.some((a) => agents[a].globalSkillsDir !== void 0);
+	if (options.global === void 0 && !options.yes && supportsGlobal) {
+		const scope = await ve({
+			message: "Installation scope",
+			options: [{
+				value: false,
+				label: "Project",
+				hint: "Install in current directory (committed with your project)"
+			}, {
+				value: true,
+				label: "Global",
+				hint: "Install in home directory (available across all projects)"
+			}]
+		});
+		if (pD(scope)) {
+			xe("Installation cancelled");
+			process.exit(0);
+		}
+		installGlobally = scope;
+	}
+	let installMode = "symlink";
+	if (!options.yes) {
+		const modeChoice = await ve({
+			message: "Installation method",
+			options: [{
+				value: "symlink",
+				label: "Symlink (Recommended)",
+				hint: "Single source of truth, easy updates"
+			}, {
+				value: "copy",
+				label: "Copy to all agents",
+				hint: "Independent copies for each agent"
+			}]
+		});
+		if (pD(modeChoice)) {
+			xe("Installation cancelled");
+			process.exit(0);
+		}
+		installMode = modeChoice;
+	}
+	const cwd = process.cwd();
+	const summaryLines = [];
+	const agentNames = targetAgents.map((a) => agents[a].displayName);
+	const overwriteChecks = await Promise.all(selectedSkills.flatMap((skill) => targetAgents.map(async (agent) => ({
+		skillName: skill.installName,
+		agent,
+		installed: await isSkillInstalled(skill.installName, agent, { global: installGlobally })
+	}))));
+	const overwriteStatus = /* @__PURE__ */ new Map();
+	for (const { skillName, agent, installed } of overwriteChecks) {
+		if (!overwriteStatus.has(skillName)) overwriteStatus.set(skillName, /* @__PURE__ */ new Map());
+		overwriteStatus.get(skillName).set(agent, installed);
+	}
+	for (const skill of selectedSkills) {
+		if (summaryLines.length > 0) summaryLines.push("");
+		if (installMode === "symlink") {
+			const shortCanonical = shortenPath$1(getCanonicalPath(skill.installName, { global: installGlobally }), cwd);
+			summaryLines.push(`${import_picocolors.default.cyan(shortCanonical)}`);
+			summaryLines.push(`  ${import_picocolors.default.dim("symlink →")} ${formatList$1(agentNames)}`);
+			if (skill.files.size > 1) summaryLines.push(`  ${import_picocolors.default.dim("files:")} ${skill.files.size}`);
+		} else {
+			summaryLines.push(`${import_picocolors.default.cyan(skill.installName)}`);
+			summaryLines.push(`  ${import_picocolors.default.dim("copy →")} ${formatList$1(agentNames)}`);
+		}
+		const skillOverwrites = overwriteStatus.get(skill.installName);
+		const overwriteAgents = targetAgents.filter((a) => skillOverwrites?.get(a)).map((a) => agents[a].displayName);
+		if (overwriteAgents.length > 0) summaryLines.push(`  ${import_picocolors.default.yellow("overwrites:")} ${formatList$1(overwriteAgents)}`);
+	}
+	console.log();
+	Me(summaryLines.join("\n"), "Installation Summary");
+	if (!options.yes) {
+		const confirmed = await ye({ message: "Proceed with installation?" });
+		if (pD(confirmed) || !confirmed) {
+			xe("Installation cancelled");
+			process.exit(0);
+		}
+	}
+	spinner.start("Installing skills...");
+	const results = [];
+	for (const skill of selectedSkills) for (const agent of targetAgents) {
+		const result = await installWellKnownSkillForAgent(skill, agent, {
+			global: installGlobally,
+			mode: installMode
+		});
+		results.push({
+			skill: skill.installName,
+			agent: agents[agent].displayName,
+			...result
+		});
+	}
+	spinner.stop("Installation complete");
+	console.log();
+	const successful = results.filter((r) => r.success);
+	const failed = results.filter((r) => !r.success);
+	const sourceIdentifier = wellKnownProvider.getSourceIdentifier(url);
+	const skillFiles = {};
+	for (const skill of selectedSkills) skillFiles[skill.installName] = skill.sourceUrl;
+	if (await isSourcePrivate(sourceIdentifier) !== true) track({
+		event: "install",
+		source: sourceIdentifier,
+		skills: selectedSkills.map((s) => s.installName).join(","),
+		agents: targetAgents.join(","),
+		...installGlobally && { global: "1" },
+		skillFiles: JSON.stringify(skillFiles),
+		sourceType: "well-known"
+	});
+	if (successful.length > 0 && installGlobally) {
+		const successfulSkillNames = new Set(successful.map((r) => r.skill));
+		for (const skill of selectedSkills) if (successfulSkillNames.has(skill.installName)) try {
+			await addSkillToLock(skill.installName, {
+				source: sourceIdentifier,
+				sourceType: "well-known",
+				sourceUrl: skill.sourceUrl,
+				skillFolderHash: ""
+			});
+		} catch {}
+	}
+	if (successful.length > 0) {
+		const bySkill = /* @__PURE__ */ new Map();
+		for (const r of successful) {
+			const skillResults = bySkill.get(r.skill) || [];
+			skillResults.push(r);
+			bySkill.set(r.skill, skillResults);
+		}
+		const skillCount = bySkill.size;
+		const agentCount = new Set(successful.map((r) => r.agent)).size;
+		const symlinkFailures = successful.filter((r) => r.mode === "symlink" && r.symlinkFailed);
+		const copiedAgents = symlinkFailures.map((r) => r.agent);
+		const resultLines = [];
+		for (const [skillName, skillResults] of bySkill) {
+			const firstResult = skillResults[0];
+			if (firstResult.mode === "copy") {
+				resultLines.push(`${import_picocolors.default.green("✓")} ${skillName} ${import_picocolors.default.dim("(copied)")}`);
+				for (const r of skillResults) {
+					const shortPath = shortenPath$1(r.path, cwd);
+					resultLines.push(`  ${import_picocolors.default.dim("→")} ${shortPath}`);
+				}
+			} else {
+				if (firstResult.canonicalPath) {
+					const shortPath = shortenPath$1(firstResult.canonicalPath, cwd);
+					resultLines.push(`${import_picocolors.default.green("✓")} ${shortPath}`);
+				} else resultLines.push(`${import_picocolors.default.green("✓")} ${skillName}`);
+				const symlinked = skillResults.filter((r) => !r.symlinkFailed).map((r) => r.agent);
+				const copied = skillResults.filter((r) => r.symlinkFailed).map((r) => r.agent);
+				if (symlinked.length > 0) resultLines.push(`  ${import_picocolors.default.dim("symlink →")} ${formatList$1(symlinked)}`);
+				if (copied.length > 0) resultLines.push(`  ${import_picocolors.default.yellow("copied →")} ${formatList$1(copied)}`);
+			}
+		}
+		const title = import_picocolors.default.green(`Installed ${skillCount} skill${skillCount !== 1 ? "s" : ""} to ${agentCount} agent${agentCount !== 1 ? "s" : ""}`);
+		Me(resultLines.join("\n"), title);
+		if (symlinkFailures.length > 0) {
+			M.warn(import_picocolors.default.yellow(`Symlinks failed for: ${formatList$1(copiedAgents)}`));
+			M.message(import_picocolors.default.dim("  Files were copied instead. On Windows, enable Developer Mode for symlink support."));
+		}
+	}
+	if (failed.length > 0) {
+		console.log();
+		M.error(import_picocolors.default.red(`Failed to install ${failed.length}`));
+		for (const r of failed) M.message(`  ${import_picocolors.default.red("✗")} ${r.skill} → ${r.agent}: ${import_picocolors.default.dim(r.error)}`);
+	}
+	console.log();
+	Se(import_picocolors.default.green("Done!"));
+	await promptForFindSkills(options, targetAgents);
+}
+async function handleDirectUrlSkillLegacy(source, url, options, spinner) {
+	spinner.start("Fetching skill.md...");
+	const mintlifySkill = await fetchMintlifySkill(url);
+	if (!mintlifySkill) {
+		spinner.stop(import_picocolors.default.red("Invalid skill"));
+		Se(import_picocolors.default.red("Could not fetch skill.md or missing required frontmatter (name, description, mintlify-proj)."));
+		process.exit(1);
+	}
+	const remoteSkill = {
+		name: mintlifySkill.name,
+		description: mintlifySkill.description,
+		content: mintlifySkill.content,
+		installName: mintlifySkill.mintlifySite,
+		sourceUrl: mintlifySkill.sourceUrl,
+		providerId: "mintlify",
+		sourceIdentifier: "mintlify/com"
+	};
+	spinner.stop(`Found skill: ${import_picocolors.default.cyan(remoteSkill.installName)}`);
+	M.info(`Skill: ${import_picocolors.default.cyan(remoteSkill.name)}`);
+	M.message(import_picocolors.default.dim(remoteSkill.description));
+	if (options.list) {
+		console.log();
+		M.step(import_picocolors.default.bold("Skill Details"));
+		M.message(`  ${import_picocolors.default.cyan("Name:")} ${remoteSkill.name}`);
+		M.message(`  ${import_picocolors.default.cyan("Site:")} ${remoteSkill.installName}`);
+		M.message(`  ${import_picocolors.default.cyan("Description:")} ${remoteSkill.description}`);
+		console.log();
+		Se("Run without --list to install");
+		process.exit(0);
+	}
+	let targetAgents;
+	const validAgents = Object.keys(agents);
+	if (options.agent?.includes("*")) {
+		targetAgents = validAgents;
+		M.info(`Installing to all ${targetAgents.length} agents`);
+	} else if (options.agent && options.agent.length > 0) {
+		const invalidAgents = options.agent.filter((a) => !validAgents.includes(a));
+		if (invalidAgents.length > 0) {
+			M.error(`Invalid agents: ${invalidAgents.join(", ")}`);
+			M.info(`Valid agents: ${validAgents.join(", ")}`);
+			process.exit(1);
+		}
+		targetAgents = options.agent;
+	} else {
+		spinner.start("Loading agents...");
+		const installedAgents = await detectInstalledAgents();
+		const totalAgents = Object.keys(agents).length;
+		spinner.stop(`${totalAgents} agents`);
+		if (installedAgents.length === 0) if (options.yes) {
+			targetAgents = validAgents;
+			M.info("Installing to all agents");
+		} else {
+			M.info("Select agents to install skills to");
+			const selected = await promptForAgents("Which agents do you want to install to?", Object.entries(agents).map(([key, config]) => ({
+				value: key,
+				label: config.displayName
+			})));
+			if (pD(selected)) {
+				xe("Installation cancelled");
+				process.exit(0);
+			}
+			targetAgents = selected;
+		}
+		else if (installedAgents.length === 1 || options.yes) {
+			targetAgents = installedAgents;
+			if (installedAgents.length === 1) {
+				const firstAgent = installedAgents[0];
+				M.info(`Installing to: ${import_picocolors.default.cyan(agents[firstAgent].displayName)}`);
+			} else M.info(`Installing to: ${installedAgents.map((a) => import_picocolors.default.cyan(agents[a].displayName)).join(", ")}`);
+		} else {
+			const selected = await selectAgentsInteractive({ global: options.global });
+			if (pD(selected)) {
+				xe("Installation cancelled");
+				process.exit(0);
+			}
+			targetAgents = selected;
+		}
+	}
+	let installGlobally = options.global ?? false;
+	const supportsGlobal = targetAgents.some((a) => agents[a].globalSkillsDir !== void 0);
+	if (options.global === void 0 && !options.yes && supportsGlobal) {
+		const scope = await ve({
+			message: "Installation scope",
+			options: [{
+				value: false,
+				label: "Project",
+				hint: "Install in current directory (committed with your project)"
+			}, {
+				value: true,
+				label: "Global",
+				hint: "Install in home directory (available across all projects)"
+			}]
+		});
+		if (pD(scope)) {
+			xe("Installation cancelled");
+			process.exit(0);
+		}
+		installGlobally = scope;
+	}
+	const installMode = "symlink";
+	const cwd = process.cwd();
+	const overwriteChecks = await Promise.all(targetAgents.map(async (agent) => ({
+		agent,
+		installed: await isSkillInstalled(remoteSkill.installName, agent, { global: installGlobally })
+	})));
+	const overwriteStatus = new Map(overwriteChecks.map(({ agent, installed }) => [agent, installed]));
+	const summaryLines = [];
+	const agentNames = targetAgents.map((a) => agents[a].displayName);
+	const shortCanonical = shortenPath$1(getCanonicalPath(remoteSkill.installName, { global: installGlobally }), cwd);
+	summaryLines.push(`${import_picocolors.default.cyan(shortCanonical)}`);
+	summaryLines.push(`  ${import_picocolors.default.dim("symlink →")} ${formatList$1(agentNames)}`);
+	const overwriteAgents = targetAgents.filter((a) => overwriteStatus.get(a)).map((a) => agents[a].displayName);
+	if (overwriteAgents.length > 0) summaryLines.push(`  ${import_picocolors.default.yellow("overwrites:")} ${formatList$1(overwriteAgents)}`);
+	console.log();
+	Me(summaryLines.join("\n"), "Installation Summary");
+	if (!options.yes) {
+		const confirmed = await ye({ message: "Proceed with installation?" });
+		if (pD(confirmed) || !confirmed) {
+			xe("Installation cancelled");
+			process.exit(0);
+		}
+	}
+	spinner.start("Installing skill...");
+	const results = [];
+	for (const agent of targetAgents) {
+		const result = await installRemoteSkillForAgent(remoteSkill, agent, {
+			global: installGlobally,
+			mode: installMode
+		});
+		results.push({
+			skill: remoteSkill.installName,
+			agent: agents[agent].displayName,
+			...result
+		});
+	}
+	spinner.stop("Installation complete");
+	console.log();
+	const successful = results.filter((r) => r.success);
+	const failed = results.filter((r) => !r.success);
+	track({
+		event: "install",
+		source: "mintlify/com",
+		skills: remoteSkill.installName,
+		agents: targetAgents.join(","),
+		...installGlobally && { global: "1" },
+		skillFiles: JSON.stringify({ [remoteSkill.installName]: url }),
+		sourceType: "mintlify"
+	});
+	if (successful.length > 0 && installGlobally) try {
+		await addSkillToLock(remoteSkill.installName, {
+			source: `mintlify/${remoteSkill.installName}`,
+			sourceType: "mintlify",
+			sourceUrl: url,
+			skillFolderHash: ""
+		});
+	} catch {}
+	if (successful.length > 0) {
+		const resultLines = [];
+		const firstResult = successful[0];
+		if (firstResult.canonicalPath) {
+			const shortPath = shortenPath$1(firstResult.canonicalPath, cwd);
+			resultLines.push(`${import_picocolors.default.green("✓")} ${shortPath}`);
+		} else resultLines.push(`${import_picocolors.default.green("✓")} ${remoteSkill.installName}`);
+		const symlinked = successful.filter((r) => !r.symlinkFailed).map((r) => r.agent);
+		const copied = successful.filter((r) => r.symlinkFailed).map((r) => r.agent);
+		if (symlinked.length > 0) resultLines.push(`  ${import_picocolors.default.dim("symlink →")} ${formatList$1(symlinked)}`);
+		if (copied.length > 0) resultLines.push(`  ${import_picocolors.default.yellow("copied →")} ${formatList$1(copied)}`);
+		const title = import_picocolors.default.green(`Installed 1 skill to ${successful.length} agent${successful.length !== 1 ? "s" : ""}`);
+		Me(resultLines.join("\n"), title);
+		const symlinkFailures = successful.filter((r) => r.mode === "symlink" && r.symlinkFailed);
+		if (symlinkFailures.length > 0) {
+			const copiedAgentNames = symlinkFailures.map((r) => r.agent);
+			M.warn(import_picocolors.default.yellow(`Symlinks failed for: ${formatList$1(copiedAgentNames)}`));
+			M.message(import_picocolors.default.dim("  Files were copied instead. On Windows, enable Developer Mode for symlink support."));
+		}
+	}
+	if (failed.length > 0) {
+		console.log();
+		M.error(import_picocolors.default.red(`Failed to install ${failed.length}`));
+		for (const r of failed) M.message(`  ${import_picocolors.default.red("✗")} ${r.skill} → ${r.agent}: ${import_picocolors.default.dim(r.error)}`);
+	}
+	console.log();
+	Se(import_picocolors.default.green("Done!"));
+	await promptForFindSkills(options, targetAgents);
+}
+async function runAdd(args, options = {}) {
+	const source = args[0];
+	let installTipShown = false;
+	const showInstallTip = () => {
+		if (installTipShown) return;
+		M.message(import_picocolors.default.dim("Tip: use the --yes (-y) and --global (-g) flags to install without prompts."));
+		installTipShown = true;
+	};
+	if (!source) {
+		console.log();
+		console.log(import_picocolors.default.bgRed(import_picocolors.default.white(import_picocolors.default.bold(" ERROR "))) + " " + import_picocolors.default.red("Missing required argument: source"));
+		console.log();
+		console.log(import_picocolors.default.dim("  Usage:"));
+		console.log(`    ${import_picocolors.default.cyan("npx skills add")} ${import_picocolors.default.yellow("<source>")} ${import_picocolors.default.dim("[options]")}`);
+		console.log();
+		console.log(import_picocolors.default.dim("  Example:"));
+		console.log(`    ${import_picocolors.default.cyan("npx skills add")} ${import_picocolors.default.yellow("vercel-labs/agent-skills")}`);
+		console.log();
+		process.exit(1);
+	}
+	if (options.all) {
+		options.skill = ["*"];
+		options.agent = ["*"];
+		options.yes = true;
+	}
+	console.log();
+	Ie(import_picocolors.default.bgCyan(import_picocolors.default.black(" skills ")));
+	if (!process.stdin.isTTY) showInstallTip();
+	let tempDir = null;
+	try {
+		const spinner = Y();
+		spinner.start("Parsing source...");
+		const parsed = parseSource(source);
+		spinner.stop(`Source: ${parsed.type === "local" ? parsed.localPath : parsed.url}${parsed.ref ? ` @ ${import_picocolors.default.yellow(parsed.ref)}` : ""}${parsed.subpath ? ` (${parsed.subpath})` : ""}${parsed.skillFilter ? ` ${import_picocolors.default.dim("@")}${import_picocolors.default.cyan(parsed.skillFilter)}` : ""}`);
+		if (parsed.type === "direct-url") {
+			await handleRemoteSkill(source, parsed.url, options, spinner);
+			return;
+		}
+		if (parsed.type === "well-known") {
+			await handleWellKnownSkills(source, parsed.url, options, spinner);
+			return;
+		}
+		let skillsDir;
+		if (parsed.type === "local") {
+			spinner.start("Validating local path...");
+			if (!existsSync(parsed.localPath)) {
+				spinner.stop(import_picocolors.default.red("Path not found"));
+				Se(import_picocolors.default.red(`Local path does not exist: ${parsed.localPath}`));
+				process.exit(1);
+			}
+			skillsDir = parsed.localPath;
+			spinner.stop("Local path validated");
+		} else {
+			spinner.start("Cloning repository...");
+			tempDir = await cloneRepo(parsed.url, parsed.ref);
+			skillsDir = tempDir;
+			spinner.stop("Repository cloned");
+		}
+		if (parsed.skillFilter) {
+			options.skill = options.skill || [];
+			if (!options.skill.includes(parsed.skillFilter)) options.skill.push(parsed.skillFilter);
+		}
+		const includeInternal = !!(options.skill && options.skill.length > 0);
+		spinner.start("Discovering skills...");
+		const skills = await discoverSkills(skillsDir, parsed.subpath, {
+			includeInternal,
+			fullDepth: options.fullDepth
+		});
+		if (skills.length === 0) {
+			spinner.stop(import_picocolors.default.red("No skills found"));
+			Se(import_picocolors.default.red("No valid skills found. Skills require a SKILL.md with name and description."));
+			await cleanup(tempDir);
+			process.exit(1);
+		}
+		spinner.stop(`Found ${import_picocolors.default.green(skills.length)} skill${skills.length > 1 ? "s" : ""}`);
+		if (options.list) {
+			console.log();
+			M.step(import_picocolors.default.bold("Available Skills"));
+			for (const skill of skills) {
+				M.message(`  ${import_picocolors.default.cyan(getSkillDisplayName(skill))}`);
+				M.message(`    ${import_picocolors.default.dim(skill.description)}`);
+			}
+			console.log();
+			Se("Use --skill <name> to install specific skills");
+			await cleanup(tempDir);
+			process.exit(0);
+		}
+		let selectedSkills;
+		if (options.skill?.includes("*")) {
+			selectedSkills = skills;
+			M.info(`Installing all ${skills.length} skills`);
+		} else if (options.skill && options.skill.length > 0) {
+			selectedSkills = filterSkills(skills, options.skill);
+			if (selectedSkills.length === 0) {
+				M.error(`No matching skills found for: ${options.skill.join(", ")}`);
+				M.info("Available skills:");
+				for (const s of skills) M.message(`  - ${getSkillDisplayName(s)}`);
+				await cleanup(tempDir);
+				process.exit(1);
+			}
+			M.info(`Selected ${selectedSkills.length} skill${selectedSkills.length !== 1 ? "s" : ""}: ${selectedSkills.map((s) => import_picocolors.default.cyan(getSkillDisplayName(s))).join(", ")}`);
+		} else if (skills.length === 1) {
+			selectedSkills = skills;
+			const firstSkill = skills[0];
+			M.info(`Skill: ${import_picocolors.default.cyan(getSkillDisplayName(firstSkill))}`);
+			M.message(import_picocolors.default.dim(firstSkill.description));
+		} else if (options.yes) {
+			selectedSkills = skills;
+			M.info(`Installing all ${skills.length} skills`);
+		} else {
+			const selected = await multiselect({
+				message: "Select skills to install",
+				options: skills.map((s) => ({
+					value: s,
+					label: getSkillDisplayName(s),
+					hint: s.description.length > 60 ? s.description.slice(0, 57) + "..." : s.description
+				})),
+				required: true
+			});
+			if (pD(selected)) {
+				xe("Installation cancelled");
+				await cleanup(tempDir);
+				process.exit(0);
+			}
+			selectedSkills = selected;
+		}
+		let targetAgents;
+		const validAgents = Object.keys(agents);
+		if (options.agent?.includes("*")) {
+			targetAgents = validAgents;
+			M.info(`Installing to all ${targetAgents.length} agents`);
+		} else if (options.agent && options.agent.length > 0) {
+			const invalidAgents = options.agent.filter((a) => !validAgents.includes(a));
+			if (invalidAgents.length > 0) {
+				M.error(`Invalid agents: ${invalidAgents.join(", ")}`);
+				M.info(`Valid agents: ${validAgents.join(", ")}`);
+				await cleanup(tempDir);
+				process.exit(1);
+			}
+			targetAgents = options.agent;
+		} else {
+			spinner.start("Loading agents...");
+			const installedAgents = await detectInstalledAgents();
+			const totalAgents = Object.keys(agents).length;
+			spinner.stop(`${totalAgents} agents`);
+			if (installedAgents.length === 0) if (options.yes) {
+				targetAgents = validAgents;
+				M.info("Installing to all agents");
+			} else {
+				M.info("Select agents to install skills to");
+				const selected = await promptForAgents("Which agents do you want to install to?", Object.entries(agents).map(([key, config]) => ({
+					value: key,
+					label: config.displayName
+				})));
+				if (pD(selected)) {
+					xe("Installation cancelled");
+					await cleanup(tempDir);
+					process.exit(0);
+				}
+				targetAgents = selected;
+			}
+			else if (installedAgents.length === 1 || options.yes) {
+				targetAgents = installedAgents;
+				if (installedAgents.length === 1) {
+					const firstAgent = installedAgents[0];
+					M.info(`Installing to: ${import_picocolors.default.cyan(agents[firstAgent].displayName)}`);
+				} else M.info(`Installing to: ${installedAgents.map((a) => import_picocolors.default.cyan(agents[a].displayName)).join(", ")}`);
+			} else {
+				const selected = await selectAgentsInteractive({ global: options.global });
+				if (pD(selected)) {
+					xe("Installation cancelled");
+					await cleanup(tempDir);
+					process.exit(0);
+				}
+				targetAgents = selected;
+			}
+		}
+		let installGlobally = options.global ?? false;
+		const supportsGlobal = targetAgents.some((a) => agents[a].globalSkillsDir !== void 0);
+		if (options.global === void 0 && !options.yes && supportsGlobal) {
+			const scope = await ve({
+				message: "Installation scope",
+				options: [{
+					value: false,
+					label: "Project",
+					hint: "Install in current directory (committed with your project)"
+				}, {
+					value: true,
+					label: "Global",
+					hint: "Install in home directory (available across all projects)"
+				}]
+			});
+			if (pD(scope)) {
+				xe("Installation cancelled");
+				await cleanup(tempDir);
+				process.exit(0);
+			}
+			installGlobally = scope;
+		}
+		let installMode = "symlink";
+		if (!options.yes) {
+			const modeChoice = await ve({
+				message: "Installation method",
+				options: [{
+					value: "symlink",
+					label: "Symlink (Recommended)",
+					hint: "Single source of truth, easy updates"
+				}, {
+					value: "copy",
+					label: "Copy to all agents",
+					hint: "Independent copies for each agent"
+				}]
+			});
+			if (pD(modeChoice)) {
+				xe("Installation cancelled");
+				await cleanup(tempDir);
+				process.exit(0);
+			}
+			installMode = modeChoice;
+		}
+		const cwd = process.cwd();
+		const summaryLines = [];
+		const agentNames = targetAgents.map((a) => agents[a].displayName);
+		const overwriteChecks = await Promise.all(selectedSkills.flatMap((skill) => targetAgents.map(async (agent) => ({
+			skillName: skill.name,
+			agent,
+			installed: await isSkillInstalled(skill.name, agent, { global: installGlobally })
+		}))));
+		const overwriteStatus = /* @__PURE__ */ new Map();
+		for (const { skillName, agent, installed } of overwriteChecks) {
+			if (!overwriteStatus.has(skillName)) overwriteStatus.set(skillName, /* @__PURE__ */ new Map());
+			overwriteStatus.get(skillName).set(agent, installed);
+		}
+		for (const skill of selectedSkills) {
+			if (summaryLines.length > 0) summaryLines.push("");
+			if (installMode === "symlink") {
+				const shortCanonical = shortenPath$1(getCanonicalPath(skill.name, { global: installGlobally }), cwd);
+				summaryLines.push(`${import_picocolors.default.cyan(shortCanonical)}`);
+				summaryLines.push(`  ${import_picocolors.default.dim("symlink →")} ${formatList$1(agentNames)}`);
+			} else {
+				summaryLines.push(`${import_picocolors.default.cyan(getSkillDisplayName(skill))}`);
+				summaryLines.push(`  ${import_picocolors.default.dim("copy →")} ${formatList$1(agentNames)}`);
+			}
+			const skillOverwrites = overwriteStatus.get(skill.name);
+			const overwriteAgents = targetAgents.filter((a) => skillOverwrites?.get(a)).map((a) => agents[a].displayName);
+			if (overwriteAgents.length > 0) summaryLines.push(`  ${import_picocolors.default.yellow("overwrites:")} ${formatList$1(overwriteAgents)}`);
+		}
+		console.log();
+		Me(summaryLines.join("\n"), "Installation Summary");
+		if (!options.yes) {
+			const confirmed = await ye({ message: "Proceed with installation?" });
+			if (pD(confirmed) || !confirmed) {
+				xe("Installation cancelled");
+				await cleanup(tempDir);
+				process.exit(0);
+			}
+		}
+		spinner.start("Installing skills...");
+		const results = [];
+		for (const skill of selectedSkills) for (const agent of targetAgents) {
+			const result = await installSkillForAgent(skill, agent, {
+				global: installGlobally,
+				mode: installMode
+			});
+			results.push({
+				skill: getSkillDisplayName(skill),
+				agent: agents[agent].displayName,
+				...result
+			});
+		}
+		spinner.stop("Installation complete");
+		console.log();
+		const successful = results.filter((r) => r.success);
+		const failed = results.filter((r) => !r.success);
+		const skillFiles = {};
+		for (const skill of selectedSkills) {
+			let relativePath;
+			if (tempDir && skill.path === tempDir) relativePath = "SKILL.md";
+			else if (tempDir && skill.path.startsWith(tempDir + sep)) relativePath = skill.path.slice(tempDir.length + 1).split(sep).join("/") + "/SKILL.md";
+			else continue;
+			skillFiles[skill.name] = relativePath;
+		}
+		const normalizedSource = getOwnerRepo(parsed);
+		if (normalizedSource) {
+			const ownerRepo = parseOwnerRepo(normalizedSource);
+			if (ownerRepo) {
+				if (await isRepoPrivate(ownerRepo.owner, ownerRepo.repo) === false) track({
+					event: "install",
+					source: normalizedSource,
+					skills: selectedSkills.map((s) => s.name).join(","),
+					agents: targetAgents.join(","),
+					...installGlobally && { global: "1" },
+					skillFiles: JSON.stringify(skillFiles)
+				});
+			} else track({
+				event: "install",
+				source: normalizedSource,
+				skills: selectedSkills.map((s) => s.name).join(","),
+				agents: targetAgents.join(","),
+				...installGlobally && { global: "1" },
+				skillFiles: JSON.stringify(skillFiles)
+			});
+		}
+		if (successful.length > 0 && installGlobally && normalizedSource) {
+			const successfulSkillNames = new Set(successful.map((r) => r.skill));
+			for (const skill of selectedSkills) {
+				const skillDisplayName = getSkillDisplayName(skill);
+				if (successfulSkillNames.has(skillDisplayName)) try {
+					let skillFolderHash = "";
+					const skillPathValue = skillFiles[skill.name];
+					if (parsed.type === "github" && skillPathValue) {
+						const hash = await fetchSkillFolderHash(normalizedSource, skillPathValue);
+						if (hash) skillFolderHash = hash;
+					}
+					await addSkillToLock(skill.name, {
+						source: normalizedSource,
+						sourceType: parsed.type,
+						sourceUrl: parsed.url,
+						skillPath: skillPathValue,
+						skillFolderHash
+					});
+				} catch {}
+			}
+		}
+		if (successful.length > 0) {
+			const bySkill = /* @__PURE__ */ new Map();
+			for (const r of successful) {
+				const skillResults = bySkill.get(r.skill) || [];
+				skillResults.push(r);
+				bySkill.set(r.skill, skillResults);
+			}
+			const skillCount = bySkill.size;
+			const agentCount = new Set(successful.map((r) => r.agent)).size;
+			const symlinkFailures = successful.filter((r) => r.mode === "symlink" && r.symlinkFailed);
+			const copiedAgents = symlinkFailures.map((r) => r.agent);
+			const resultLines = [];
+			for (const [skillName, skillResults] of bySkill) {
+				const firstResult = skillResults[0];
+				if (firstResult.mode === "copy") {
+					resultLines.push(`${import_picocolors.default.green("✓")} ${skillName} ${import_picocolors.default.dim("(copied)")}`);
+					for (const r of skillResults) {
+						const shortPath = shortenPath$1(r.path, cwd);
+						resultLines.push(`  ${import_picocolors.default.dim("→")} ${shortPath}`);
+					}
+				} else {
+					if (firstResult.canonicalPath) {
+						const shortPath = shortenPath$1(firstResult.canonicalPath, cwd);
+						resultLines.push(`${import_picocolors.default.green("✓")} ${shortPath}`);
+					} else resultLines.push(`${import_picocolors.default.green("✓")} ${skillName}`);
+					const symlinked = skillResults.filter((r) => !r.symlinkFailed).map((r) => r.agent);
+					const copied = skillResults.filter((r) => r.symlinkFailed).map((r) => r.agent);
+					if (symlinked.length > 0) resultLines.push(`  ${import_picocolors.default.dim("symlink →")} ${formatList$1(symlinked)}`);
+					if (copied.length > 0) resultLines.push(`  ${import_picocolors.default.yellow("copied →")} ${formatList$1(copied)}`);
+				}
+			}
+			const title = import_picocolors.default.green(`Installed ${skillCount} skill${skillCount !== 1 ? "s" : ""} to ${agentCount} agent${agentCount !== 1 ? "s" : ""}`);
+			Me(resultLines.join("\n"), title);
+			if (symlinkFailures.length > 0) {
+				M.warn(import_picocolors.default.yellow(`Symlinks failed for: ${formatList$1(copiedAgents)}`));
+				M.message(import_picocolors.default.dim("  Files were copied instead. On Windows, enable Developer Mode for symlink support."));
+			}
+		}
+		if (failed.length > 0) {
+			console.log();
+			M.error(import_picocolors.default.red(`Failed to install ${failed.length}`));
+			for (const r of failed) M.message(`  ${import_picocolors.default.red("✗")} ${r.skill} → ${r.agent}: ${import_picocolors.default.dim(r.error)}`);
+		}
+		console.log();
+		Se(import_picocolors.default.green("Done!"));
+		await promptForFindSkills(options, targetAgents);
+	} catch (error) {
+		if (error instanceof GitCloneError) {
+			M.error(import_picocolors.default.red("Failed to clone repository"));
+			for (const line of error.message.split("\n")) M.message(import_picocolors.default.dim(line));
+		} else M.error(error instanceof Error ? error.message : "Unknown error occurred");
+		showInstallTip();
+		Se(import_picocolors.default.red("Installation failed"));
+		process.exit(1);
+	} finally {
+		await cleanup(tempDir);
+	}
+}
+async function cleanup(tempDir) {
+	if (tempDir) try {
+		await cleanupTempDir(tempDir);
+	} catch {}
+}
+async function promptForFindSkills(options, targetAgents) {
+	if (!process.stdin.isTTY) return;
+	if (options?.yes) return;
+	try {
+		if (await isPromptDismissed("findSkillsPrompt")) return;
+		if (await isSkillInstalled("find-skills", "claude-code", { global: true })) {
+			await dismissPrompt("findSkillsPrompt");
+			return;
+		}
+		console.log();
+		M.message(import_picocolors.default.dim("One-time prompt - you won't be asked again if you dismiss."));
+		const install = await ye({ message: `Install the ${import_picocolors.default.cyan("find-skills")} skill? It helps your agent discover and suggest skills.` });
+		if (pD(install)) {
+			await dismissPrompt("findSkillsPrompt");
+			return;
+		}
+		if (install) {
+			await dismissPrompt("findSkillsPrompt");
+			const findSkillsAgents = targetAgents?.filter((a) => a !== "replit");
+			if (!findSkillsAgents || findSkillsAgents.length === 0) return;
+			console.log();
+			M.step("Installing find-skills skill...");
+			try {
+				await runAdd(["vercel-labs/skills"], {
+					skill: ["find-skills"],
+					global: true,
+					yes: true,
+					agent: findSkillsAgents
+				});
+			} catch {
+				M.warn("Failed to install find-skills. You can try again with:");
+				M.message(import_picocolors.default.dim("  npx skills add vercel-labs/skills@find-skills -g -y --all"));
+			}
+		} else {
+			await dismissPrompt("findSkillsPrompt");
+			M.message(import_picocolors.default.dim("You can install it later with: npx skills add vercel-labs/skills@find-skills"));
+		}
+	} catch {}
+}
+function parseAddOptions(args) {
+	const options = {};
+	const source = [];
+	for (let i = 0; i < args.length; i++) {
+		const arg = args[i];
+		if (arg === "-g" || arg === "--global") options.global = true;
+		else if (arg === "-y" || arg === "--yes") options.yes = true;
+		else if (arg === "-l" || arg === "--list") options.list = true;
+		else if (arg === "--all") options.all = true;
+		else if (arg === "-a" || arg === "--agent") {
+			options.agent = options.agent || [];
+			i++;
+			let nextArg = args[i];
+			while (i < args.length && nextArg && !nextArg.startsWith("-")) {
+				options.agent.push(nextArg);
+				i++;
+				nextArg = args[i];
+			}
+			i--;
+		} else if (arg === "-s" || arg === "--skill") {
+			options.skill = options.skill || [];
+			i++;
+			let nextArg = args[i];
+			while (i < args.length && nextArg && !nextArg.startsWith("-")) {
+				options.skill.push(nextArg);
+				i++;
+				nextArg = args[i];
+			}
+			i--;
+		} else if (arg === "--full-depth") options.fullDepth = true;
+		else if (arg && !arg.startsWith("-")) source.push(arg);
+	}
+	return {
+		source,
+		options
+	};
+}
+const RESET$2 = "\x1B[0m";
+const BOLD$2 = "\x1B[1m";
+const DIM$2 = "\x1B[38;5;102m";
+const TEXT$1 = "\x1B[38;5;145m";
+const SEARCH_API_BASE = process.env.SKILLS_API_URL || "https://skills.sh";
+async function searchSkillsAPI(query) {
+	try {
+		const url = `${SEARCH_API_BASE}/api/search?q=${encodeURIComponent(query)}&limit=10`;
+		const res = await fetch(url);
+		if (!res.ok) return [];
+		return (await res.json()).skills.map((skill) => ({
+			name: skill.name,
+			slug: skill.id,
+			source: skill.topSource || "",
+			installs: skill.installs
+		}));
+	} catch {
+		return [];
+	}
+}
+const HIDE_CURSOR = "\x1B[?25l";
+const SHOW_CURSOR = "\x1B[?25h";
+const CLEAR_DOWN = "\x1B[J";
+const MOVE_UP = (n) => `\x1b[${n}A`;
+const MOVE_TO_COL = (n) => `\x1b[${n}G`;
+async function runSearchPrompt(initialQuery = "") {
+	let results = [];
+	let selectedIndex = 0;
+	let query = initialQuery;
+	let loading = false;
+	let debounceTimer = null;
+	let lastRenderedLines = 0;
+	if (process.stdin.isTTY) process.stdin.setRawMode(true);
+	readline.emitKeypressEvents(process.stdin);
+	process.stdin.resume();
+	process.stdout.write(HIDE_CURSOR);
+	function render() {
+		if (lastRenderedLines > 0) process.stdout.write(MOVE_UP(lastRenderedLines) + MOVE_TO_COL(1));
+		process.stdout.write(CLEAR_DOWN);
+		const lines = [];
+		const cursor = `${BOLD$2}_${RESET$2}`;
+		lines.push(`${TEXT$1}Search skills:${RESET$2} ${query}${cursor}`);
+		lines.push("");
+		if (!query || query.length < 2) lines.push(`${DIM$2}Start typing to search (min 2 chars)${RESET$2}`);
+		else if (results.length === 0 && loading) lines.push(`${DIM$2}Searching...${RESET$2}`);
+		else if (results.length === 0) lines.push(`${DIM$2}No skills found${RESET$2}`);
+		else {
+			const visible = results.slice(0, 8);
+			for (let i = 0; i < visible.length; i++) {
+				const skill = visible[i];
+				const isSelected = i === selectedIndex;
+				const arrow = isSelected ? `${BOLD$2}>${RESET$2}` : " ";
+				const name = isSelected ? `${BOLD$2}${skill.name}${RESET$2}` : `${TEXT$1}${skill.name}${RESET$2}`;
+				const source = skill.source ? ` ${DIM$2}${skill.source}${RESET$2}` : "";
+				const loadingIndicator = loading && i === 0 ? ` ${DIM$2}...${RESET$2}` : "";
+				lines.push(`  ${arrow} ${name}${source}${loadingIndicator}`);
+			}
+		}
+		lines.push("");
+		lines.push(`${DIM$2}up/down navigate | enter select | esc cancel${RESET$2}`);
+		for (const line of lines) process.stdout.write(line + "\n");
+		lastRenderedLines = lines.length;
+	}
+	function triggerSearch(q) {
+		if (debounceTimer) {
+			clearTimeout(debounceTimer);
+			debounceTimer = null;
+		}
+		loading = false;
+		if (!q || q.length < 2) {
+			results = [];
+			selectedIndex = 0;
+			render();
+			return;
+		}
+		loading = true;
+		render();
+		const debounceMs = Math.max(150, 350 - q.length * 50);
+		debounceTimer = setTimeout(async () => {
+			try {
+				results = await searchSkillsAPI(q);
+				selectedIndex = 0;
+			} catch {
+				results = [];
+			} finally {
+				loading = false;
+				debounceTimer = null;
+				render();
+			}
+		}, debounceMs);
+	}
+	if (initialQuery) triggerSearch(initialQuery);
+	render();
+	return new Promise((resolve) => {
+		function cleanup() {
+			process.stdin.removeListener("keypress", handleKeypress);
+			if (process.stdin.isTTY) process.stdin.setRawMode(false);
+			process.stdout.write(SHOW_CURSOR);
+			process.stdin.pause();
+		}
+		function handleKeypress(_ch, key) {
+			if (!key) return;
+			if (key.name === "escape" || key.ctrl && key.name === "c") {
+				cleanup();
+				resolve(null);
+				return;
+			}
+			if (key.name === "return") {
+				cleanup();
+				resolve(results[selectedIndex] || null);
+				return;
+			}
+			if (key.name === "up") {
+				selectedIndex = Math.max(0, selectedIndex - 1);
+				render();
+				return;
+			}
+			if (key.name === "down") {
+				selectedIndex = Math.min(Math.max(0, results.length - 1), selectedIndex + 1);
+				render();
+				return;
+			}
+			if (key.name === "backspace") {
+				if (query.length > 0) {
+					query = query.slice(0, -1);
+					triggerSearch(query);
+				}
+				return;
+			}
+			if (key.sequence && !key.ctrl && !key.meta && key.sequence.length === 1) {
+				const char = key.sequence;
+				if (char >= " " && char <= "~") {
+					query += char;
+					triggerSearch(query);
+				}
+			}
+		}
+		process.stdin.on("keypress", handleKeypress);
+	});
+}
+function getOwnerRepoFromString(pkg) {
+	const atIndex = pkg.lastIndexOf("@");
+	const match = (atIndex > 0 ? pkg.slice(0, atIndex) : pkg).match(/^([^/]+)\/([^/]+)$/);
+	if (match) return {
+		owner: match[1],
+		repo: match[2]
+	};
+	return null;
+}
+async function isRepoPublic(owner, repo) {
+	return await isRepoPrivate(owner, repo) === false;
+}
+async function runFind(args) {
+	const query = args.join(" ");
+	const isNonInteractive = !process.stdin.isTTY;
+	const agentTip = `${DIM$2}Tip: if running in a coding agent, follow these steps:${RESET$2}
+${DIM$2}  1) npx skills find [query]${RESET$2}
+${DIM$2}  2) npx skills add <owner/repo@skill>${RESET$2}`;
+	if (query) {
+		const results = await searchSkillsAPI(query);
+		track({
+			event: "find",
+			query,
+			resultCount: String(results.length)
+		});
+		if (results.length === 0) {
+			console.log(`${DIM$2}No skills found for "${query}"${RESET$2}`);
+			return;
+		}
+		console.log(`${DIM$2}Install with${RESET$2} npx skills add <owner/repo@skill>`);
+		console.log();
+		for (const skill of results.slice(0, 6)) {
+			const pkg = skill.source || skill.slug;
+			console.log(`${TEXT$1}${pkg}@${skill.name}${RESET$2}`);
+			console.log(`${DIM$2}└ https://skills.sh/${pkg}/${skill.slug}${RESET$2}`);
+			console.log();
+		}
+		return;
+	}
+	if (isNonInteractive) {
+		console.log(agentTip);
+		console.log();
+	}
+	const selected = await runSearchPrompt();
+	track({
+		event: "find",
+		query: "",
+		resultCount: selected ? "1" : "0",
+		interactive: "1"
+	});
+	if (!selected) {
+		console.log(`${DIM$2}Search cancelled${RESET$2}`);
+		console.log();
+		return;
+	}
+	const pkg = selected.source || selected.slug;
+	const skillName = selected.name;
+	console.log();
+	console.log(`${TEXT$1}Installing ${BOLD$2}${skillName}${RESET$2} from ${DIM$2}${pkg}${RESET$2}...`);
+	console.log();
+	const { source, options } = parseAddOptions([
+		pkg,
+		"--skill",
+		skillName
+	]);
+	await runAdd(source, options);
+	console.log();
+	const info = getOwnerRepoFromString(pkg);
+	if (info && await isRepoPublic(info.owner, info.repo)) console.log(`${DIM$2}View the skill at${RESET$2} ${TEXT$1}https://skills.sh/${info.owner}/${info.repo}/${selected.slug}${RESET$2}`);
+	else console.log(`${DIM$2}Discover more skills at${RESET$2} ${TEXT$1}https://skills.sh${RESET$2}`);
+	console.log();
+}
+const RESET$1 = "\x1B[0m";
+const BOLD$1 = "\x1B[1m";
+const DIM$1 = "\x1B[38;5;102m";
+const CYAN = "\x1B[36m";
+const YELLOW = "\x1B[33m";
+function shortenPath(fullPath, cwd) {
+	const home = homedir();
+	if (fullPath.startsWith(home)) return fullPath.replace(home, "~");
+	if (fullPath.startsWith(cwd)) return "." + fullPath.slice(cwd.length);
+	return fullPath;
+}
+function formatList(items, maxShow = 5) {
+	if (items.length <= maxShow) return items.join(", ");
+	const shown = items.slice(0, maxShow);
+	const remaining = items.length - maxShow;
+	return `${shown.join(", ")} +${remaining} more`;
+}
+function parseListOptions(args) {
+	const options = {};
+	for (let i = 0; i < args.length; i++) {
+		const arg = args[i];
+		if (arg === "-g" || arg === "--global") options.global = true;
+		else if (arg === "-a" || arg === "--agent") {
+			options.agent = options.agent || [];
+			while (i + 1 < args.length && !args[i + 1].startsWith("-")) options.agent.push(args[++i]);
+		}
+	}
+	return options;
+}
+async function runList(args) {
+	const options = parseListOptions(args);
+	const scope = options.global === true ? true : false;
+	let agentFilter;
+	if (options.agent && options.agent.length > 0) {
+		const validAgents = Object.keys(agents);
+		const invalidAgents = options.agent.filter((a) => !validAgents.includes(a));
+		if (invalidAgents.length > 0) {
+			console.log(`${YELLOW}Invalid agents: ${invalidAgents.join(", ")}${RESET$1}`);
+			console.log(`${DIM$1}Valid agents: ${validAgents.join(", ")}${RESET$1}`);
+			process.exit(1);
+		}
+		agentFilter = options.agent;
+	}
+	const installedSkills = await listInstalledSkills({
+		global: scope,
+		agentFilter
+	});
+	const cwd = process.cwd();
+	const scopeLabel = scope ? "Global" : "Project";
+	if (installedSkills.length === 0) {
+		console.log(`${DIM$1}No ${scopeLabel.toLowerCase()} skills found.${RESET$1}`);
+		if (scope) console.log(`${DIM$1}Try listing project skills without -g${RESET$1}`);
+		else console.log(`${DIM$1}Try listing global skills with -g${RESET$1}`);
+		return;
+	}
+	function printSkill(skill) {
+		const shortPath = shortenPath(skill.canonicalPath, cwd);
+		const agentNames = skill.agents.map((a) => agents[a].displayName);
+		const agentInfo = skill.agents.length > 0 ? formatList(agentNames) : `${YELLOW}not linked${RESET$1}`;
+		console.log(`${CYAN}${skill.name}${RESET$1} ${DIM$1}${shortPath}${RESET$1}`);
+		console.log(`  ${DIM$1}Agents:${RESET$1} ${agentInfo}`);
+	}
+	console.log(`${BOLD$1}${scopeLabel} Skills${RESET$1}`);
+	console.log();
+	for (const skill of installedSkills) printSkill(skill);
+	console.log();
+}
+async function removeCommand(skillNames, options) {
+	const isGlobal = options.global ?? false;
+	const cwd = process.cwd();
+	const spinner = Y();
+	spinner.start("Scanning for installed skills...");
+	const skillNamesSet = /* @__PURE__ */ new Set();
+	const scanDir = async (dir) => {
+		try {
+			const entries = await readdir(dir, { withFileTypes: true });
+			for (const entry of entries) if (entry.isDirectory()) skillNamesSet.add(entry.name);
+		} catch (err) {
+			if (err instanceof Error && err.code !== "ENOENT") M.warn(`Could not scan directory ${dir}: ${err.message}`);
+		}
+	};
+	if (isGlobal) {
+		await scanDir(getCanonicalSkillsDir(true, cwd));
+		for (const agent of Object.values(agents)) if (agent.globalSkillsDir !== void 0) await scanDir(agent.globalSkillsDir);
+	} else {
+		await scanDir(getCanonicalSkillsDir(false, cwd));
+		for (const agent of Object.values(agents)) await scanDir(join(cwd, agent.skillsDir));
+	}
+	const installedSkills = Array.from(skillNamesSet).sort();
+	spinner.stop(`Found ${installedSkills.length} unique installed skill(s)`);
+	if (installedSkills.length === 0) {
+		Se(import_picocolors.default.yellow("No skills found to remove."));
+		return;
+	}
+	if (options.agent && options.agent.length > 0) {
+		const validAgents = Object.keys(agents);
+		const invalidAgents = options.agent.filter((a) => !validAgents.includes(a));
+		if (invalidAgents.length > 0) {
+			M.error(`Invalid agents: ${invalidAgents.join(", ")}`);
+			M.info(`Valid agents: ${validAgents.join(", ")}`);
+			process.exit(1);
+		}
+	}
+	let selectedSkills = [];
+	if (options.all) selectedSkills = installedSkills;
+	else if (skillNames.length > 0) {
+		selectedSkills = installedSkills.filter((s) => skillNames.some((name) => name.toLowerCase() === s.toLowerCase()));
+		if (selectedSkills.length === 0) {
+			M.error(`No matching skills found for: ${skillNames.join(", ")}`);
+			return;
+		}
+	} else {
+		const choices = installedSkills.map((s) => ({
+			value: s,
+			label: s
+		}));
+		const selected = await fe({
+			message: `Select skills to remove ${import_picocolors.default.dim("(space to toggle)")}`,
+			options: choices,
+			required: true
+		});
+		if (pD(selected)) {
+			xe("Removal cancelled");
+			process.exit(0);
+		}
+		selectedSkills = selected;
+	}
+	let targetAgents;
+	if (options.agent && options.agent.length > 0) targetAgents = options.agent;
+	else {
+		spinner.start("Detecting installed agents...");
+		targetAgents = await detectInstalledAgents();
+		if (targetAgents.length === 0) targetAgents = Object.keys(agents);
+		spinner.stop(`Targeting ${targetAgents.length} installed agent(s)`);
+	}
+	if (!options.yes) {
+		console.log();
+		M.info("Skills to remove:");
+		for (const skill of selectedSkills) M.message(`  ${import_picocolors.default.red("•")} ${skill}`);
+		console.log();
+		const confirmed = await ye({ message: `Are you sure you want to uninstall ${selectedSkills.length} skill(s)?` });
+		if (pD(confirmed) || !confirmed) {
+			xe("Removal cancelled");
+			process.exit(0);
+		}
+	}
+	spinner.start("Removing skills...");
+	const results = [];
+	for (const skillName of selectedSkills) try {
+		for (const agentKey of targetAgents) {
+			const agent = agents[agentKey];
+			const skillPath = getInstallPath(skillName, agentKey, {
+				global: isGlobal,
+				cwd
+			});
+			try {
+				if (await lstat(skillPath).catch(() => null)) await rm(skillPath, {
+					recursive: true,
+					force: true
+				});
+			} catch (err) {
+				M.warn(`Could not remove skill from ${agent.displayName}: ${err instanceof Error ? err.message : String(err)}`);
+			}
+		}
+		await rm(getCanonicalPath(skillName, {
+			global: isGlobal,
+			cwd
+		}), {
+			recursive: true,
+			force: true
+		});
+		const lockEntry = isGlobal ? await getSkillFromLock(skillName) : null;
+		const effectiveSource = lockEntry?.source || "local";
+		const effectiveSourceType = lockEntry?.sourceType || "local";
+		if (isGlobal) await removeSkillFromLock(skillName);
+		results.push({
+			skill: skillName,
+			success: true,
+			source: effectiveSource,
+			sourceType: effectiveSourceType
+		});
+	} catch (err) {
+		results.push({
+			skill: skillName,
+			success: false,
+			error: err instanceof Error ? err.message : String(err)
+		});
+	}
+	spinner.stop("Removal process complete");
+	const successful = results.filter((r) => r.success);
+	const failed = results.filter((r) => !r.success);
+	if (successful.length > 0) {
+		const bySource = /* @__PURE__ */ new Map();
+		for (const r of successful) {
+			const source = r.source || "local";
+			const existing = bySource.get(source) || { skills: [] };
+			existing.skills.push(r.skill);
+			existing.sourceType = r.sourceType;
+			bySource.set(source, existing);
+		}
+		for (const [source, data] of bySource) track({
+			event: "remove",
+			source,
+			skills: data.skills.join(","),
+			agents: targetAgents.join(","),
+			...isGlobal && { global: "1" },
+			sourceType: data.sourceType
+		});
+	}
+	if (successful.length > 0) M.success(import_picocolors.default.green(`Successfully removed ${successful.length} skill(s)`));
+	if (failed.length > 0) {
+		M.error(import_picocolors.default.red(`Failed to remove ${failed.length} skill(s)`));
+		for (const r of failed) M.message(`  ${import_picocolors.default.red("✗")} ${r.skill}: ${r.error}`);
+	}
+	console.log();
+	Se(import_picocolors.default.green("Done!"));
+}
+function parseRemoveOptions(args) {
+	const options = {};
+	const skills = [];
+	for (let i = 0; i < args.length; i++) {
+		const arg = args[i];
+		if (arg === "-g" || arg === "--global") options.global = true;
+		else if (arg === "-y" || arg === "--yes") options.yes = true;
+		else if (arg === "--all") options.all = true;
+		else if (arg === "-a" || arg === "--agent") {
+			options.agent = options.agent || [];
+			i++;
+			let nextArg = args[i];
+			while (i < args.length && nextArg && !nextArg.startsWith("-")) {
+				options.agent.push(nextArg);
+				i++;
+				nextArg = args[i];
+			}
+			i--;
+		} else if (arg && !arg.startsWith("-")) skills.push(arg);
+	}
+	return {
+		skills,
+		options
+	};
+}
+const __dirname = dirname(fileURLToPath(import.meta.url));
+function getVersion() {
+	try {
+		const pkgPath = join(__dirname, "..", "package.json");
+		return JSON.parse(readFileSync(pkgPath, "utf-8")).version;
+	} catch {
+		return "0.0.0";
+	}
+}
+const VERSION = getVersion();
+initTelemetry(VERSION);
+const RESET = "\x1B[0m";
+const BOLD = "\x1B[1m";
+const DIM = "\x1B[38;5;102m";
+const TEXT = "\x1B[38;5;145m";
+const LOGO_LINES = [
+	"███████╗██╗  ██╗██╗██╗     ██╗     ███████╗",
+	"██╔════╝██║ ██╔╝██║██║     ██║     ██╔════╝",
+	"███████╗█████╔╝ ██║██║     ██║     ███████╗",
+	"╚════██║██╔═██╗ ██║██║     ██║     ╚════██║",
+	"███████║██║  ██╗██║███████╗███████╗███████║",
+	"╚══════╝╚═╝  ╚═╝╚═╝╚══════╝╚══════╝╚══════╝"
+];
+const GRAYS = [
+	"\x1B[38;5;250m",
+	"\x1B[38;5;248m",
+	"\x1B[38;5;245m",
+	"\x1B[38;5;243m",
+	"\x1B[38;5;240m",
+	"\x1B[38;5;238m"
+];
+function showLogo() {
+	console.log();
+	LOGO_LINES.forEach((line, i) => {
+		console.log(`${GRAYS[i]}${line}${RESET}`);
+	});
+}
+function showBanner() {
+	showLogo();
+	console.log();
+	console.log(`${DIM}The open agent skills ecosystem${RESET}`);
+	console.log();
+	console.log(`  ${DIM}$${RESET} ${TEXT}npx skills add ${DIM}<package>${RESET}   ${DIM}Install a skill${RESET}`);
+	console.log(`  ${DIM}$${RESET} ${TEXT}npx skills list${RESET}            ${DIM}List installed skills${RESET}`);
+	console.log(`  ${DIM}$${RESET} ${TEXT}npx skills find ${DIM}[query]${RESET}    ${DIM}Search for skills${RESET}`);
+	console.log(`  ${DIM}$${RESET} ${TEXT}npx skills check${RESET}           ${DIM}Check for updates${RESET}`);
+	console.log(`  ${DIM}$${RESET} ${TEXT}npx skills update${RESET}          ${DIM}Update all skills${RESET}`);
+	console.log(`  ${DIM}$${RESET} ${TEXT}npx skills remove${RESET}          ${DIM}Remove installed skills${RESET}`);
+	console.log(`  ${DIM}$${RESET} ${TEXT}npx skills init ${DIM}[name]${RESET}     ${DIM}Create a new skill${RESET}`);
+	console.log();
+	console.log(`${DIM}try:${RESET} npx skills add vercel-labs/agent-skills`);
+	console.log();
+	console.log(`Discover more skills at ${TEXT}https://skills.sh/${RESET}`);
+	console.log();
+}
+function showHelp() {
+	console.log(`
+${BOLD}Usage:${RESET} skills <command> [options]
+
+${BOLD}Commands:${RESET}
+  add <package>     Add a skill package
+                    e.g. vercel-labs/agent-skills
+                         https://github.com/vercel-labs/agent-skills
+  remove [skills]   Remove installed skills
+  list, ls          List installed skills
+  find [query]      Search for skills interactively
+  init [name]       Initialize a skill (creates <name>/SKILL.md or ./SKILL.md)
+  check             Check for available skill updates
+  update            Update all skills to latest versions
+
+${BOLD}Add Options:${RESET}
+  -g, --global           Install skill globally (user-level) instead of project-level
+  -a, --agent <agents>   Specify agents to install to (use '*' for all agents)
+  -s, --skill <skills>   Specify skill names to install (use '*' for all skills)
+  -l, --list             List available skills in the repository without installing
+  -y, --yes              Skip confirmation prompts
+  --all                  Shorthand for --skill '*' --agent '*' -y
+  --full-depth           Search all subdirectories even when a root SKILL.md exists
+
+${BOLD}Remove Options:${RESET}
+  -g, --global           Remove from global scope
+  -a, --agent <agents>   Remove from specific agents (use '*' for all agents)
+  -s, --skill <skills>   Specify skills to remove (use '*' for all skills)
+  -y, --yes              Skip confirmation prompts
+  --all                  Shorthand for --skill '*' --agent '*' -y
+  
+${BOLD}List Options:${RESET}
+  -g, --global           List global skills (default: project)
+  -a, --agent <agents>   Filter by specific agents
+
+${BOLD}Options:${RESET}
+  --help, -h        Show this help message
+  --version, -v     Show version number
+
+${BOLD}Examples:${RESET}
+  ${DIM}$${RESET} skills add vercel-labs/agent-skills
+  ${DIM}$${RESET} skills add vercel-labs/agent-skills -g
+  ${DIM}$${RESET} skills add vercel-labs/agent-skills --agent claude-code cursor
+  ${DIM}$${RESET} skills add vercel-labs/agent-skills --skill pr-review commit
+  ${DIM}$${RESET} skills remove                   ${DIM}# interactive remove${RESET}
+  ${DIM}$${RESET} skills remove web-design        ${DIM}# remove by name${RESET}
+  ${DIM}$${RESET} skills rm --global frontend-design
+  ${DIM}$${RESET} skills list                     ${DIM}# list all installed skills${RESET}
+  ${DIM}$${RESET} skills ls -g                    ${DIM}# list global skills only${RESET}
+  ${DIM}$${RESET} skills ls -a claude-code        ${DIM}# filter by agent${RESET}
+  ${DIM}$${RESET} skills find                     ${DIM}# interactive search${RESET}
+  ${DIM}$${RESET} skills find typescript          ${DIM}# search by keyword${RESET}
+  ${DIM}$${RESET} skills init my-skill
+  ${DIM}$${RESET} skills check
+  ${DIM}$${RESET} skills update
+
+Discover more skills at ${TEXT}https://skills.sh/${RESET}
+`);
+}
+function showRemoveHelp() {
+	console.log(`
+${BOLD}Usage:${RESET} skills remove [skills...] [options]
+
+${BOLD}Description:${RESET}
+  Remove installed skills from agents. If no skill names are provided,
+  an interactive selection menu will be shown.
+
+${BOLD}Arguments:${RESET}
+  skills            Optional skill names to remove (space-separated)
+
+${BOLD}Options:${RESET}
+  -g, --global       Remove from global scope (~/) instead of project scope
+  -a, --agent        Remove from specific agents (use '*' for all agents)
+  -s, --skill        Specify skills to remove (use '*' for all skills)
+  -y, --yes          Skip confirmation prompts
+  --all              Shorthand for --skill '*' --agent '*' -y
+
+${BOLD}Examples:${RESET}
+  ${DIM}$${RESET} skills remove                           ${DIM}# interactive selection${RESET}
+  ${DIM}$${RESET} skills remove my-skill                   ${DIM}# remove specific skill${RESET}
+  ${DIM}$${RESET} skills remove skill1 skill2 -y           ${DIM}# remove multiple skills${RESET}
+  ${DIM}$${RESET} skills remove --global my-skill          ${DIM}# remove from global scope${RESET}
+  ${DIM}$${RESET} skills rm --agent claude-code my-skill   ${DIM}# remove from specific agent${RESET}
+  ${DIM}$${RESET} skills remove --all                      ${DIM}# remove all skills${RESET}
+  ${DIM}$${RESET} skills remove --skill '*' -a cursor      ${DIM}# remove all skills from cursor${RESET}
+
+Discover more skills at ${TEXT}https://skills.sh/${RESET}
+`);
+}
+function runInit(args) {
+	const cwd = process.cwd();
+	const skillName = args[0] || basename(cwd);
+	const hasName = args[0] !== void 0;
+	const skillDir = hasName ? join(cwd, skillName) : cwd;
+	const skillFile = join(skillDir, "SKILL.md");
+	const displayPath = hasName ? `${skillName}/SKILL.md` : "SKILL.md";
+	if (existsSync(skillFile)) {
+		console.log(`${TEXT}Skill already exists at ${DIM}${displayPath}${RESET}`);
+		return;
+	}
+	if (hasName) mkdirSync(skillDir, { recursive: true });
+	writeFileSync(skillFile, `---
+name: ${skillName}
+description: A brief description of what this skill does
+---
+
+# ${skillName}
+
+Instructions for the agent to follow when this skill is activated.
+
+## When to use
+
+Describe when this skill should be used.
+
+## Instructions
+
+1. First step
+2. Second step
+3. Additional steps as needed
+`);
+	console.log(`${TEXT}Initialized skill: ${DIM}${skillName}${RESET}`);
+	console.log();
+	console.log(`${DIM}Created:${RESET}`);
+	console.log(`  ${displayPath}`);
+	console.log();
+	console.log(`${DIM}Next steps:${RESET}`);
+	console.log(`  1. Edit ${TEXT}${displayPath}${RESET} to define your skill instructions`);
+	console.log(`  2. Update the ${TEXT}name${RESET} and ${TEXT}description${RESET} in the frontmatter`);
+	console.log();
+	console.log(`${DIM}Publishing:${RESET}`);
+	console.log(`  ${DIM}GitHub:${RESET}  Push to a repo, then ${TEXT}npx skills add <owner>/<repo>${RESET}`);
+	console.log(`  ${DIM}URL:${RESET}     Host the file, then ${TEXT}npx skills add https://example.com/${displayPath}${RESET}`);
+	console.log();
+	console.log(`Browse existing skills for inspiration at ${TEXT}https://skills.sh/${RESET}`);
+	console.log();
+}
+const AGENTS_DIR = ".agents";
+const LOCK_FILE = ".skill-lock.json";
+const CHECK_UPDATES_API_URL = "https://add-skill.vercel.sh/check-updates";
+const CURRENT_LOCK_VERSION = 3;
+function getSkillLockPath() {
+	return join(homedir(), AGENTS_DIR, LOCK_FILE);
+}
+function readSkillLock() {
+	const lockPath = getSkillLockPath();
+	try {
+		const content = readFileSync(lockPath, "utf-8");
+		const parsed = JSON.parse(content);
+		if (typeof parsed.version !== "number" || !parsed.skills) return {
+			version: CURRENT_LOCK_VERSION,
+			skills: {}
+		};
+		if (parsed.version < CURRENT_LOCK_VERSION) return {
+			version: CURRENT_LOCK_VERSION,
+			skills: {}
+		};
+		return parsed;
+	} catch {
+		return {
+			version: CURRENT_LOCK_VERSION,
+			skills: {}
+		};
+	}
+}
+async function runCheck(args = []) {
+	console.log(`${TEXT}Checking for skill updates...${RESET}`);
+	console.log();
+	const lock = readSkillLock();
+	const skillNames = Object.keys(lock.skills);
+	if (skillNames.length === 0) {
+		console.log(`${DIM}No skills tracked in lock file.${RESET}`);
+		console.log(`${DIM}Install skills with${RESET} ${TEXT}npx skills add <package>${RESET}`);
+		return;
+	}
+	const checkRequest = { skills: [] };
+	for (const skillName of skillNames) {
+		const entry = lock.skills[skillName];
+		if (!entry) continue;
+		if (!entry.skillFolderHash) continue;
+		checkRequest.skills.push({
+			name: skillName,
+			source: entry.source,
+			path: entry.skillPath,
+			skillFolderHash: entry.skillFolderHash
+		});
+	}
+	if (checkRequest.skills.length === 0) {
+		console.log(`${DIM}No skills to check.${RESET}`);
+		return;
+	}
+	console.log(`${DIM}Checking ${checkRequest.skills.length} skill(s) for updates...${RESET}`);
+	try {
+		const response = await fetch(CHECK_UPDATES_API_URL, {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify(checkRequest)
+		});
+		if (!response.ok) throw new Error(`API error: ${response.status} ${response.statusText}`);
+		const data = await response.json();
+		console.log();
+		if (data.updates.length === 0) console.log(`${TEXT}✓ All skills are up to date${RESET}`);
+		else {
+			console.log(`${TEXT}${data.updates.length} update(s) available:${RESET}`);
+			console.log();
+			for (const update of data.updates) {
+				console.log(`  ${TEXT}↑${RESET} ${update.name}`);
+				console.log(`    ${DIM}source: ${update.source}${RESET}`);
+			}
+			console.log();
+			console.log(`${DIM}Run${RESET} ${TEXT}npx skills update${RESET} ${DIM}to update all skills${RESET}`);
+		}
+		if (data.errors && data.errors.length > 0) {
+			console.log();
+			console.log(`${DIM}Could not check ${data.errors.length} skill(s) (may need reinstall)${RESET}`);
+		}
+		track({
+			event: "check",
+			skillCount: String(checkRequest.skills.length),
+			updatesAvailable: String(data.updates.length)
+		});
+	} catch (error) {
+		console.log(`${TEXT}Error checking for updates:${RESET} ${error instanceof Error ? error.message : "Unknown error"}`);
+		process.exit(1);
+	}
+	console.log();
+}
+async function runUpdate() {
+	console.log(`${TEXT}Checking for skill updates...${RESET}`);
+	console.log();
+	const lock = readSkillLock();
+	const skillNames = Object.keys(lock.skills);
+	if (skillNames.length === 0) {
+		console.log(`${DIM}No skills tracked in lock file.${RESET}`);
+		console.log(`${DIM}Install skills with${RESET} ${TEXT}npx skills add <package>${RESET}`);
+		return;
+	}
+	const checkRequest = { skills: [] };
+	for (const skillName of skillNames) {
+		const entry = lock.skills[skillName];
+		if (!entry) continue;
+		if (!entry.skillFolderHash) continue;
+		checkRequest.skills.push({
+			name: skillName,
+			source: entry.source,
+			path: entry.skillPath,
+			skillFolderHash: entry.skillFolderHash
+		});
+	}
+	if (checkRequest.skills.length === 0) {
+		console.log(`${DIM}No skills to check.${RESET}`);
+		return;
+	}
+	let updates = [];
+	try {
+		const response = await fetch(CHECK_UPDATES_API_URL, {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify(checkRequest)
+		});
+		if (!response.ok) throw new Error(`API error: ${response.status} ${response.statusText}`);
+		updates = (await response.json()).updates;
+	} catch (error) {
+		console.log(`${TEXT}Error checking for updates:${RESET} ${error instanceof Error ? error.message : "Unknown error"}`);
+		process.exit(1);
+	}
+	if (updates.length === 0) {
+		console.log(`${TEXT}✓ All skills are up to date${RESET}`);
+		console.log();
+		return;
+	}
+	console.log(`${TEXT}Found ${updates.length} update(s)${RESET}`);
+	console.log();
+	let successCount = 0;
+	let failCount = 0;
+	for (const update of updates) {
+		const entry = lock.skills[update.name];
+		if (!entry) continue;
+		console.log(`${TEXT}Updating ${update.name}...${RESET}`);
+		if (spawnSync("npx", [
+			"-y",
+			"skills",
+			entry.sourceUrl,
+			"--skill",
+			update.name,
+			"-g",
+			"-y"
+		], { stdio: [
+			"inherit",
+			"pipe",
+			"pipe"
+		] }).status === 0) {
+			successCount++;
+			console.log(`  ${TEXT}✓${RESET} Updated ${update.name}`);
+		} else {
+			failCount++;
+			console.log(`  ${DIM}✗ Failed to update ${update.name}${RESET}`);
+		}
+	}
+	console.log();
+	if (successCount > 0) console.log(`${TEXT}✓ Updated ${successCount} skill(s)${RESET}`);
+	if (failCount > 0) console.log(`${DIM}Failed to update ${failCount} skill(s)${RESET}`);
+	track({
+		event: "update",
+		skillCount: String(updates.length),
+		successCount: String(successCount),
+		failCount: String(failCount)
+	});
+	console.log();
+}
+async function main() {
+	const args = process.argv.slice(2);
+	if (args.length === 0) {
+		showBanner();
+		return;
+	}
+	const command = args[0];
+	const restArgs = args.slice(1);
+	switch (command) {
+		case "find":
+		case "search":
+		case "f":
+		case "s":
+			showLogo();
+			console.log();
+			await runFind(restArgs);
+			break;
+		case "init":
+			showLogo();
+			console.log();
+			runInit(restArgs);
+			break;
+		case "i":
+		case "install":
+		case "a":
+		case "add": {
+			showLogo();
+			const { source, options } = parseAddOptions(restArgs);
+			await runAdd(source, options);
+			break;
+		}
+		case "remove":
+		case "rm":
+		case "r":
+			if (restArgs.includes("--help") || restArgs.includes("-h")) {
+				showRemoveHelp();
+				break;
+			}
+			const { skills, options: removeOptions } = parseRemoveOptions(restArgs);
+			await removeCommand(skills, removeOptions);
+			break;
+		case "list":
+		case "ls":
+			await runList(restArgs);
+			break;
+		case "check":
+			runCheck(restArgs);
+			break;
+		case "update":
+		case "upgrade":
+			runUpdate();
+			break;
+		case "--help":
+		case "-h":
+			showHelp();
+			break;
+		case "--version":
+		case "-v":
+			console.log(VERSION);
+			break;
+		default:
+			console.log(`Unknown command: ${command}`);
+			console.log(`Run ${BOLD}skills --help${RESET} for usage.`);
+	}
+}
+main();
+export {};