skilld 0.1.2 → 0.2.1

package/dist/_chunks/sync-parallel.mjs

@@ -1,26 +1,16 @@
-import { a as getCacheDir, i as getPackageDbPath, s as getVersionKey, t as CACHE_DIR } from "./config.mjs";
-import { _ as writeToCache, a as getShippedSkills, c as linkGithub, d as linkReleases, f as linkShippedSkill, g as resolvePkgDir, h as readCachedDocs, i as getPkgKeyFiles, l as linkPkg, m as listReferenceFiles, n as clearCache, o as hasShippedDocs, r as ensureCacheDir, s as isCached, u as linkReferences } from "./storage.mjs";
+import { s as getVersionKey } from "./config.mjs";
+import { _ as listReferenceFiles, b as resolvePkgDir, d as linkPkgNamed, i as getPkgKeyFiles, o as hasShippedDocs, r as ensureCacheDir, s as isCached } from "./storage.mjs";
 import "../cache/index.mjs";
-import { createIndex } from "../retriv/index.mjs";
-import { A as resolveEntryFiles, E as parseGitHubUrl, S as fetchReadmeContent, _ as normalizeLlmsLinks, a as fetchPkgDist, c as readLocalDependencies, d as resolvePackageDocs, f as resolvePackageDocsWithAttempts, h as fetchLlmsTxt, p as downloadLlmsDocs, r as fetchNpmPackage, t as fetchReleaseNotes, u as resolveLocalPackageDocs, v as parseMarkdownLinks, y as fetchGitDocs } from "./releases.mjs";
+import { h as searchNpmPackages, l as readLocalDependencies, m as resolvePackageDocsWithAttempts, o as fetchPkgDist } from "./releases.mjs";
 import "../sources/index.mjs";
-import { c as sanitizeName, i as generateSkillMd, p as agents, r as optimizeDocs } from "./llm.mjs";
+import { a as generateSkillMd, i as optimizeDocs, m as computeSkillDirName, n as getModelLabel, x as agents } from "./llm.mjs";
 import "../agent/index.mjs";
-import { a as defaultFeatures, i as writeLock, n as selectModel, o as readConfig, r as selectSkillSections, s as registerProject, t as ensureGitignore } from "../cli.mjs";
-import { join } from "node:path";
-import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, writeFileSync } from "node:fs";
-import * as p from "@clack/prompts";
+import { _ as defaultFeatures, a as fetchAndCacheResources, c as handleShippedSkills, d as resolveBaseDir, f as resolveLocalDep, g as formatDuration, h as writeLock, i as detectChangelog, l as indexResources, m as readLock, n as selectLlmConfig, o as findRelatedSkills, p as parsePackages, r as RESOLVE_STEP_LABELS, s as forceClearCache, t as ensureGitignore, u as linkAllReferences, v as readConfig, y as registerProject } from "../cli.mjs";
+import { join } from "pathe";
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
 import pLimit from "p-limit";
+import * as p from "@clack/prompts";
 import logUpdate from "log-update";
-const RESOLVE_STEP_LABELS = {
-	"npm": "npm registry",
-	"github-docs": "GitHub docs",
-	"github-meta": "GitHub meta",
-	"github-search": "GitHub search",
-	"readme": "README",
-	"llms.txt": "llms.txt",
-	"local": "node_modules"
-};
 const STATUS_ICONS = {
 	pending: "○",
 	resolving: "◐",
@@ -62,8 +52,9 @@ async function syncPackagesParallel(config) {
 			const dim = "\x1B[90m";
 			const name = s.name.padEnd(maxNameLen);
 			const version = s.version ? `${dim}${s.version}${reset} ` : "";
+			const elapsed = (s.status === "done" || s.status === "error") && s.startedAt && s.completedAt ? ` ${dim}(${formatDuration(s.completedAt - s.startedAt)})${reset}` : "";
 			const preview = s.streamPreview ? ` ${dim}${s.streamPreview}${reset}` : "";
-			return `  ${color}${icon}${reset} ${name} ${version}${s.message}${preview}`;
+			return `  ${color}${icon}${reset} ${name} ${version}${s.message}${elapsed}${preview}`;
 		});
 		const doneCount = [...states.values()].filter((s) => s.status === "done").length;
 		const errorCount = [...states.values()].filter((s) => s.status === "error").length;
