skilld 1.7.0 → 1.7.1

package/dist/_chunks/install.mjs

@@ -1,101 +1,539 @@
-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"
+import { a as getModelLabel, r as createToolProgress, s as optimizeDocs } from "./agent.mjs";
+import { c as getRepoCacheDir, s as getPackageDbPath, t as getCacheDir } from "./version.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, c as isReadmeOnlyCache, d as linkPkgNamed, h as readCachedDocs, i as getPkgKeyFiles, m as listReferenceFiles, o as inferDocsTypeFromCache, r as ensureCacheDir, s as isCached, v as writeToCache } from "./cache.mjs";
+import { r as createIndex, t as SearchDepsUnavailableError } from "./retriv.mjs";
+import { n as getSharedSkillsDir } from "./shared.mjs";
+import { A as filterFrameworkDocs, E as fetchGitDocs, I as fetchLlmsTxt, P as downloadLlmsDocs, Q as fetchGitHubRaw, R as normalizeLlmsLinks, _ as resolveEntryFiles, d as resolvePackageDocs, j as isShallowGitDocs, k as fetchReadmeContent, m as fetchGitSkills, rt as parseGitHubUrl } from "./sources.mjs";
+import { a as targets } from "./detect.mjs";
+import { _ as timedSpinner, n as writeGeneratedSkillMd, o as linkSkillToAgents, r as writeSkillMd } from "./skill.mjs";
+import { a as readConfig, t as defaultFeatures } from "./config.mjs";
+import { _ as promptForAgent, b as resolveAgent, x as sharedArgs } from "./cli-helpers.mjs";
+import { a as readLock, c as writeLock, n as parsePackageNames, r as parsePackages, s as syncLockfilesToDirs, t as mergeLocks } from "./lockfile.mjs";
+import { r as toStoragePackageName } from "./prefix.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";
+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
 			});
 			continue;
 		}
-		const baseDir = isGlobal ? agent.globalSkillsDir : join(cwd, agent.skillsDir);
-		if (!explicit && !existsSync(baseDir)) {
-			skipped.push({
-				agent: agentType,
-				reason: "skills dir not found"
-			});
+		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, toStoragePackageName(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 = toStoragePackageName(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 (isGlobal && (writtenDirs.has(baseDir) || agent.additionalSkillsDirs.some((d) => writtenDirs.has(d)))) {
-			skipped.push({
-				agent: agentType,
-				reason: "already covered by another agent dir"
-			});
+		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 });
+				writeSkillMd(skillDir, 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) && !isReadmeOnlyCache(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}`);
 			continue;
 		}
-		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);
+		spin.start(`Downloading ${name}@${version}`);
+		const resolved = await resolvePackageDocs(pkgName, { version });
+		if (!resolved) {
+			spin.stop(`Could not resolve: ${name}`);
+			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 (!isReadmeOnlyCache(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);
+		}
 	}
-	return {
-		installed,
-		skipped,
-		paths
-	};
+	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");
 }
-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;
-			}
+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;
 		}
-		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);
 	}
+	return false;
+}
+function unsanitizeName(sanitized, source) {
+	if (source?.includes("ungh://")) {
+		const match = source.match(/ungh:\/\/([^/]+)\/(.+)/);
+		if (match) return `@${match[1]}/${match[2]}`;
+	}
+	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;
+}
+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");
+}
+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;
+}
+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;
+		}
+		const docsType = inferDocsTypeFromCache(globalCachePath);
+		const dirName = skillDir.split("/").pop();
+		const allPackages = parsePackageNames(packages);
+		writeGeneratedSkillMd(skillDir, {
+			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
+		});
+	} 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;
+		}
+		p.intro(`\x1B[1m\x1B[35mskilld\x1B[0m install`);
+		return installCommand({
+			global: args.global,
+			agent
+		});
+	}
+});
+function regenerateBaseSkillMd(skillDir, pkgName, version, cwd, allSkillNames, source, packages) {
+	if (existsSync(join(skillDir, "SKILL.md"))) 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 globalCachePath = getCacheDir(pkgName, version);
+	const docsType = inferDocsTypeFromCache(globalCachePath, source);
+	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 = parsePackageNames(packages);
+	mkdirSync(skillDir, { recursive: true });
+	writeGeneratedSkillMd(skillDir, {
+		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
+	});
+	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 {}
+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;
 	}
+	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;
 }
-export { unlinkSkillFromAgents as a, sanitizeName as i, installSkillForAgents as n, linkSkillToAgents as r, computeSkillDirName as t };
+export { installCommandDef };
 
 //# sourceMappingURL=install.mjs.map