skilld 1.7.3 → 2.0.0

package/dist/_chunks/install.mjs

@@ -1,26 +1,24 @@
-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 { i as getModelLabel } from "./agent.mjs";
+import { h as timedSpinner, i as linkSkillToAgents, n as writeSkillMd } from "./prompts.mjs";
+import { f as getSharedSkillsDir, m as skillInternalDir } from "./paths.mjs";
+import { n as sanitizeMarkdown } from "./sanitize.mjs";
+import { a as resolvePkgDir, i as linkShippedSkill, n as getShippedSkills, s as getCacheDir } from "./prepare.mjs";
+import { i as readPackageJsonSafe } from "./package-json.mjs";
+import { d as readConfig, o as defaultFeatures, r as ensureCacheDir, t as createReferenceCache } from "./cache.mjs";
+import { n as promptForAgent, r as resolveAgent } from "./agent-prompt.mjs";
+import { t as sharedArgs } from "./args.mjs";
+import { _ as fetchGitSkills, a as resolvePackageDocs, l as toStoragePackageName } from "./semver.mjs";
+import { a as parsePackageNames, c as readLock, d as writeLock, i as mergeLocks, o as parsePackages, u as syncLockfilesToDirs } from "./lockfile.mjs";
+import { a as prepareSkillReferences, c as selectLlmConfig, f as writeBaseSkill, p as writePromptFiles, r as fetchAndCacheResources, t as buildSkillContext, u as enhanceSkillWithLLM } from "./pipeline.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 { copyFileSync, existsSync, lstatSync, mkdirSync, readdirSync, writeFileSync } from "node:fs";
+import { styleText } from "node:util";
 import * as p from "@clack/prompts";
 import { defineCommand } from "citty";
+import { dirname, join } from "pathe";
+import { homedir } from "node:os";
+const STATIC_REGEX_1 = /ungh:\/\/([^/]+)\/(.+)/;
 async function installCommand(opts) {
 	const cwd = process.cwd();
 	const agent = targets[opts.agent];
@@ -46,7 +44,7 @@ async function installCommand(opts) {
 			continue;
 		}
 		const skillDir = join(skillsDir, name);
-		const referencesPath = join(skillDir, ".skilld");
+		const referencesPath = skillInternalDir(skillDir);
 		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,
@@ -59,11 +57,11 @@ async function installCommand(opts) {
 	}
 	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));
+		const identityName = info.packageName || unsanitizeName(name, info.source);
+		const pkgName = toStoragePackageName(identityName);
 		if (info.source === "shipped") {
 			const match = getShippedSkills(pkgName, cwd, version).find((s) => s.skillName === name);
 			if (match) {
@@ -97,260 +95,75 @@ async function installCommand(opts) {
 			continue;
 		}
 		const skillDir = join(skillsDir, name);
-		const referencesPath = join(skillDir, ".skilld");
-		const globalCachePath = getCacheDir(pkgName, version);
+		const cache = createReferenceCache(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;
-		}
-		spin.start(`Downloading ${name}@${version}`);
-		const resolved = await resolvePackageDocs(pkgName, { version });
+		const wasCacheHit = cache.has();
+		spin.start(wasCacheHit ? `Linking ${name}` : `Downloading ${name}@${version}`);
+		mkdirSync(skillDir, { recursive: true });
+		const resolved = wasCacheHit ? synthesizeResolved(identityName, version, info, cwd) : 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"
-					}
-				});
-			}
+		const resources = await fetchAndCacheResources({
+			packageName: pkgName,
+			resolved,
+			version,
+			useCache: wasCacheHit,
+			features,
+			onProgress: (msg) => spin.message(msg)
+		});
+		for (const w of resources.warnings) p.log.warn(`${name}: ${w}`);
+		if (!cache.has()) {
+			spin.stop(`No docs found for ${name}`);
+			continue;
 		}
-		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({
+		const ctx = buildSkillContext({
+			packageName: identityName,
+			cachePackageName: pkgName,
+			version,
+			skillDir,
+			skillDirName: name,
+			resources,
+			prepared: await prepareSkillReferences({
+				packageName: pkgName,
+				version,
+				cwd,
+				skillDir,
+				resources,
+				features,
+				baseDir: skillsDir,
+				extraPackages: parsePackages(info.packages),
+				onIndexProgress: (msg) => spin.message(msg)
+			}),
+			resolved,
+			packages: parsePackageNames(info.packages),
+			features
+		});
+		if (!copyFromExistingAgent(skillDir, name, allSkillsDirs)) {
+			if (!existsSync(join(skillDir, "SKILL.md"))) {
+				writeBaseSkill(ctx);
+				regenerated.push({
 					name,
-					pkgName,
-					version,
-					skillDir,
-					packages: info.packages
+					ctx
 				});
 			}
-			spin.stop(`Downloaded and linked ${name}`);
-		} else spin.stop(`No docs found for ${name}`);
+		}
+		spin.stop(wasCacheHit ? `Linked ${name}` : `Downloaded and linked ${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) {
+		if (llmConfig?.promptOnly) for (const { ctx } of regenerated) writePromptFiles(ctx, {
+			sections: llmConfig.sections,
+			customPrompt: llmConfig.customPrompt
+		});
+		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 { ctx } of regenerated) await enhanceSkillWithLLM(ctx, {
+				model: llmConfig.model,
+				sections: llmConfig.sections,
+				customPrompt: llmConfig.customPrompt
+			});
 		}
 	}
 	for (const [name, info] of Object.entries(lock.skills)) writeLock(skillsDir, name, info);
@@ -375,7 +188,7 @@ function copyFromExistingAgent(skillDir, name, allSkillsDirs) {
 }
 function unsanitizeName(sanitized, source) {
 	if (source?.includes("ungh://")) {
-		const match = source.match(/ungh:\/\/([^/]+)\/(.+)/);
+		const match = source.match(STATIC_REGEX_1);
 		if (match) return `@${match[1]}/${match[2]}`;
 	}
 	if (sanitized.startsWith("antfu-")) return `@antfu/${sanitized.slice(6)}`;
@@ -385,78 +198,15 @@ function unsanitizeName(sanitized, source) {
 	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,
+function synthesizeResolved(identityName, version, info, cwd) {
+	const repoUrl = info.repo?.includes("/") ? `https://github.com/${info.repo}` : void 0;
+	const pkgPath = resolvePkgDir(toStoragePackageName(identityName), cwd, version);
+	return {
+		name: identityName,
 		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");
+		repoUrl,
+		description: pkgPath ? readPackageJsonSafe(join(pkgPath, "package.json"))?.parsed.description : void 0
+	};
 }
 const installCommandDef = defineCommand({
 	meta: {
@@ -475,48 +225,13 @@ const installCommandDef = defineCommand({
 			if (!picked || picked === "none") return;
 			agent = picked;
 		}
-		p.intro(`\x1B[1m\x1B[35mskilld\x1B[0m install`);
+		p.intro(`${styleText(["bold", "magenta"], "skilld")} 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 hasStaleReferences(referencesPath, pkgName, version, features) {
 	for (const entry of readdirSync(referencesPath)) {
 		const entryPath = join(referencesPath, entry);