@@ -71,6 +62,8 @@ async function syncPackagesParallel(config) {
 	}
 	function update(pkg, status, message, version) {
 		const state = states.get(pkg);
+		if (!state.startedAt && status !== "pending") state.startedAt = performance.now();
+		if ((status === "done" || status === "error") && !state.completedAt) state.completedAt = performance.now();
 		state.status = status;
 		state.message = message;
 		state.streamPreview = void 0;
@@ -80,13 +73,18 @@ async function syncPackagesParallel(config) {
 	ensureCacheDir();
 	render();
 	const limit = pLimit(concurrency);
+	const skillData = /* @__PURE__ */ new Map();
 	const baseResults = await Promise.allSettled(packages.map((pkg) => limit(() => syncBaseSkill(pkg, config, cwd, update))));
 	logUpdate.done();
 	const successfulPkgs = [];
+	const shippedPkgs = [];
 	const errors = [];
 	for (let i = 0; i < baseResults.length; i++) {
 		const r = baseResults[i];
-		if (r.status === "fulfilled" && r.value !== "shipped") successfulPkgs.push(packages[i]);
+		if (r.status === "fulfilled" && r.value !== "shipped") {
+			successfulPkgs.push(packages[i]);
+			skillData.set(packages[i], r.value);
+		} else if (r.status === "fulfilled" && r.value === "shipped") shippedPkgs.push(packages[i]);
 		else if (r.status === "rejected") {
 			const err = r.reason;
 			const reason = err instanceof Error ? `${err.message}\n${err.stack}` : String(err);
@@ -96,35 +94,32 @@ async function syncPackagesParallel(config) {
 			});
 		}
 	}
-	p.log.success(`Created ${successfulPkgs.length} base skills`);
+	const skillMsg = `Created ${successfulPkgs.length} base skills${shippedPkgs.length > 1 ? ` (Skipping ${shippedPkgs.length})` : ""}`;
+	p.log.success(skillMsg);
 	if (errors.length > 0) for (const { pkg, reason } of errors) p.log.error(`  ${pkg}: ${reason}`);
 	const globalConfig = readConfig();
 	if (successfulPkgs.length > 0 && !globalConfig.skipLlm && !(config.yes && !config.model)) {
-		const { sections, customPrompt, cancelled } = config.model ? {
-			sections: ["best-practices", "api"],
-			customPrompt: void 0,
-			cancelled: false
-		} : await selectSkillSections();
-		if (!cancelled && sections.length > 0) {
-			const model = config.model ?? await selectModel(false);
-			if (model) {
-				for (const pkg of successfulPkgs) states.set(pkg, {
-					name: pkg,
-					status: "pending",
-					message: "Waiting..."
-				});
-				render();
-				const llmResults = await Promise.allSettled(successfulPkgs.map((pkg) => limit(() => enhanceWithLLM(pkg, {
-					...config,
-					model
-				}, cwd, update, sections, customPrompt))));
-				logUpdate.done();
-				const llmSucceeded = llmResults.filter((r) => r.status === "fulfilled").length;
-				p.log.success(`Enhanced ${llmSucceeded}/${successfulPkgs.length} skills with LLM`);
-			}
+		const llmConfig = await selectLlmConfig(config.model);
+		if (llmConfig) {
+			p.log.step(getModelLabel(llmConfig.model));
+			for (const pkg of successfulPkgs) states.set(pkg, {
+				name: pkg,
+				status: "pending",
+				message: "Waiting..."
+			});
+			render();
+			const llmResults = await Promise.allSettled(successfulPkgs.map((pkg) => limit(() => enhanceWithLLM(pkg, skillData.get(pkg), {
+				...config,
+				model: llmConfig.model
+			}, cwd, update, llmConfig.sections, llmConfig.customPrompt))));
+			logUpdate.done();
+			const llmSucceeded = llmResults.filter((r) => r.status === "fulfilled").length;
+			p.log.success(`Enhanced ${llmSucceeded}/${successfulPkgs.length} skills with LLM`);
 		}
 	}
 	await ensureGitignore(agent.skillsDir, cwd, config.global);
+	const { shutdownWorker } = await import("./pool.mjs");
+	await shutdownWorker();
 	p.outro(`Synced ${successfulPkgs.length}/${packages.length} packages`);
 }
 async function syncBaseSkill(packageName, config, cwd, update) {
@@ -136,25 +131,17 @@ async function syncBaseSkill(packageName, config, cwd, update) {
 	});
 	let resolved = resolvedPkg;
 	if (!resolved) {
-		const pkgPath = join(cwd, "package.json");
-		if (existsSync(pkgPath)) {
-			const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
-			const depVersion = {
-				...pkg.dependencies,
-				...pkg.devDependencies
-			}[packageName];
-			if (depVersion?.startsWith("link:")) {
-				update(packageName, "resolving", "Local package...");
-				const { resolve } = await import("node:path");
-				resolved = await resolveLocalPackageDocs(resolve(cwd, depVersion.slice(5)));
-			}
-		}
+		update(packageName, "resolving", "Local package...");
+		resolved = await resolveLocalDep(packageName, cwd);
 	}
 	if (!resolved) {
 		const npmAttempt = attempts.find((a) => a.source === "npm");
 		let reason;
-		if (npmAttempt?.status === "not-found") reason = npmAttempt.message || "Not on npm";
-		else reason = attempts.filter((a) => a.status !== "success").map((a) => a.message || a.source).join("; ") || "No docs found";
+		if (npmAttempt?.status === "not-found") {
+			const suggestions = await searchNpmPackages(packageName, 3);
+			const hint = suggestions.length > 0 ? ` (try: ${suggestions.map((s) => s.name).join(", ")})` : "";
+			reason = (npmAttempt.message || "Not on npm") + hint;
+		} else reason = attempts.filter((a) => a.status !== "success").map((a) => a.message || a.source).join("; ") || "No docs found";
 		update(packageName, "error", reason);
 		throw new Error(`Could not find docs for: ${packageName}`);
 	}
@@ -164,218 +151,54 @@ async function syncBaseSkill(packageName, config, cwd, update) {
 		update(packageName, "downloading", "Downloading dist...", versionKey);
 		await fetchPkgDist(packageName, version);
 	}
-	const shippedSkills = getShippedSkills(packageName, cwd, version);
-	if (shippedSkills.length > 0) {
-		const agent = agents[config.agent];
-		const baseDir = config.global ? join(CACHE_DIR, "skills") : join(cwd, agent.skillsDir);
-		mkdirSync(baseDir, { recursive: true });
-		for (const shipped of shippedSkills) {
-			linkShippedSkill(baseDir, shipped.skillName, shipped.skillDir);
-			writeLock(baseDir, shipped.skillName, {
-				packageName,
-				version,
-				source: "shipped",
-				syncedAt: (/* @__PURE__ */ new Date()).toISOString().split("T")[0],
-				generator: "skilld"
-			});
-		}
-		if (!config.global) registerProject(cwd);
-		update(packageName, "done", "Shipped", versionKey);
+	if (handleShippedSkills(packageName, version, cwd, config.agent, config.global)) {
+		update(packageName, "done", "Published SKILL.md", versionKey);
 		return "shipped";
 	}
-	if (config.force) {
-		clearCache(packageName, version);
-		const forcedDbPath = getPackageDbPath(packageName, version);
-		if (existsSync(forcedDbPath)) rmSync(forcedDbPath, {
-			recursive: true,
-			force: true
-		});
-	}
+	if (config.force) forceClearCache(packageName, version);
 	const useCache = isCached(packageName, version);
 	if (useCache) update(packageName, "downloading", "Using cache", versionKey);
 	else update(packageName, "downloading", config.force ? "Re-fetching docs..." : "Fetching docs...", versionKey);
-	const agent = agents[config.agent];
-	const baseDir = config.global ? join(CACHE_DIR, "skills") : join(cwd, agent.skillsDir);
-	const skillDir = join(baseDir, sanitizeName(packageName));
+	const baseDir = resolveBaseDir(cwd, config.agent, config.global);
+	const skillDirName = computeSkillDirName(packageName, resolved.repoUrl);
+	const skillDir = join(baseDir, skillDirName);
 	mkdirSync(skillDir, { recursive: true });
-	let docSource = resolved.readmeUrl || "readme";
-	let docsType = "readme";
-	const docsToIndex = [];
-	if (!useCache) {
-		const cachedDocs = [];
-		if (resolved.gitDocsUrl && resolved.repoUrl) {
-			const gh = parseGitHubUrl(resolved.repoUrl);
-			if (gh) {
-				update(packageName, "downloading", "Git docs...", versionKey);
-				const gitDocs = await fetchGitDocs(gh.owner, gh.repo, version, packageName);
-				if (gitDocs && gitDocs.files.length > 0) {
-					update(packageName, "downloading", `0/${gitDocs.files.length} docs @ ${gitDocs.ref}`, versionKey);
-					const BATCH_SIZE = 20;
-					const results = [];
-					let downloaded = 0;
-					for (let i = 0; i < gitDocs.files.length; i += BATCH_SIZE) {
-						const batch = gitDocs.files.slice(i, i + BATCH_SIZE);
-						const batchResults = await Promise.all(batch.map(async (file) => {
-							const url = `${gitDocs.baseUrl}/${file}`;
-							const res = await fetch(url, { headers: { "User-Agent": "skilld/1.0" } }).catch(() => null);
-							if (!res?.ok) return null;
-							const content = await res.text();
-							downloaded++;
-							update(packageName, "downloading", `${downloaded}/${gitDocs.files.length} docs @ ${gitDocs.ref}`, versionKey);
-							return {
-								file,
-								content
-							};
-						}));
-						results.push(...batchResults);
-					}
-					for (const r of results) if (r) {
-						const cachePath = gitDocs.docsPrefix ? r.file.replace(gitDocs.docsPrefix, "") : r.file;
-						cachedDocs.push({
-							path: cachePath,
-							content: r.content
-						});
-						docsToIndex.push({
-							id: cachePath,
-							content: r.content,
-							metadata: {
-								package: packageName,
-								source: cachePath,
-								type: "doc"
-							}
-						});
-					}
-					if (results.filter(Boolean).length > 0) {
-						docSource = `${resolved.repoUrl}/tree/${gitDocs.ref}/docs`;
-						docsType = "docs";
-					}
-				}
-			}
-		}
-		if (resolved.llmsUrl && cachedDocs.length === 0) {
-			update(packageName, "downloading", "Fetching llms.txt...", versionKey);
-			const llmsContent = await fetchLlmsTxt(resolved.llmsUrl);
-			if (llmsContent) {
-				docSource = resolved.llmsUrl;
-				docsType = "llms.txt";
-				cachedDocs.push({
-					path: "llms.txt",
-					content: normalizeLlmsLinks(llmsContent.raw)
-				});
-				if (llmsContent.links.length > 0) {
-					update(packageName, "downloading", `0/${llmsContent.links.length} linked docs...`, versionKey);
-					const docs = await downloadLlmsDocs(llmsContent, resolved.docsUrl || new URL(resolved.llmsUrl).origin);
-					for (const doc of docs) {
-						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: packageName,
-								source: cachePath,
-								type: "doc"
-							}
-						});
-					}
-				}
-			}
-		}
-		if (resolved.readmeUrl && cachedDocs.length === 0) {
-			update(packageName, "downloading", "Fetching README...", versionKey);
-			const content = await fetchReadmeContent(resolved.readmeUrl);
-			if (content) {
-				cachedDocs.push({
-					path: "docs/README.md",
-					content
-				});
-				docsToIndex.push({
-					id: "README.md",
-					content,
-					metadata: {
-						package: packageName,
-						source: "docs/README.md",
-						type: "doc"
-					}
-				});
-			}
-		}
-		if (cachedDocs.length > 0) writeToCache(packageName, version, cachedDocs);
-	} else {
-		const cacheDir = getCacheDir(packageName, version);
-		if (existsSync(join(cacheDir, "docs", "index.md")) || existsSync(join(cacheDir, "docs", "guide"))) docsType = "docs";
-		else if (existsSync(join(cacheDir, "llms.txt"))) docsType = "llms.txt";
-		if (!existsSync(getPackageDbPath(packageName, version))) {
-			const cached = readCachedDocs(packageName, version);
-			for (const doc of cached) docsToIndex.push({
-				id: doc.path,
-				content: doc.content,
-				metadata: {
-					package: packageName,
-					source: doc.path,
-					type: "doc"
-				}
-			});
-		}
-	}
 	const features = readConfig().features ?? defaultFeatures;
