skilld 1.5.5 → 1.7.0

package/dist/_chunks/install.mjs

@@ -1,566 +1,101 @@
-import { a as getRepoCacheDir, i as getPackageDbPath, o as getCacheDir } from "./config.mjs";
-import { i as readPackageJsonSafe } from "./package-json.mjs";
-import { n as linkShippedSkill, r as resolvePkgDir, t as getShippedSkills } from "./prepare.mjs";
-import { n as sanitizeMarkdown } from "./sanitize.mjs";
-import { a as hasShippedDocs, f as listReferenceFiles, g as writeToCache, i as getPkgKeyFiles, l as linkPkgNamed, o as isCached, p as readCachedDocs, r as ensureCacheDir } from "./cache.mjs";
-import "./yaml.mjs";
-import "./markdown.mjs";
-import { r as createIndex, t as SearchDepsUnavailableError } from "./retriv.mjs";
-import { n as getSharedSkillsDir } from "./shared.mjs";
-import { C as downloadLlmsDocs, D as normalizeLlmsLinks, M as resolveEntryFiles, T as fetchLlmsTxt, Z as fetchGitHubRaw, b as isShallowGitDocs, d as resolvePackageDocs, h as fetchGitDocs, k as fetchGitSkills, tt as parseGitHubUrl, v as fetchReadmeContent, y as filterFrameworkDocs } from "./sources.mjs";
-import { a as targets } from "./detect.mjs";
-import { i as linkSkillToAgents, t as generateSkillMd } from "./prompts.mjs";
-import { a as getModelLabel, r as createToolProgress, s as optimizeDocs } from "./agent.mjs";
-import "./libs/@sinclair/typebox.mjs";
-import { O as readConfig, _ as promptForAgent, b as resolveAgent, w as defaultFeatures, x as sharedArgs } from "./cli-helpers.mjs";
-import { i as readLock, n as parsePackages, o as syncLockfilesToDirs, s as writeLock, t as mergeLocks } from "./lockfile.mjs";
-import "./skills.mjs";
-import { l as timedSpinner } from "./formatting.mjs";
-import "./wizard.mjs";
-import { S as writePromptFiles, a as classifyCachedDoc, b as selectLlmConfig, g as indexResources } from "./sync-shared2.mjs";
-import { n as shutdownWorker } from "./pool2.mjs";
-import "./sync.mjs";
-import { homedir } from "node:os";
-import { dirname, join } from "pathe";
-import { copyFileSync, existsSync, lstatSync, mkdirSync, readdirSync, symlinkSync, unlinkSync, writeFileSync } from "node:fs";
-import * as p from "@clack/prompts";
-import { defineCommand } from "citty";
-//#region src/commands/install.ts
-async function installCommand(opts) {
-	const cwd = process.cwd();
-	const agent = targets[opts.agent];
-	const shared = !opts.global && getSharedSkillsDir(cwd);
-	const skillsDir = opts.global ? join(homedir(), ".skilld", "skills") : shared || join(cwd, agent.skillsDir);
-	const allSkillsDirs = shared ? [shared] : Object.values(targets).map((t) => opts.global ? t.globalSkillsDir : join(cwd, t.skillsDir));
-	const allLocks = allSkillsDirs.map((dir) => readLock(dir)).filter((l) => !!l && Object.keys(l.skills).length > 0);
-	if (allLocks.length === 0) {
-		p.log.warn("No skilld-lock.yaml found. Run `skilld` to sync skills first.");
-		return;
-	}
-	const lock = mergeLocks(allLocks);
-	const skills = Object.entries(lock.skills);
-	const toRestore = [];
-	const features = readConfig().features ?? defaultFeatures;
-	for (const [name, info] of skills) {
-		if (!info.version) continue;
-		if (info.source === "shipped") {
-			if (!existsSync(join(skillsDir, name))) toRestore.push({
-				name,
-				info
+import { n as sanitizeMarkdown, t as repairMarkdown } from "./sanitize.mjs";
+import { a as targets, t as detectInstalledAgents } from "./detect.mjs";
+import { join, relative } from "pathe";
+import { existsSync, lstatSync, mkdirSync, symlinkSync, unlinkSync, writeFileSync } from "node:fs";
+function sanitizeName(name) {
+	return name.toLowerCase().replace(/[^a-z0-9._]+/g, "-").replace(/^[.\-]+|[.\-]+$/g, "").slice(0, 255) || "unnamed-skill";
+}
+function computeSkillDirName(packageName) {
+	return `${sanitizeName(packageName)}-skilld`;
+}
+function installSkillForAgents(skillName, skillContent, options = {}) {
+	const isGlobal = options.global ?? false;
+	const cwd = options.cwd || process.cwd();
+	const sanitized = sanitizeName(skillName);
+	const explicit = !!options.agents;
+	const targetAgents = options.agents || detectInstalledAgents();
+	const installed = [];
+	const skipped = [];
+	const paths = [];
+	const writtenDirs = /* @__PURE__ */ new Set();
+	for (const agentType of targetAgents) {
+		const agent = targets[agentType];
+		if (isGlobal && !agent.globalSkillsDir) {
+			skipped.push({
+				agent: agentType,
+				reason: "no global support"
 			});
 			continue;
 		}
-		const skillDir = join(skillsDir, name);
-		const referencesPath = join(skillDir, ".skilld");
-		const skillMdPath = join(skillDir, "SKILL.md");
-		if (!existsSync(skillDir) || !existsSync(skillMdPath) || !existsSync(referencesPath) || hasStaleReferences(referencesPath, info.packageName || name, info.version, features)) toRestore.push({
-			name,
-			info
-		});
-	}
-	if (toRestore.length === 0) {
-		p.log.success("All up to date");
-		return;
-	}
-	p.log.info(`Restoring ${toRestore.length} references`);
-	ensureCacheDir();
-	const allSkillNames = skills.map(([, info]) => info.packageName || "").filter(Boolean);
-	const regenerated = [];
-	for (const { name, info } of toRestore) {
-		const version = info.version;
-		const pkgName = info.packageName || unsanitizeName(name, info.source);
-		if (info.source === "shipped") {
-			const match = getShippedSkills(pkgName, cwd, version).find((s) => s.skillName === name);
-			if (match) {
-				linkShippedSkill(skillsDir, name, match.skillDir);
-				p.log.success(`Linked ${name}`);
-			} else p.log.warn(`${name}: package ${pkgName} no longer ships this skill`);
-			continue;
-		}
-		if (info.source === "github" || info.source === "gitlab" || info.source === "local") {
-			const match = (await fetchGitSkills({
-				type: info.source,
-				...info.repo?.includes("/") ? {
-					owner: info.repo.split("/")[0],
-					repo: info.repo.split("/")[1]
-				} : {},
-				skillPath: info.path,
-				ref: info.ref,
-				...info.source === "local" ? { localPath: info.repo } : {}
-			})).skills.find((s) => s.name === name);
-			if (match) {
-				const skillDir = join(skillsDir, name);
-				mkdirSync(skillDir, { recursive: true });
-				writeFileSync(join(skillDir, "SKILL.md"), sanitizeMarkdown(match.content));
-				for (const f of match.files) {
-					const filePath = join(skillDir, f.path);
-					mkdirSync(dirname(filePath), { recursive: true });
-					writeFileSync(filePath, f.content);
-				}
-				p.log.success(`Restored ${name} from ${info.repo}`);
-			} else p.log.warn(`${name}: skill not found in ${info.repo}`);
-			continue;
-		}
-		const skillDir = join(skillsDir, name);
-		const referencesPath = join(skillDir, ".skilld");
-		const globalCachePath = getCacheDir(pkgName, version);
-		const spin = timedSpinner();
-		if (isCached(pkgName, version)) {
-			spin.start(`Linking ${name}`);
-			mkdirSync(skillDir, { recursive: true });
-			mkdirSync(referencesPath, { recursive: true });
-			linkPkgSymlink(referencesPath, pkgName, cwd, version);
-			for (const pkg of parsePackages(info.packages)) linkPkgNamed(skillDir, pkg.name, cwd, pkg.version);
-			if (!pkgHasShippedDocs(pkgName, cwd, version) && !isReadmeOnly(globalCachePath)) {
-				const docsLink = join(referencesPath, "docs");
-				const cachedDocs = join(globalCachePath, "docs");
-				if (existsSync(docsLink)) unlinkSync(docsLink);
-				if (existsSync(cachedDocs)) symlinkSync(cachedDocs, docsLink, "junction");
-			}
-			const repoGh = info.repo ? parseGitHubUrl(`https://github.com/${info.repo}`) : null;
-			const repoCachePath = repoGh ? getRepoCacheDir(repoGh.owner, repoGh.repo) : null;
-			if (features.issues) {
-				const issuesLink = join(referencesPath, "issues");
-				const repoIssues = repoCachePath ? join(repoCachePath, "issues") : null;
-				const cachedIssues = repoIssues && existsSync(repoIssues) ? repoIssues : join(globalCachePath, "issues");
-				if (existsSync(issuesLink)) unlinkSync(issuesLink);
-				if (existsSync(cachedIssues)) symlinkSync(cachedIssues, issuesLink, "junction");
-			}
-			if (features.discussions) {
-				const discussionsLink = join(referencesPath, "discussions");
-				const repoDiscussions = repoCachePath ? join(repoCachePath, "discussions") : null;
-				const cachedDiscussions = repoDiscussions && existsSync(repoDiscussions) ? repoDiscussions : join(globalCachePath, "discussions");
-				if (existsSync(discussionsLink)) unlinkSync(discussionsLink);
-				if (existsSync(cachedDiscussions)) symlinkSync(cachedDiscussions, discussionsLink, "junction");
-			}
-			if (features.releases) {
-				const releasesLink = join(referencesPath, "releases");
-				const repoReleases = repoCachePath ? join(repoCachePath, "releases") : null;
-				const cachedReleases = repoReleases && existsSync(repoReleases) ? repoReleases : join(globalCachePath, "releases");
-				if (existsSync(releasesLink)) unlinkSync(releasesLink);
-				if (existsSync(cachedReleases)) symlinkSync(cachedReleases, releasesLink, "junction");
-			}
-			const sectionsLink = join(referencesPath, "sections");
-			const cachedSections = join(globalCachePath, "sections");
-			if (existsSync(sectionsLink)) unlinkSync(sectionsLink);
-			if (existsSync(cachedSections)) symlinkSync(cachedSections, sectionsLink, "junction");
-			if (features.search && !existsSync(getPackageDbPath(pkgName, version))) {
-				spin.message(`Indexing ${name}`);
-				await indexResources({
-					packageName: pkgName,
-					version,
-					cwd,
-					docsToIndex: readCachedDocs(pkgName, version).map((d) => ({
-						id: d.path,
-						content: d.content,
-						metadata: {
-							package: pkgName,
-							source: d.path,
-							type: classifyCachedDoc(d.path).type
-						}
-					})),
-					features,
-					onProgress: (msg) => spin.message(msg)
-				});
-			}
-			if (!copyFromExistingAgent(skillDir, name, allSkillsDirs)) {
-				if (regenerateBaseSkillMd(skillDir, pkgName, version, cwd, allSkillNames, info.source, info.packages)) regenerated.push({
-					name,
-					pkgName,
-					version,
-					skillDir,
-					packages: info.packages
-				});
-			}
-			spin.stop(`Linked ${name}`);
+		const baseDir = isGlobal ? agent.globalSkillsDir : join(cwd, agent.skillsDir);
+		if (!explicit && !existsSync(baseDir)) {
+			skipped.push({
+				agent: agentType,
+				reason: "skills dir not found"
+			});
 			continue;
 		}
-		spin.start(`Downloading ${name}@${version}`);
-		const resolved = await resolvePackageDocs(pkgName, { version });
-		if (!resolved) {
-			spin.stop(`Could not resolve: ${name}`);
+		if (isGlobal && (writtenDirs.has(baseDir) || agent.additionalSkillsDirs.some((d) => writtenDirs.has(d)))) {
+			skipped.push({
+				agent: agentType,
+				reason: "already covered by another agent dir"
+			});
 			continue;
 		}
-		const cachedDocs = [];
-		const docsToIndex = [];
-		const isFrameworkDoc = (path) => filterFrameworkDocs([path], pkgName).length > 0;
-		if (resolved.gitDocsUrl && resolved.repoUrl) {
-			const gh = parseGitHubUrl(resolved.repoUrl);
-			if (gh) {
-				const gitDocs = await fetchGitDocs(gh.owner, gh.repo, version, pkgName);
-				if (gitDocs?.files.length) {
-					const BATCH_SIZE = 20;
-					for (let i = 0; i < gitDocs.files.length; i += BATCH_SIZE) {
-						const batch = gitDocs.files.slice(i, i + BATCH_SIZE);
-						const results = await Promise.all(batch.map(async (file) => {
-							const content = await fetchGitHubRaw(`${gitDocs.baseUrl}/${file}`);
-							if (!content) return null;
-							return {
-								file,
-								content
-							};
-						}));
-						for (const r of results) if (r) {
-							const stripped = gitDocs.docsPrefix ? r.file.replace(gitDocs.docsPrefix, "") : r.file;
-							const cachePath = stripped.startsWith("docs/") ? stripped : `docs/${stripped}`;
-							cachedDocs.push({
-								path: cachePath,
-								content: r.content
-							});
-							docsToIndex.push({
-								id: cachePath,
-								content: r.content,
-								metadata: {
-									package: pkgName,
-									source: cachePath,
-									type: "doc"
-								}
-							});
-						}
-					}
-					if (isShallowGitDocs(cachedDocs.length) && resolved.llmsUrl) {
-						cachedDocs.length = 0;
-						docsToIndex.length = 0;
-					} else if (cachedDocs.length > 0 && resolved.llmsUrl) {
-						const llmsContent = await fetchLlmsTxt(resolved.llmsUrl);
-						if (llmsContent) {
-							const baseUrl = resolved.docsUrl || new URL(resolved.llmsUrl).origin;
-							cachedDocs.push({
-								path: "llms.txt",
-								content: normalizeLlmsLinks(llmsContent.raw)
-							});
-							if (llmsContent.links.length > 0) {
-								const docs = await downloadLlmsDocs(llmsContent, baseUrl);
-								for (const doc of docs) {
-									if (!isFrameworkDoc(doc.url)) continue;
-									const localPath = doc.url.startsWith("/") ? doc.url.slice(1) : doc.url;
-									cachedDocs.push({
-										path: join("llms-docs", ...localPath.split("/")),
-										content: doc.content
-									});
-								}
-							}
-						}
-					}
-				}
-			}
-		}
-		if (resolved.llmsUrl && cachedDocs.length === 0) {
-			const llmsContent = await fetchLlmsTxt(resolved.llmsUrl);
-			if (llmsContent) {
-				cachedDocs.push({
-					path: "llms.txt",
-					content: normalizeLlmsLinks(llmsContent.raw)
-				});
-				if (llmsContent.links.length > 0) {
-					const docs = await downloadLlmsDocs(llmsContent, resolved.docsUrl || new URL(resolved.llmsUrl).origin);
-					for (const doc of docs) {
-						if (!isFrameworkDoc(doc.url)) continue;
-						const cachePath = join("docs", ...(doc.url.startsWith("/") ? doc.url.slice(1) : doc.url).split("/"));
-						cachedDocs.push({
-							path: cachePath,
-							content: doc.content
-						});
-						docsToIndex.push({
-							id: doc.url,
-							content: doc.content,
-							metadata: {
-								package: pkgName,
-								source: cachePath,
-								type: "doc"
-							}
-						});
-					}
-				}
-			}
-		}
-		if (resolved.readmeUrl && cachedDocs.length === 0) {
-			const content = await fetchReadmeContent(resolved.readmeUrl);
-			if (content) {
-				cachedDocs.push({
-					path: "docs/README.md",
-					content
-				});
-				docsToIndex.push({
-					id: "README.md",
-					content,
-					metadata: {
-						package: pkgName,
-						source: "docs/README.md",
-						type: "doc"
-					}
-				});
-			}
-		}
-		if (cachedDocs.length > 0) {
-			writeToCache(pkgName, version, cachedDocs);
-			mkdirSync(referencesPath, { recursive: true });
-			linkPkgSymlink(referencesPath, pkgName, cwd, version);
-			for (const pkg of parsePackages(info.packages)) linkPkgNamed(skillDir, pkg.name, cwd, pkg.version);
-			if (!isReadmeOnly(globalCachePath)) {
-				const docsLink = join(referencesPath, "docs");
-				const cachedDocsDir = join(globalCachePath, "docs");
-				if (existsSync(docsLink)) unlinkSync(docsLink);
-				if (existsSync(cachedDocsDir)) symlinkSync(cachedDocsDir, docsLink, "junction");
-			}
-			if (features.search) try {
-				if (docsToIndex.length > 0) await createIndex(docsToIndex, { dbPath: getPackageDbPath(pkgName, version) });
-				const pkgDir = resolvePkgDir(pkgName, cwd, version);
-				const entryFiles = pkgDir ? await resolveEntryFiles(pkgDir) : [];
-				if (entryFiles.length > 0) await createIndex(entryFiles.map((e) => ({
-					id: e.path,
-					content: e.content,
-					metadata: {
-						package: pkgName,
-						source: `pkg/${e.path}`,
-						type: e.type
-					}
-				})), { dbPath: getPackageDbPath(pkgName, version) });
-			} catch (err) {
-				if (!(err instanceof SearchDepsUnavailableError)) throw err;
-			}
-			if (!copyFromExistingAgent(skillDir, name, allSkillsDirs)) {
-				if (regenerateBaseSkillMd(skillDir, pkgName, version, cwd, allSkillNames, info.source, info.packages)) regenerated.push({
-					name,
-					pkgName,
-					version,
-					skillDir,
-					packages: info.packages
-				});
-			}
-			spin.stop(`Downloaded and linked ${name}`);
-		} else spin.stop(`No docs found for ${name}`);
-	}
-	if (regenerated.length > 0 && !readConfig().skipLlm) {
-		const llmConfig = await selectLlmConfig(void 0, `Enhance SKILL.md for ${regenerated.map((r) => r.name).join(", ")}`);
-		if (llmConfig?.promptOnly) {
-			const features = readConfig().features ?? defaultFeatures;
-			for (const { pkgName, version, skillDir } of regenerated) {
-				const globalCachePath = getCacheDir(pkgName, version);
-				writePromptFiles({
-					packageName: pkgName,
-					skillDir,
-					version,
-					hasIssues: existsSync(join(globalCachePath, "issues")),
-					hasDiscussions: existsSync(join(globalCachePath, "discussions")),
-					hasReleases: existsSync(join(globalCachePath, "releases")),
-					hasChangelog: false,
-					docsType: "docs",
-					hasShippedDocs: false,
-					pkgFiles: getPkgKeyFiles(pkgName, process.cwd(), version),
-					sections: llmConfig.sections,
-					customPrompt: llmConfig.customPrompt,
-					features
-				});
-			}
-		} else if (llmConfig) {
-			p.log.step(getModelLabel(llmConfig.model));
-			for (const { pkgName, version, skillDir, packages: pkgPackages } of regenerated) await enhanceRegenerated(pkgName, version, skillDir, llmConfig.model, llmConfig.sections, llmConfig.customPrompt, pkgPackages);
-		}
-	}
-	for (const [name, info] of Object.entries(lock.skills)) writeLock(skillsDir, name, info);
-	if (shared) for (const [name] of skills) linkSkillToAgents(name, shared, cwd, opts.agent);
-	else syncLockfilesToDirs(lock, allSkillsDirs.filter((d) => d !== skillsDir));
-	await shutdownWorker();
-	p.outro("Install complete");
-}
-/** Copy SKILL.md from another agent's skill dir if one exists */
-function copyFromExistingAgent(skillDir, name, allSkillsDirs) {
-	const targetMd = join(skillDir, "SKILL.md");
-	if (existsSync(targetMd)) return false;
-	for (const dir of allSkillsDirs) {
-		if (dir === skillDir) continue;
-		const candidateMd = join(dir, name, "SKILL.md");
-		if (existsSync(candidateMd) && !lstatSync(candidateMd).isSymbolicLink()) {
-			mkdirSync(skillDir, { recursive: true });
-			copyFileSync(candidateMd, targetMd);
-			return true;
-		}
-	}
-	return false;
-}
-/** Try to recover original package name from sanitized name + source */
-function unsanitizeName(sanitized, source) {
-	if (source?.includes("ungh://")) {
-		const match = source.match(/ungh:\/\/([^/]+)\/(.+)/);
-		if (match) return `@${match[1]}/${match[2]}`;
+		const skillDir = join(baseDir, sanitized);
+		const skilldDir = join(skillDir, ".skilld");
+		mkdirSync(skilldDir, { recursive: true });
+		writeFileSync(join(skilldDir, "_SKILL.md"), sanitizeMarkdown(repairMarkdown(skillContent)));
+		if (options.files) for (const [filename, content] of Object.entries(options.files)) writeFileSync(join(skillDir, filename), filename.endsWith(".md") ? sanitizeMarkdown(repairMarkdown(content)) : content);
+		installed.push(agentType);
+		paths.push(skillDir);
+		writtenDirs.add(baseDir);
 	}
-	if (sanitized.startsWith("antfu-")) return `@antfu/${sanitized.slice(6)}`;
-	if (sanitized.startsWith("clack-")) return `@clack/${sanitized.slice(6)}`;
-	if (sanitized.startsWith("nuxt-")) return `@nuxt/${sanitized.slice(5)}`;
-	if (sanitized.startsWith("vue-")) return `@vue/${sanitized.slice(4)}`;
-	if (sanitized.startsWith("vueuse-")) return `@vueuse/${sanitized.slice(7)}`;
-	return sanitized;
-}
-/** Create pkg symlink inside references dir (links to entire package or cached dist) */
-function linkPkgSymlink(referencesDir, name, cwd, version) {
-	const pkgPath = resolvePkgDir(name, cwd, version);
-	if (!pkgPath) return;
-	const pkgLink = join(referencesDir, "pkg");
-	if (existsSync(pkgLink)) unlinkSync(pkgLink);
-	symlinkSync(pkgPath, pkgLink, "junction");
-}
-/** Check if cache only has docs/README.md (pkg/ already has this) */
-function isReadmeOnly(cacheDir) {
-	const docsDir = join(cacheDir, "docs");
-	if (!existsSync(docsDir)) return false;
-	const files = readdirSync(docsDir);
-	return files.length === 1 && files[0] === "README.md";
+	return {
+		installed,
+		skipped,
+		paths
+	};
 }
-/** Check if package ships its own docs folder */
-function pkgHasShippedDocs(name, cwd, version) {
-	const pkgPath = resolvePkgDir(name, cwd, version);
-	if (!pkgPath) return false;
-	for (const candidate of [
-		"docs",
-		"documentation",
-		"doc"
-	]) if (existsSync(join(pkgPath, candidate))) return true;
-	return false;
-}
-/** Run LLM enhancement on a regenerated SKILL.md */
-async function enhanceRegenerated(pkgName, version, skillDir, model, sections, customPrompt, packages) {
-	const llmLog = p.taskLog({
-		title: `Agent exploring ${pkgName}`,
-		limit: 3
-	});
-	const docFiles = listReferenceFiles(skillDir);
-	const globalCachePath = getCacheDir(pkgName, version);
-	const hasIssues = existsSync(join(globalCachePath, "issues"));
-	const hasDiscussions = existsSync(join(globalCachePath, "discussions"));
-	const hasGithub = hasIssues || hasDiscussions;
-	const hasReleases = existsSync(join(globalCachePath, "releases"));
-	const features = readConfig().features ?? defaultFeatures;
-	const { optimized, wasOptimized } = await optimizeDocs({
-		packageName: pkgName,
-		skillDir,
-		model,
-		version,
-		hasGithub,
-		hasReleases,
-		docFiles,
-		sections,
-		customPrompt,
-		features,
-		pkgFiles: getPkgKeyFiles(pkgName, process.cwd(), version),
-		onProgress: createToolProgress(llmLog)
-	});
-	if (wasOptimized) {
-		llmLog.success("Generated best practices");
-		const cwd = process.cwd();
-		const pkgPath = resolvePkgDir(pkgName, cwd, version);
-		let description;
-		if (pkgPath) {
-			const pkgJsonResult = readPackageJsonSafe(join(pkgPath, "package.json"));
-			if (pkgJsonResult) description = pkgJsonResult.parsed.description;
-		}
-		let docsType = "docs";
-		if (existsSync(join(globalCachePath, "docs", "llms.txt"))) docsType = "llms.txt";
-		else if (isReadmeOnly(globalCachePath)) docsType = "readme";
-		const dirName = skillDir.split("/").pop();
-		const allPackages = parsePackages(packages).map((p) => ({ name: p.name }));
-		const skillMd = generateSkillMd({
-			name: pkgName,
-			version,
-			description,
-			body: optimized,
-			relatedSkills: [],
-			hasIssues,
-			hasDiscussions,
-			hasReleases,
-			docsType,
-			hasShippedDocs: hasShippedDocs(pkgName, cwd, version),
-			pkgFiles: getPkgKeyFiles(pkgName, cwd, version),
-			dirName,
-			packages: allPackages.length > 1 ? allPackages : void 0,
-			features
-		});
-		writeFileSync(join(skillDir, "SKILL.md"), skillMd);
-	} else llmLog.message("Enhancement skipped");
-}
-const installCommandDef = defineCommand({
-	meta: {
-		name: "install",
-		description: "Restore references from lockfile"
-	},
-	args: {
-		global: sharedArgs.global,
-		agent: sharedArgs.agent
-	},
-	async run({ args }) {
-		let agent = resolveAgent(args.agent);
-		if (!agent || agent === "none") {
-			if (agent === "none") return;
-			const picked = await promptForAgent();
-			if (!picked || picked === "none") return;
-			agent = picked;
+function linkSkillToAgents(skillName, sharedDir, cwd, agentType) {
+	const targetAgents = agentType ? [[agentType, targets[agentType]]] : Object.entries(targets);
+	const linkedDirs = /* @__PURE__ */ new Set();
+	for (const [type, agent] of targetAgents) {
+		const agentSkillsDir = join(cwd, agent.skillsDir);
+		if (agentType === type) mkdirSync(agentSkillsDir, { recursive: true });
+		else {
+			if (!existsSync(agentSkillsDir)) continue;
+			if (agent.additionalSkillsDirs.map((d) => join(cwd, d)).some((d) => linkedDirs.has(d))) {
+				const staleTarget = join(agentSkillsDir, skillName);
+				try {
+					if (lstatSync(staleTarget).isSymbolicLink() && !existsSync(staleTarget)) unlinkSync(staleTarget);
+				} catch {}
+				continue;
+			}
 		}
-		p.intro(`\x1B[1m\x1B[35mskilld\x1B[0m install`);
-		return installCommand({
-			global: args.global,
-			agent
-		});
-	}
-});
-/** Regenerate base SKILL.md from local metadata if missing */
-function regenerateBaseSkillMd(skillDir, pkgName, version, cwd, allSkillNames, source, packages) {
-	const skillMdPath = join(skillDir, "SKILL.md");
-	if (existsSync(skillMdPath)) return false;
-	const pkgPath = resolvePkgDir(pkgName, cwd, version);
-	let description;
-	if (pkgPath) {
-		const pkgResult = readPackageJsonSafe(join(pkgPath, "package.json"));
-		if (pkgResult) description = pkgResult.parsed.description;
+		const target = join(agentSkillsDir, skillName);
+		let isSymlink = false;
+		let targetExists = false;
+		try {
+			const stat = lstatSync(target);
+			targetExists = true;
+			isSymlink = stat.isSymbolicLink();
+		} catch {}
+		if (targetExists && !isSymlink) continue;
+		if (isSymlink) unlinkSync(target);
+		symlinkSync(relative(agentSkillsDir, join(sharedDir, skillName)), target);
+		linkedDirs.add(agentSkillsDir);
 	}
-	const globalCachePath = getCacheDir(pkgName, version);
-	let docsType = "docs";
-	if (source?.includes("llms.txt") || existsSync(join(globalCachePath, "docs", "llms.txt"))) docsType = "llms.txt";
-	else if (isReadmeOnly(globalCachePath)) docsType = "readme";
-	const feat = readConfig().features ?? defaultFeatures;
-	const hasIssues = feat.issues && existsSync(join(globalCachePath, "issues"));
-	const hasDiscussions = feat.discussions && existsSync(join(globalCachePath, "discussions"));
-	const hasReleases = feat.releases && existsSync(join(globalCachePath, "releases"));
-	const relatedSkills = allSkillNames.filter((n) => n !== pkgName);
-	const dirName = skillDir.split("/").pop();
-	const allPackages = parsePackages(packages).map((p) => ({ name: p.name }));
-	const content = generateSkillMd({
-		name: pkgName,
-		version,
-		description,
-		relatedSkills,
-		hasIssues,
-		hasDiscussions,
-		hasReleases,
-		docsType,
-		hasShippedDocs: hasShippedDocs(pkgName, cwd, version),
-		pkgFiles: getPkgKeyFiles(pkgName, cwd, version),
-		dirName,
-		packages: allPackages.length > 1 ? allPackages : void 0,
-		features: readConfig().features ?? defaultFeatures
-	});
-	mkdirSync(skillDir, { recursive: true });
-	writeFileSync(skillMdPath, content);
-	return true;
 }
-/** Check if .skilld/ has broken symlinks or is missing expected references from global cache */
-function hasStaleReferences(referencesPath, pkgName, version, features) {
-	for (const entry of readdirSync(referencesPath)) {
-		const entryPath = join(referencesPath, entry);
-		if (lstatSync(entryPath).isSymbolicLink() && !existsSync(entryPath)) return true;
+function unlinkSkillFromAgents(skillName, cwd, agentType) {
+	const targetAgents = agentType ? [[agentType, targets[agentType]]] : Object.entries(targets);
+	for (const [, agent] of targetAgents) {
+		const target = join(cwd, agent.skillsDir, skillName);
+		try {
+			if (lstatSync(target).isSymbolicLink()) unlinkSync(target);
+		} catch {}
 	}
-	if (!existsSync(join(referencesPath, "pkg"))) return true;
-	const globalCachePath = getCacheDir(pkgName, version);
-	const expected = [
-		["docs", existsSync(join(globalCachePath, "docs"))],
-		["issues", features.issues && existsSync(join(globalCachePath, "issues"))],
-		["discussions", features.discussions && existsSync(join(globalCachePath, "discussions"))],
-		["releases", features.releases && existsSync(join(globalCachePath, "releases"))],
-		["sections", existsSync(join(globalCachePath, "sections"))]
-	];
-	for (const [name, shouldExist] of expected) if (shouldExist && !existsSync(join(referencesPath, name))) return true;
-	return false;
 }
-//#endregion
-export { installCommandDef };
+export { unlinkSkillFromAgents as a, sanitizeName as i, installSkillForAgents as n, linkSkillToAgents as r, computeSkillDirName as t };
 
 //# sourceMappingURL=install.mjs.map