-	const releasesPath = join(getCacheDir(packageName, version), "releases");
-	if (features.releases && resolved.repoUrl && !existsSync(releasesPath)) {
-		const gh = parseGitHubUrl(resolved.repoUrl);
-		if (gh) {
-			update(packageName, "downloading", "Fetching releases...", versionKey);
-			const releaseDocs = await fetchReleaseNotes(gh.owner, gh.repo, version, resolved.gitRef, packageName);
-			if (releaseDocs.length > 0) {
-				writeToCache(packageName, version, releaseDocs);
-				for (const doc of releaseDocs) docsToIndex.push({
-					id: doc.path,
-					content: doc.content,
-					metadata: {
-						package: packageName,
-						source: doc.path,
-						type: "release"
-					}
-				});
-			}
-		}
-	}
+	const resources = await fetchAndCacheResources({
+		packageName,
+		resolved,
+		version,
+		useCache,
+		features,
+		onProgress: (msg) => update(packageName, "downloading", msg, versionKey)
+	});
 	update(packageName, "downloading", "Linking references...", versionKey);
-	try {
-		linkPkg(skillDir, packageName, cwd, version);
-		if (!hasShippedDocs(packageName, cwd, version) && docsType !== "readme") linkReferences(skillDir, packageName, version);
-		linkGithub(skillDir, packageName, version);
-		linkReleases(skillDir, packageName, version);
-	} catch {}
-	update(packageName, "embedding", "Scanning exports...", versionKey);
-	const pkgDir = resolvePkgDir(packageName, cwd, version);
-	const entryFiles = features.search && pkgDir ? await resolveEntryFiles(pkgDir) : [];
-	if (entryFiles.length > 0) for (const e of entryFiles) docsToIndex.push({
-		id: e.path,
-		content: e.content,
-		metadata: {
-			package: packageName,
-			source: `pkg/${e.path}`,
-			type: e.type
-		}
+	linkAllReferences(skillDir, packageName, cwd, version, resources.docsType);
+	update(packageName, "embedding", "Indexing docs", versionKey);
+	await indexResources({
+		packageName,
+		version,
+		cwd,
+		docsToIndex: resources.docsToIndex,
+		features,
+		onProgress: (msg) => update(packageName, "embedding", msg, versionKey)
 	});
-	const dbPath = getPackageDbPath(packageName, version);
-	if (docsToIndex.length > 0) {
-		update(packageName, "embedding", `Indexing ${docsToIndex.length} documents...`, versionKey);
-		await createIndex(docsToIndex, {
-			dbPath,
-			onProgress: (current, total, doc) => {
-				update(packageName, "embedding", `Indexing ${doc?.type === "source" || doc?.type === "types" ? "code" : "doc"} ${doc?.id ? doc.id.split("/").pop() : ""}... ${current}/${total} ${Math.round(current / total * 100)}%`, versionKey);
-			}
-		});
-	}
-	const hasReleases = existsSync(releasesPath);
-	const hasChangelog = pkgDir ? ["CHANGELOG.md", "changelog.md"].find((f) => existsSync(join(pkgDir, f))) || false : false;
+	const hasChangelog = detectChangelog(resolvePkgDir(packageName, cwd, version));
 	const relatedSkills = await findRelatedSkills(packageName, baseDir);
 	const shippedDocs = hasShippedDocs(packageName, cwd, version);
 	const pkgFiles = getPkgKeyFiles(packageName, cwd, version);
+	const repoSlug = resolved.repoUrl?.match(/github\.com\/([^/]+\/[^/]+?)(?:\.git)?(?:[/#]|$)/)?.[1];
+	linkPkgNamed(skillDir, packageName, cwd, version);
+	writeLock(baseDir, skillDirName, {
+		packageName,
+		version,
+		repo: repoSlug,
+		source: resources.docSource,
+		syncedAt: (/* @__PURE__ */ new Date()).toISOString().split("T")[0],
+		generator: "skilld"
+	});
+	const updatedLock = readLock(baseDir)?.skills[skillDirName];
+	const allPackages = parsePackages(updatedLock?.packages).map((p) => ({ name: p.name }));
 	const skillMd = generateSkillMd({
 		name: packageName,
 		version,
@@ -384,106 +207,60 @@ async function syncBaseSkill(packageName, config, cwd, update) {
 		dependencies: resolved.dependencies,
 		distTags: resolved.distTags,
 		relatedSkills,
-		hasGithub: false,
-		hasReleases,
+		hasIssues: resources.hasIssues,
+		hasDiscussions: resources.hasDiscussions,
+		hasReleases: resources.hasReleases,
 		hasChangelog,
-		docsType,
+		docsType: resources.docsType,
 		hasShippedDocs: shippedDocs,
-		pkgFiles
+		pkgFiles,
+		dirName: skillDirName,
+		packages: allPackages.length > 1 ? allPackages : void 0,
+		repoUrl: resolved.repoUrl
 	});
 	writeFileSync(join(skillDir, "SKILL.md"), skillMd);
-	writeLock(baseDir, sanitizeName(packageName), {
-		packageName,
-		version,
-		source: docSource,
-		syncedAt: (/* @__PURE__ */ new Date()).toISOString().split("T")[0],
-		generator: "skilld"
-	});
 	if (!config.global) registerProject(cwd);
-	update(packageName, "done", "Skill ready", versionKey);
-	return "synced";
+	update(packageName, "done", "Base skill created", versionKey);
+	return {
+		resolved,
+		version,
+		skillDirName,
+		docsType: resources.docsType,
+		hasIssues: resources.hasIssues,
+		hasDiscussions: resources.hasDiscussions,
+		hasReleases: resources.hasReleases,
+		hasChangelog,
+		shippedDocs,
+		pkgFiles,
+		relatedSkills,
+		packages: allPackages.length > 1 ? allPackages : void 0
+	};
 }
-async function enhanceWithLLM(packageName, config, cwd, update, sections, customPrompt) {
-	const localVersion = (await readLocalDependencies(cwd).catch(() => [])).find((d) => d.name === packageName)?.version;
-	const resolved = await resolvePackageDocs(packageName, { version: localVersion });
-	if (!resolved) throw new Error("Package not found");
-	const version = localVersion || resolved.version || "latest";
-	const versionKey = getVersionKey(version);
-	const agent = agents[config.agent];
-	const baseDir = config.global ? join(CACHE_DIR, "skills") : join(cwd, agent.skillsDir);
-	const skillDir = join(baseDir, sanitizeName(packageName));
-	const cacheDir = getCacheDir(packageName, version);
-	let docsContent = null;
-	let llmsRaw = null;
-	let docsType = "readme";
-	if (existsSync(join(cacheDir, "docs", "index.md")) || existsSync(join(cacheDir, "docs", "guide"))) docsType = "docs";
-	else if (existsSync(join(cacheDir, "llms.txt"))) docsType = "llms.txt";
-	const guideDir = join(cacheDir, "docs", "guide");
-	const docsDir = join(cacheDir, "docs");
-	if (existsSync(guideDir) || existsSync(join(docsDir, "index.md"))) {
-		const sections = [];
-		const indexPath = join(docsDir, "index.md");
-		if (existsSync(indexPath)) sections.push(readFileSync(indexPath, "utf-8"));
-		if (existsSync(guideDir)) {
-			const priorityFiles = [
-				"index.md",
-				"features.md",
-				"migration.md",
-				"why.md"
-			];
-			const guideFiles = readdirSync(guideDir, { withFileTypes: true }).filter((f) => f.isFile() && f.name.endsWith(".md")).map((f) => f.name).sort((a, b) => {
-				const aIdx = priorityFiles.indexOf(a);
-				const bIdx = priorityFiles.indexOf(b);
-				if (aIdx >= 0 && bIdx >= 0) return aIdx - bIdx;
-				if (aIdx >= 0) return -1;
-				if (bIdx >= 0) return 1;
-				return a.localeCompare(b);
-			});
-			for (const file of guideFiles.slice(0, 10)) {
-				const content = readFileSync(join(guideDir, file), "utf-8");
-				sections.push(`# guide/${file}\n\n${content}`);
-			}
-		}
-		if (sections.length > 0) docsContent = sections.join("\n\n---\n\n");
-	}
-	if (!docsContent) {
-		if (existsSync(join(cacheDir, "llms.txt"))) llmsRaw = readFileSync(join(cacheDir, "llms.txt"), "utf-8");
-		if (llmsRaw) {
-			const bestPracticesPaths = parseMarkdownLinks(llmsRaw).map((l) => l.url).filter((lp) => lp.includes("/style-guide/") || lp.includes("/best-practices/") || lp.includes("/typescript/"));
-			const sections = [];
-			for (const mdPath of bestPracticesPaths) {
-				const filePath = join(cacheDir, "docs", mdPath.startsWith("/") ? mdPath.slice(1) : mdPath);
-				if (existsSync(filePath)) {
-					const content = readFileSync(filePath, "utf-8");
-					sections.push(`# ${mdPath}\n\n${content}`);
-				}
-			}
-			docsContent = sections.length > 0 ? sections.join("\n\n---\n\n") : llmsRaw;
-		}
-	}
-	if (!docsContent) {
-		const readmePath = join(cacheDir, "docs", "README.md");
-		if (existsSync(readmePath)) docsContent = readFileSync(readmePath, "utf-8");
-	}
-	const hasGithub = existsSync(join(cacheDir, "github"));
-	const hasReleases = existsSync(join(cacheDir, "releases"));
-	const hasChangelog = ["CHANGELOG.md", "changelog.md"].find((f) => existsSync(join(cwd, "node_modules", packageName, f))) || false;
+async function enhanceWithLLM(packageName, data, config, cwd, update, sections, customPrompt) {
+	const versionKey = getVersionKey(data.version);
+	const skillDir = join(resolveBaseDir(cwd, config.agent, config.global), data.skillDirName);
+	const hasGithub = data.hasIssues || data.hasDiscussions;
 	const docFiles = listReferenceFiles(skillDir);
 	update(packageName, "generating", config.model, versionKey);
 	const { optimized, wasOptimized, error } = await optimizeDocs({
 		packageName,
 		skillDir,
 		model: config.model,
-		version,
+		version: data.version,
 		hasGithub,
-		hasReleases,
-		hasChangelog,
+		hasReleases: data.hasReleases,
+		hasChangelog: data.hasChangelog,
 		docFiles,
+		docsType: data.docsType,
+		hasShippedDocs: data.shippedDocs,
 		noCache: config.force,
+		debug: config.debug,
 		sections,
 		customPrompt,
 		onProgress: (progress) => {
-			update(packageName, progress.type === "reasoning" ? "exploring" : "generating", progress.chunk.startsWith("[") ? progress.chunk : config.model, versionKey);
+			const status = progress.type === "reasoning" ? "exploring" : "generating";
+			const sectionPrefix = progress.section ? `[${progress.section}] ` : "";
+			update(packageName, status, progress.chunk.startsWith("[") ? `${sectionPrefix}${progress.chunk}` : `${sectionPrefix}${config.model}`, versionKey);
 		}
 	});
 	if (error) {
@@ -491,49 +268,28 @@ async function enhanceWithLLM(packageName, config, cwd, update, sections, custom
 		throw new Error(error);
 	}
 	if (wasOptimized) {
-		const relatedSkills = await findRelatedSkills(packageName, baseDir);
-		const shippedDocs = hasShippedDocs(packageName, cwd, version);
-		const pkgFiles = getPkgKeyFiles(packageName, cwd, version);
-		const body = cleanSkillMd(optimized);
 		const skillMd = generateSkillMd({
 			name: packageName,
-			version,
-			releasedAt: resolved.releasedAt,
-			dependencies: resolved.dependencies,
-			distTags: resolved.distTags,
-			body,
-			relatedSkills,
-			hasGithub,
-			hasReleases,
-			hasChangelog,
-			docsType,
-			hasShippedDocs: shippedDocs,
-			pkgFiles
+			version: data.version,
+			releasedAt: data.resolved.releasedAt,
+			dependencies: data.resolved.dependencies,
+			distTags: data.resolved.distTags,
+			body: optimized,
+			relatedSkills: data.relatedSkills,
+			hasIssues: data.hasIssues,
+			hasDiscussions: data.hasDiscussions,
+			hasReleases: data.hasReleases,
+			hasChangelog: data.hasChangelog,
+			docsType: data.docsType,
+			hasShippedDocs: data.shippedDocs,
+			pkgFiles: data.pkgFiles,
+			dirName: data.skillDirName,
+			packages: data.packages,
+			repoUrl: data.resolved.repoUrl
 		});
 		writeFileSync(join(skillDir, "SKILL.md"), skillMd);
 	}
-	update(packageName, "done", "Enhanced", versionKey);
-}
-async function findRelatedSkills(packageName, skillsDir) {
-	const related = [];
-	const npmInfo = await fetchNpmPackage(packageName);
-	if (!npmInfo?.dependencies) return related;
-	const deps = Object.keys(npmInfo.dependencies);
-	if (!existsSync(skillsDir)) return related;
-	const installedSkills = readdirSync(skillsDir);
-	for (const skill of installedSkills) if (deps.some((d) => sanitizeName(d) === skill)) related.push(skill);
-	return related.slice(0, 5);
-}
-function cleanSkillMd(content) {
-	let cleaned = content.replace(/^```markdown\n?/m, "").replace(/\n?```$/m, "").trim();
-	const fmMatch = cleaned.match(/^-{3,}\n/);
-	if (fmMatch) {
-		const afterOpen = fmMatch[0].length;
-		const closeMatch = cleaned.slice(afterOpen).match(/\n-{3,}/);
-		if (closeMatch) cleaned = cleaned.slice(afterOpen + closeMatch.index + closeMatch[0].length).trim();
-		else cleaned = cleaned.slice(afterOpen).trim();
-	}
-	return cleaned;
+	update(packageName, "done", "Skill optimized", versionKey);
 }
 export { syncPackagesParallel };