skilld 0.15.3 → 1.0.0

package/dist/_chunks/sync.mjs

@@ -0,0 +1,1937 @@
+import { a as getRepoCacheDir, c as getVersionKey, i as getPackageDbPath, o as getCacheDir, t as CACHE_DIR } from "./config.mjs";
+import { n as sanitizeMarkdown } from "./sanitize.mjs";
+import { _ as resolvePkgDir, a as getShippedSkills, b as writeToRepoCache, c as linkCachedDir, d as linkRepoCachedDir, f as linkShippedSkill, 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 linkPkgNamed, y as writeToCache } from "./cache.mjs";
+import { i as parseFrontmatter } from "./markdown.mjs";
+import { createIndex } from "../retriv/index.mjs";
+import { d as getPrereleaseChangelogRef, n as getSharedSkillsDir, o as getBlogPreset, t as SHARED_SKILLS_DIR } from "./shared.mjs";
+import { $ as fetchGitHubIssues, A as parseGitSkillInput, C as downloadLlmsDocs, D as normalizeLlmsLinks, F as formatDiscussionAsMarkdown, G as $fetch, H as generateReleaseIndex, I as generateDiscussionIndex, L as fetchCrawledDocs, M as resolveEntryFiles, N as generateDocsIndex, P as fetchGitHubDiscussions, R as toCrawlPattern, T as fetchLlmsTxt, U as isPrerelease, V as fetchReleaseNotes, X as parseGitHubUrl, Z as parsePackageSpec, b as isShallowGitDocs, et as formatIssueAsMarkdown, f as resolvePackageDocsWithAttempts, h as fetchGitDocs, i as fetchPkgDist, k as fetchGitSkills, n as fetchNpmPackage, nt as isGhAvailable, p as searchNpmPackages, s as readLocalDependencies, tt as generateIssueIndex, u as resolveLocalPackageDocs, v as fetchReadmeContent, x as resolveGitHubRepo, y as filterFrameworkDocs, z as fetchBlogReleases } from "./sources.mjs";
+import { _ as targets, a as sanitizeName, f as maxItems, i as linkSkillToAgents, n as computeSkillDirName, p as maxLines, t as generateSkillMd } from "./prompts.mjs";
+import { a as getModelName, i as getModelLabel, n as createToolProgress, o as optimizeDocs, r as getAvailableModels, t as detectImportedPackages } from "./agent.mjs";
+import { C as introLine, F as readConfig, I as registerProject, N as hasCompletedWizard, O as resolveAgent, R as updateConfig, T as promptForAgent, g as readLock, h as parsePackages, j as defaultFeatures, k as sharedArgs, l as timedSpinner, n as formatDuration, u as getProjectState, w as isInteractive, x as getInstalledGenerators, y as writeLock } from "./formatting.mjs";
+import { t as runWizard } from "../cli.mjs";
+import { n as shutdownWorker } from "./pool2.mjs";
+import { dirname, join, relative, resolve } from "pathe";
+import { appendFileSync, copyFileSync, existsSync, mkdirSync, readFileSync, readdirSync, rmSync, writeFileSync } from "node:fs";
+import { isCI } from "std-env";
+import pLimit from "p-limit";
+import * as p from "@clack/prompts";
+import { defineCommand } from "citty";
+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",
+	"crawl": "website crawl",
+	"local": "node_modules"
+};
+/** Classify a cached doc path into the right metadata type */
+function classifyCachedDoc(path) {
+	const issueMatch = path.match(/^issues\/issue-(\d+)\.md$/);
+	if (issueMatch) return {
+		type: "issue",
+		number: Number(issueMatch[1])
+	};
+	const discussionMatch = path.match(/^discussions\/discussion-(\d+)\.md$/);
+	if (discussionMatch) return {
+		type: "discussion",
+		number: Number(discussionMatch[1])
+	};
+	if (path.startsWith("releases/")) return { type: "release" };
+	return { type: "doc" };
+}
+async function findRelatedSkills(packageName, skillsDir) {
+	const related = [];
+	const npmInfo = await fetchNpmPackage(packageName);
+	if (!npmInfo?.dependencies) return related;
+	const deps = new Set(Object.keys(npmInfo.dependencies));
+	if (!existsSync(skillsDir)) return related;
+	const lock = readLock(skillsDir);
+	const pkgToDirName = /* @__PURE__ */ new Map();
+	if (lock) for (const [dirName, info] of Object.entries(lock.skills)) {
+		if (info.packageName) pkgToDirName.set(info.packageName, dirName);
+		for (const pkg of parsePackages(info.packages)) pkgToDirName.set(pkg.name, dirName);
+	}
+	const installedSkills = readdirSync(skillsDir);
+	const installedSet = new Set(installedSkills);
+	for (const dep of deps) {
+		const dirName = pkgToDirName.get(dep);
+		if (dirName && installedSet.has(dirName)) related.push(dirName);
+	}
+	return related.slice(0, 5);
+}
+/** Clear cache + db for --force flag */
+function forceClearCache(packageName, version, repoInfo) {
+	clearCache(packageName, version);
+	const forcedDbPath = getPackageDbPath(packageName, version);
+	if (existsSync(forcedDbPath)) rmSync(forcedDbPath, {
+		recursive: true,
+		force: true
+	});
+	if (repoInfo) {
+		const repoDir = getRepoCacheDir(repoInfo.owner, repoInfo.repo);
+		if (existsSync(repoDir)) rmSync(repoDir, {
+			recursive: true,
+			force: true
+		});
+	}
+}
+/** Link all reference symlinks (pkg, docs, issues, discussions, releases) */
+function linkAllReferences(skillDir, packageName, cwd, version, docsType, extraPackages, features, repoInfo) {
+	const f = features ?? readConfig().features ?? defaultFeatures;
+	try {
+		linkPkg(skillDir, packageName, cwd, version);
+		linkPkgNamed(skillDir, packageName, cwd, version);
+		if (!hasShippedDocs(packageName, cwd, version) && docsType !== "readme") linkCachedDir(skillDir, packageName, version, "docs");
+		if (f.issues) if (repoInfo) linkRepoCachedDir(skillDir, repoInfo.owner, repoInfo.repo, "issues");
+		else linkCachedDir(skillDir, packageName, version, "issues");
+		if (f.discussions) if (repoInfo) linkRepoCachedDir(skillDir, repoInfo.owner, repoInfo.repo, "discussions");
+		else linkCachedDir(skillDir, packageName, version, "discussions");
+		if (f.releases) if (repoInfo) linkRepoCachedDir(skillDir, repoInfo.owner, repoInfo.repo, "releases");
+		else linkCachedDir(skillDir, packageName, version, "releases");
+		linkCachedDir(skillDir, packageName, version, "sections");
+		if (extraPackages) {
+			for (const pkg of extraPackages) if (pkg.name !== packageName) linkPkgNamed(skillDir, pkg.name, cwd, pkg.version);
+		}
+	} catch {}
+}
+/** Detect docs type from cached directory contents */
+function detectDocsType(packageName, version, repoUrl, llmsUrl) {
+	const cacheDir = getCacheDir(packageName, version);
+	if (existsSync(join(cacheDir, "docs", "index.md")) || existsSync(join(cacheDir, "docs", "guide"))) return {
+		docsType: "docs",
+		docSource: repoUrl ? `${repoUrl}/tree/v${version}/docs` : "git"
+	};
+	if (existsSync(join(cacheDir, "llms.txt"))) return {
+		docsType: "llms.txt",
+		docSource: llmsUrl || "llms.txt"
+	};
+	if (existsSync(join(cacheDir, "docs", "README.md"))) return { docsType: "readme" };
+	return { docsType: "readme" };
+}
+/** Link shipped skills, write lock entries, register project. Returns result or null if no shipped skills. */
+function handleShippedSkills(packageName, version, cwd, agent, global) {
+	const shippedSkills = getShippedSkills(packageName, cwd, version);
+	if (shippedSkills.length === 0) return null;
+	const shared = getSharedSkillsDir(cwd);
+	const agentConfig = targets[agent];
+	const baseDir = global ? join(CACHE_DIR, "skills") : shared || join(cwd, agentConfig.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 (!global) registerProject(cwd);
+	return {
+		shipped: shippedSkills,
+		baseDir
+	};
+}
+/** Resolve the base skills directory for an agent */
+function resolveBaseDir(cwd, agent, global) {
+	if (global) return join(CACHE_DIR, "skills");
+	const shared = getSharedSkillsDir(cwd);
+	if (shared) return shared;
+	const agentConfig = targets[agent];
+	return join(cwd, agentConfig.skillsDir);
+}
+/** Try resolving a `link:` dependency to local package docs. Returns null if not a link dep or resolution fails. */
+async function resolveLocalDep(packageName, cwd) {
+	const pkgPath = join(cwd, "package.json");
+	if (!existsSync(pkgPath)) return null;
+	const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+	const depVersion = {
+		...pkg.dependencies,
+		...pkg.devDependencies
+	}[packageName];
+	if (!depVersion?.startsWith("link:")) return null;
+	return resolveLocalPackageDocs(resolve(cwd, depVersion.slice(5)));
+}
+/** Detect CHANGELOG.md in a package directory or cached releases */
+function detectChangelog(pkgDir, cacheDir) {
+	if (pkgDir) {
+		const found = ["CHANGELOG.md", "changelog.md"].find((f) => existsSync(join(pkgDir, f)));
+		if (found) return `pkg/${found}`;
+	}
+	if (cacheDir && existsSync(join(cacheDir, "releases", "CHANGELOG.md"))) return "releases/CHANGELOG.md";
+	return false;
+}
+/** Fetch and cache all resources for a package (docs cascade + issues + discussions + releases) */
+async function fetchAndCacheResources(opts) {
+	const { packageName, resolved, version, onProgress } = opts;
+	const features = opts.features ?? readConfig().features ?? defaultFeatures;
+	const cacheInvalidated = opts.useCache && resolved.crawlUrl && detectDocsType(packageName, version, resolved.repoUrl, resolved.llmsUrl).docsType === "readme";
+	const useCache = opts.useCache && !cacheInvalidated;
+	let docSource = resolved.readmeUrl || "readme";
+	let docsType = "readme";
+	const docsToIndex = [];
+	const warnings = [];
+	if (cacheInvalidated) warnings.push(`Retrying crawl for ${resolved.crawlUrl} (previous attempt only cached README)`);
+	if (!useCache) {
+		const cachedDocs = [];
+		const isFrameworkDoc = (path) => filterFrameworkDocs([path], packageName).length > 0;
+		if (resolved.gitDocsUrl && resolved.repoUrl) {
+			const gh = parseGitHubUrl(resolved.repoUrl);
+			if (gh) {
+				onProgress("Fetching git docs");
+				const gitDocs = await fetchGitDocs(gh.owner, gh.repo, version, packageName);
+				if (gitDocs?.fallback) warnings.push(`Docs fetched from ${gitDocs.ref} branch (no tag found for v${version})`);
+				if (gitDocs && gitDocs.files.length > 0) {
+					const BATCH_SIZE = 20;
+					const results = [];
+					for (let i = 0; i < gitDocs.files.length; i += BATCH_SIZE) {
+						const batch = gitDocs.files.slice(i, i + BATCH_SIZE);
+						onProgress(`Downloading docs ${Math.min(i + BATCH_SIZE, gitDocs.files.length)}/${gitDocs.files.length} from ${gitDocs.ref}`);
+						const batchResults = await Promise.all(batch.map(async (file) => {
+							const content = await $fetch(`${gitDocs.baseUrl}/${file}`, { responseType: "text" }).catch(() => null);
+							if (!content) return null;
+							return {
+								file,
+								content
+							};
+						}));
+						results.push(...batchResults);
+					}
+					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: packageName,
+								source: cachePath,
+								type: "doc"
+							}
+						});
+					}
+					const downloaded = results.filter(Boolean).length;
+					if (downloaded > 0) if (isShallowGitDocs(downloaded) && resolved.llmsUrl) {
+						onProgress(`Shallow git-docs (${downloaded} files), trying llms.txt`);
+						cachedDocs.length = 0;
+						docsToIndex.length = 0;
+					} else {
+						docSource = `${resolved.repoUrl}/tree/${gitDocs.ref}/docs`;
+						docsType = "docs";
+						writeToCache(packageName, version, cachedDocs);
+						if (resolved.llmsUrl) {
+							onProgress("Caching supplementary llms.txt");
+							const llmsContent = await fetchLlmsTxt(resolved.llmsUrl);
+							if (llmsContent) {
+								const baseUrl = resolved.docsUrl || new URL(resolved.llmsUrl).origin;
+								const supplementary = [{
+									path: "llms.txt",
+									content: normalizeLlmsLinks(llmsContent.raw, baseUrl)
+								}];
+								if (llmsContent.links.length > 0) {
+									onProgress(`Downloading ${llmsContent.links.length} supplementary docs`);
+									const docs = await downloadLlmsDocs(llmsContent, baseUrl, (url, done, total) => {
+										onProgress(`Downloading supplementary doc ${done + 1}/${total}`);
+									});
+									for (const doc of docs) {
+										if (!isFrameworkDoc(doc.url)) continue;
+										const localPath = doc.url.startsWith("/") ? doc.url.slice(1) : doc.url;
+										supplementary.push({
+											path: join("llms-docs", ...localPath.split("/")),
+											content: doc.content
+										});
+									}
+								}
+								writeToCache(packageName, version, supplementary);
+							}
+						}
+					}
+				}
+			}
+		}
+		if (resolved.crawlUrl && cachedDocs.length === 0) {
+			onProgress("Crawling website");
+			const crawledDocs = await fetchCrawledDocs(resolved.crawlUrl, onProgress).catch((err) => {
+				warnings.push(`Crawl failed for ${resolved.crawlUrl}: ${err?.message || err}`);
+				return [];
+			});
+			if (crawledDocs.length === 0 && resolved.crawlUrl) warnings.push(`Crawl returned 0 docs from ${resolved.crawlUrl}`);
+			if (crawledDocs.length > 0) {
+				for (const doc of crawledDocs) {
+					if (!isFrameworkDoc(doc.path)) continue;
+					cachedDocs.push(doc);
+					docsToIndex.push({
+						id: doc.path,
+						content: doc.content,
+						metadata: {
+							package: packageName,
+							source: doc.path,
+							type: "doc"
+						}
+					});
+				}
+				docSource = resolved.crawlUrl;
+				docsType = "docs";
+				writeToCache(packageName, version, cachedDocs);
+			}
+		}
+		if (resolved.llmsUrl && cachedDocs.length === 0) {
+			onProgress("Fetching llms.txt");
+			const llmsContent = await fetchLlmsTxt(resolved.llmsUrl);
+			if (llmsContent) {
+				docSource = resolved.llmsUrl;
+				docsType = "llms.txt";
+				const baseUrl = resolved.docsUrl || new URL(resolved.llmsUrl).origin;
+				cachedDocs.push({
+					path: "llms.txt",
+					content: normalizeLlmsLinks(llmsContent.raw, baseUrl)
+				});
+				if (llmsContent.links.length > 0) {
+					onProgress(`Downloading ${llmsContent.links.length} linked docs`);
+					const docs = await downloadLlmsDocs(llmsContent, baseUrl, (url, done, total) => {
+						onProgress(`Downloading linked doc ${done + 1}/${total}`);
+					});
+					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: packageName,
+								source: cachePath,
+								type: "doc"
+							}
+						});
+					}
+				}
+				writeToCache(packageName, version, cachedDocs);
+			}
+		}
+		if (resolved.docsUrl && !cachedDocs.some((d) => d.path.startsWith("docs/"))) {
+			const crawlPattern = resolved.crawlUrl || toCrawlPattern(resolved.docsUrl);
+			onProgress("Crawling docs site");
+			const crawledDocs = await fetchCrawledDocs(crawlPattern, onProgress).catch((err) => {
+				warnings.push(`Crawl failed for ${crawlPattern}: ${err?.message || err}`);
+				return [];
+			});
+			if (crawledDocs.length > 0) {
+				for (const doc of crawledDocs) {
+					if (!isFrameworkDoc(doc.path)) continue;
+					cachedDocs.push(doc);
+					docsToIndex.push({
+						id: doc.path,
+						content: doc.content,
+						metadata: {
+							package: packageName,
+							source: doc.path,
+							type: "doc"
+						}
+					});
+				}
+				docSource = crawlPattern;
+				docsType = "docs";
+				writeToCache(packageName, version, cachedDocs);
+			}
+		}
+		if (resolved.readmeUrl && cachedDocs.length === 0) {
+			onProgress("Fetching README");
+			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"
+					}
+				});
+				writeToCache(packageName, version, cachedDocs);
+			}
+		}
+		if (docsType !== "readme" && cachedDocs.filter((d) => d.path.startsWith("docs/") && d.path.endsWith(".md")).length > 1) {
+			const docsIndex = generateDocsIndex(cachedDocs);
+			if (docsIndex) writeToCache(packageName, version, [{
+				path: "docs/_INDEX.md",
+				content: docsIndex
+			}]);
+		}
+	} else {
+		onProgress("Loading cached docs");
+		const detected = detectDocsType(packageName, version, resolved.repoUrl, resolved.llmsUrl);
+		docsType = detected.docsType;
+		if (detected.docSource) docSource = detected.docSource;
+		if (!existsSync(getPackageDbPath(packageName, version))) {
+			onProgress("Reading cached docs for indexing");
+			const cached = readCachedDocs(packageName, version);
+			for (const doc of cached) docsToIndex.push({
+				id: doc.path,
+				content: doc.content,
+				metadata: {
+					package: packageName,
+					source: doc.path,
+					...classifyCachedDoc(doc.path)
+				}
+			});
+		}
+		if (docsType !== "readme" && !existsSync(join(getCacheDir(packageName, version), "docs", "_INDEX.md"))) {
+			onProgress("Generating docs index");
+			const cached = readCachedDocs(packageName, version);
+			if (cached.filter((d) => d.path.startsWith("docs/") && d.path.endsWith(".md")).length > 1) {
+				const docsIndex = generateDocsIndex(cached);
+				if (docsIndex) writeToCache(packageName, version, [{
+					path: "docs/_INDEX.md",
+					content: docsIndex
+				}]);
+			}
+		}
+	}
+	const gh = resolved.repoUrl ? parseGitHubUrl(resolved.repoUrl) : null;
+	const repoInfo = gh ? {
+		owner: gh.owner,
+		repo: gh.repo
+	} : void 0;
+	const repoCacheDir = repoInfo ? getRepoCacheDir(repoInfo.owner, repoInfo.repo) : null;
+	const cacheDir = getCacheDir(packageName, version);
+	const issuesDir = repoCacheDir ? join(repoCacheDir, "issues") : join(cacheDir, "issues");
+	const discussionsDir = repoCacheDir ? join(repoCacheDir, "discussions") : join(cacheDir, "discussions");
+	const releasesPath = repoCacheDir ? join(repoCacheDir, "releases") : join(cacheDir, "releases");
+	if (features.issues && gh && isGhAvailable() && !existsSync(issuesDir)) {
+		onProgress("Fetching issues via GitHub API");
+		const issues = await fetchGitHubIssues(gh.owner, gh.repo, 30, resolved.releasedAt, opts.from).catch(() => []);
+		if (issues.length > 0) {
+			onProgress(`Caching ${issues.length} issues`);
+			const issueDocs = [...issues.map((issue) => ({
+				path: `issues/issue-${issue.number}.md`,
+				content: formatIssueAsMarkdown(issue)
+			})), {
+				path: "issues/_INDEX.md",
+				content: generateIssueIndex(issues)
+			}];
+			if (repoInfo) writeToRepoCache(repoInfo.owner, repoInfo.repo, issueDocs);
+			else writeToCache(packageName, version, issueDocs);
+			for (const issue of issues) docsToIndex.push({
+				id: `issue-${issue.number}`,
+				content: sanitizeMarkdown(`#${issue.number}: ${issue.title}\n\n${issue.body || ""}`),
+				metadata: {
+					package: packageName,
+					source: `issues/issue-${issue.number}.md`,
+					type: "issue",
+					number: issue.number
+				}
+			});
+		}
+	}
+	if (features.discussions && gh && isGhAvailable() && !existsSync(discussionsDir)) {
+		onProgress("Fetching discussions via GitHub API");
+		const discussions = await fetchGitHubDiscussions(gh.owner, gh.repo, 20, resolved.releasedAt, opts.from).catch(() => []);
+		if (discussions.length > 0) {
+			onProgress(`Caching ${discussions.length} discussions`);
+			const discussionDocs = [...discussions.map((d) => ({
+				path: `discussions/discussion-${d.number}.md`,
+				content: formatDiscussionAsMarkdown(d)
+			})), {
+				path: "discussions/_INDEX.md",
+				content: generateDiscussionIndex(discussions)
+			}];
+			if (repoInfo) writeToRepoCache(repoInfo.owner, repoInfo.repo, discussionDocs);
+			else writeToCache(packageName, version, discussionDocs);
+			for (const d of discussions) docsToIndex.push({
+				id: `discussion-${d.number}`,
+				content: sanitizeMarkdown(`#${d.number}: ${d.title}\n\n${d.body || ""}`),
+				metadata: {
+					package: packageName,
+					source: `discussions/discussion-${d.number}.md`,
+					type: "discussion",
+					number: d.number
+				}
+			});
+		}
+	}
+	if (features.releases && gh && isGhAvailable() && !existsSync(releasesPath)) {
+		onProgress("Fetching releases via GitHub API");
+		const changelogRef = isPrerelease(version) ? getPrereleaseChangelogRef(packageName) : void 0;
+		const releaseDocs = await fetchReleaseNotes(gh.owner, gh.repo, version, resolved.gitRef, packageName, opts.from, changelogRef).catch(() => []);
+		let blogDocs = [];
+		if (getBlogPreset(packageName)) {
+			onProgress("Fetching blog release notes");
+			blogDocs = await fetchBlogReleases(packageName, version).catch(() => []);
+		}
+		const allDocs = [...releaseDocs, ...blogDocs];
+		const blogEntries = blogDocs.filter((d) => !d.path.endsWith("_INDEX.md")).map((d) => {
+			const versionMatch = d.path.match(/blog-(.+)\.md$/);
+			const fm = parseFrontmatter(d.content);
+			return {
+				version: versionMatch?.[1] ?? "",
+				title: fm.title ?? `Release ${versionMatch?.[1]}`,
+				date: fm.date ?? ""
+			};
+		}).filter((b) => b.version);
+		const ghReleases = releaseDocs.filter((d) => d.path.startsWith("releases/") && !d.path.endsWith("CHANGELOG.md")).map((d) => {
+			const fm = parseFrontmatter(d.content);
+			const tag = fm.tag ?? "";
+			const name = fm.name ?? tag;
+			const published = fm.published ?? "";
+			return {
+				id: 0,
+				tag,
+				name,
+				prerelease: false,
+				createdAt: published,
+				publishedAt: published,
+				markdown: ""
+			};
+		}).filter((r) => r.tag);
+		const hasChangelog = allDocs.some((d) => d.path === "releases/CHANGELOG.md");
+		if (ghReleases.length > 0 || blogEntries.length > 0) allDocs.push({
+			path: "releases/_INDEX.md",
+			content: generateReleaseIndex({
+				releases: ghReleases,
+				packageName,
+				blogReleases: blogEntries,
+				hasChangelog
+			})
+		});
+		if (allDocs.length > 0) {
+			onProgress(`Caching ${allDocs.length} releases`);
+			if (repoInfo) writeToRepoCache(repoInfo.owner, repoInfo.repo, allDocs);
+			else writeToCache(packageName, version, allDocs);
+			for (const doc of allDocs) docsToIndex.push({
+				id: doc.path,
+				content: doc.content,
+				metadata: {
+					package: packageName,
+					source: doc.path,
+					type: "release"
+				}
+			});
+		}
+	}
+	return {
+		docSource,
+		docsType,
+		docsToIndex,
+		hasIssues: features.issues && existsSync(issuesDir),
+		hasDiscussions: features.discussions && existsSync(discussionsDir),
+		hasReleases: features.releases && existsSync(releasesPath),
+		warnings,
+		repoInfo,
+		usedCache: useCache
+	};
+}
+/** Index all resources into the search database (single batch) */
+async function indexResources(opts) {
+	const { packageName, version, cwd, onProgress } = opts;
+	const features = opts.features ?? readConfig().features ?? defaultFeatures;
+	if (!features.search) return;
+	const dbPath = getPackageDbPath(packageName, version);
+	if (existsSync(dbPath)) return;
+	const allDocs = [...opts.docsToIndex];
+	const pkgDir = resolvePkgDir(packageName, cwd, version);
+	if (features.search && pkgDir) {
+		onProgress("Scanning exports");
+		const entryFiles = await resolveEntryFiles(pkgDir);
+		for (const e of entryFiles) allDocs.push({
+			id: e.path,
+			content: e.content,
+			metadata: {
+				package: packageName,
+				source: `pkg/${e.path}`,
+				type: e.type
+			}
+		});
+	}
+	if (allDocs.length === 0) return;
+	onProgress(`Building search index (${allDocs.length} docs)`);
+	await createIndex(allDocs, {
+		dbPath,
+		onProgress: ({ phase, current, total }) => {
+			if (phase === "storing") {
+				const d = allDocs[current - 1];
+				onProgress(`Storing ${d?.metadata?.type === "source" || d?.metadata?.type === "types" ? "code" : d?.metadata?.type || "doc"} (${current}/${total})`);
+			} else if (phase === "embedding") onProgress(`Creating embeddings (${current}/${total})`);
+		}
+	});
+}
+/**
+* Eject references: copy cached files as real files into references/ dir.
+* Used for portable skills (git repos, sharing). Replaces symlinks with copies.
+* Does NOT copy pkg files — those reference node_modules directly.
+*/
+function ejectReferences(skillDir, packageName, cwd, version, docsType, features, repoInfo) {
+	const f = features ?? readConfig().features ?? defaultFeatures;
+	const cacheDir = getCacheDir(packageName, version);
+	const refsDir = join(skillDir, "references");
+	const repoDir = repoInfo ? getRepoCacheDir(repoInfo.owner, repoInfo.repo) : cacheDir;
+	if (!hasShippedDocs(packageName, cwd, version) && docsType !== "readme") copyCachedSubdir(cacheDir, refsDir, "docs");
+	if (f.issues) copyCachedSubdir(repoDir, refsDir, "issues");
+	if (f.discussions) copyCachedSubdir(repoDir, refsDir, "discussions");
+	if (f.releases) copyCachedSubdir(repoDir, refsDir, "releases");
+}
+/** Recursively copy a cached subdirectory into the references dir */
+function copyCachedSubdir(cacheDir, refsDir, subdir) {
+	const srcDir = join(cacheDir, subdir);
+	if (!existsSync(srcDir)) return;
+	const destDir = join(refsDir, subdir);
+	mkdirSync(destDir, { recursive: true });
+	function walk(dir, rel) {
+		for (const entry of readdirSync(dir, { withFileTypes: true })) {
+			const srcPath = join(dir, entry.name);
+			const destPath = join(destDir, rel ? `${rel}/${entry.name}` : entry.name);
+			if (entry.isDirectory()) {
+				mkdirSync(destPath, { recursive: true });
+				walk(srcPath, rel ? `${rel}/${entry.name}` : entry.name);
+			} else copyFileSync(srcPath, destPath);
+		}
+	}
+	walk(srcDir, "");
+}
+/**
+* Check if .gitignore has `.skilld` entry.
+* If missing, prompt to add it. Skipped for global installs.
+*/
+async function ensureGitignore(skillsDir, cwd, isGlobal) {
+	if (isGlobal) return;
+	const gitignorePath = join(cwd, ".gitignore");
+	const pattern = ".skilld";
+	if (existsSync(gitignorePath)) {
+		if (readFileSync(gitignorePath, "utf-8").split("\n").some((line) => line.trim() === pattern)) return;
+	}
+	if (!isInteractive()) {
+		const entry = `\n# Skilld references (recreated by \`skilld install\`)\n${pattern}\n`;
+		if (existsSync(gitignorePath)) appendFileSync(gitignorePath, `${readFileSync(gitignorePath, "utf-8").endsWith("\n") ? "" : "\n"}${entry}`);
+		else writeFileSync(gitignorePath, entry);
+		return;
+	}
+	const relSkillsDir = relative(cwd, skillsDir) || ".";
+	p.log.info(`\x1B[1mGit guidance:\x1B[0m\n  \x1B[32m✓\x1B[0m Commit: \x1B[36m${relSkillsDir}/*/SKILL.md\x1B[0m\n  \x1B[32m✓\x1B[0m Commit: \x1B[36m${relSkillsDir}/skilld-lock.yaml\x1B[0m\n  \x1B[31m✗\x1B[0m Ignore: \x1B[36m${pattern}\x1B[0m \x1B[90m(recreated by \`skilld install\`)\x1B[0m`);
+	const add = await p.confirm({
+		message: `Add \`${pattern}\` to .gitignore?`,
+		initialValue: true
+	});
+	if (p.isCancel(add) || !add) return;
+	const entry = `\n# Skilld references (recreated by \`skilld install\`)\n${pattern}\n`;
+	if (existsSync(gitignorePath)) appendFileSync(gitignorePath, `${readFileSync(gitignorePath, "utf-8").endsWith("\n") ? "" : "\n"}${entry}`);
+	else writeFileSync(gitignorePath, entry);
+	p.log.success("Updated .gitignore");
+}
+const SKILLD_MARKER_START = "<!-- skilld -->";
+const SKILLD_MARKER_END = "<!-- /skilld -->";
+const SKILLD_INSTRUCTIONS = `${SKILLD_MARKER_START}
+Before modifying code, evaluate each installed skill against the current task.
+For each skill, determine YES/NO relevance and invoke all YES skills before proceeding.
+${SKILLD_MARKER_END}`;
+/**
+* Check if agent instruction file has skilld skill-activation snippet.
+* If missing, prompt to add it. Skipped for global installs or agents without an instructionFile.
+*/
+async function ensureAgentInstructions(agent, cwd, isGlobal) {
+	if (isGlobal) return;
+	const agentConfig = targets[agent];
+	if (!agentConfig.instructionFile) return;
+	const filePath = join(cwd, agentConfig.instructionFile);
+	if (existsSync(filePath)) {
+		if (readFileSync(filePath, "utf-8").includes(SKILLD_MARKER_START)) return;
+	}
+	if (!isInteractive()) {
+		if (existsSync(filePath)) appendFileSync(filePath, `${readFileSync(filePath, "utf-8").endsWith("\n") ? "" : "\n"}\n${SKILLD_INSTRUCTIONS}\n`);
+		else writeFileSync(filePath, `${SKILLD_INSTRUCTIONS}\n`);
+		return;
+	}
+	p.note(SKILLD_INSTRUCTIONS, `Will be added to ${agentConfig.instructionFile}`);
+	const add = await p.confirm({
+		message: `Add skill activation instructions to ${agentConfig.instructionFile}?`,
+		initialValue: true
+	});
+	if (p.isCancel(add) || !add) return;
+	if (existsSync(filePath)) appendFileSync(filePath, `${readFileSync(filePath, "utf-8").endsWith("\n") ? "" : "\n"}\n${SKILLD_INSTRUCTIONS}\n`);
+	else writeFileSync(filePath, `${SKILLD_INSTRUCTIONS}\n`);
+	p.log.success(`Updated ${agentConfig.instructionFile}`);
+}
+/** Select LLM model for SKILL.md generation (independent of target agent) */
+async function selectModel(skipPrompt) {
+	const config = readConfig();
+	const available = await getAvailableModels();
+	if (available.length === 0) {
+		p.log.warn("No LLM CLIs found (claude, gemini, codex)");
+		return null;
+	}
+	if (skipPrompt) {
+		if (config.model && available.some((m) => m.id === config.model)) return config.model;
+		return available.find((m) => m.recommended)?.id ?? available[0].id;
+	}
+	const modelChoice = await p.select({
+		message: "Model for SKILL.md generation",
+		options: available.map((m) => ({
+			label: m.recommended ? `${m.name} (Recommended)` : m.name,
+			value: m.id,
+			hint: `${m.agentName} · ${m.hint}`
+		})),
+		initialValue: available.find((m) => m.recommended)?.id ?? available[0].id
+	});
+	if (p.isCancel(modelChoice)) {
+		p.cancel("Cancelled");
+		return null;
+	}
+	updateConfig({ model: modelChoice });
+	return modelChoice;
+}
+/** Default sections when model is pre-set (non-interactive) */
+const DEFAULT_SECTIONS = ["best-practices", "api-changes"];
+async function selectSkillSections(message = "Generate SKILL.md with LLM") {
+	p.log.info("Budgets adapt to package release density.");
+	const selected = await p.multiselect({
+		message,
+		options: [
+			{
+				label: "API changes",
+				value: "api-changes",
+				hint: "new/deprecated APIs from version history"
+			},
+			{
+				label: "Best practices",
+				value: "best-practices",
+				hint: "gotchas, pitfalls, patterns"
+			},
+			{
+				label: "Custom section",
+				value: "custom",
+				hint: "add your own section"
+			}
+		],
+		initialValues: DEFAULT_SECTIONS,
+		required: false
+	});
+	if (p.isCancel(selected)) return {
+		sections: [],
+		cancelled: true
+	};
+	const sections = selected;
+	if (sections.length === 0) return {
+		sections: [],
+		cancelled: false
+	};
+	if (sections.length > 1) {
+		const n = sections.length;
+		const budgetLines = [];
+		for (const s of sections) switch (s) {
+			case "api-changes":
+				budgetLines.push(`  API changes     ${maxItems(6, 12, n)}–${maxItems(6, Math.round(12 * 1.6), n)} items (adapts to release churn)`);
+				break;
+			case "best-practices":
+				budgetLines.push(`  Best practices  ${maxItems(4, 10, n)}–${maxItems(4, Math.round(10 * 1.3), n)} items`);
+				break;
+			case "custom":
+				budgetLines.push(`  Custom          ≤${maxLines(50, 80, n)} lines`);
+				break;
+		}
+		p.log.info(`Budget (${n} sections):\n${budgetLines.join("\n")}`);
+	}
+	let customPrompt;
+	if (sections.includes("custom")) {
+		const heading = await p.text({
+			message: "Section heading",
+			placeholder: "e.g. \"Migration from v2\" or \"SSR Patterns\""
+		});
+		if (p.isCancel(heading)) return {
+			sections: [],
+			cancelled: true
+		};
+		const body = await p.text({
+			message: "Instructions for this section",
+			placeholder: "e.g. \"Document breaking changes and migration steps from v2 to v3\""
+		});
+		if (p.isCancel(body)) return {
+			sections: [],
+			cancelled: true
+		};
+		customPrompt = {
+			heading,
+			body
+		};
+	}
+	return {
+		sections,
+		customPrompt,
+		cancelled: false
+	};
+}
+/**
+* Resolve sections + model for LLM enhancement.
+* If presetModel is provided, uses DEFAULT_SECTIONS without prompting.
+* Returns null if cancelled or no sections/model selected.
+*/
+async function selectLlmConfig(presetModel, message) {
+	if (presetModel) return {
+		model: presetModel,
+		sections: DEFAULT_SECTIONS
+	};
+	if (!isInteractive()) return null;
+	const defaultModel = await selectModel(true);
+	if (!defaultModel) return null;
+	const defaultModelName = getModelName(defaultModel);
+	const choice = await p.select({
+		message: "Generate enhanced SKILL.md?",
+		options: [
+			{
+				label: defaultModelName,
+				value: "default",
+				hint: "configured default"
+			},
+			{
+				label: "Different model",
+				value: "pick",
+				hint: "choose another model"
+			},
+			{
+				label: "Skip",
+				value: "skip",
+				hint: "base skill only"
+			}
+		]
+	});
+	if (p.isCancel(choice)) return null;
+	if (choice === "skip") return null;
+	const model = choice === "pick" ? await selectModel(false) : defaultModel;
+	if (!model) return null;
+	const modelName = getModelName(model);
+	const { sections, customPrompt, cancelled } = await selectSkillSections(message ? `${message} (${modelName})` : `Generate SKILL.md with ${modelName}`);
+	if (cancelled || sections.length === 0) return null;
+	return {
+		model,
+		sections,
+		customPrompt
+	};
+}
+async function enhanceSkillWithLLM(opts) {
+	const { packageName, version, skillDir, dirName, model, resolved, relatedSkills, hasIssues, hasDiscussions, hasReleases, hasChangelog, docsType, hasShippedDocs: shippedDocs, pkgFiles, force, debug, sections, customPrompt, packages, features, eject } = opts;
+	const effectiveFeatures = features;
+	const llmLog = p.taskLog({ title: `Agent exploring ${packageName}` });
+	const docFiles = listReferenceFiles(skillDir);
+	const { optimized, wasOptimized, usage, cost, warnings, error, debugLogsDir } = await optimizeDocs({
+		packageName,
+		skillDir,
+		model,
+		version,
+		hasGithub: hasIssues || hasDiscussions,
+		hasReleases,
+		hasChangelog,
+		docFiles,
+		docsType,
+		hasShippedDocs: shippedDocs,
+		noCache: force,
+		debug,
+		sections,
+		customPrompt,
+		features: effectiveFeatures,
+		pkgFiles,
+		onProgress: createToolProgress(llmLog)
+	});
+	if (wasOptimized) {
+		const costParts = [];
+		if (usage) {
+			const totalK = Math.round(usage.totalTokens / 1e3);
+			costParts.push(`${totalK}k tokens`);
+		}
+		if (cost) costParts.push(`$${cost.toFixed(2)}`);
+		const costSuffix = costParts.length > 0 ? ` (${costParts.join(", ")})` : "";
+		llmLog.success(`Generated best practices${costSuffix}`);
+		if (debugLogsDir) p.log.info(`Debug logs: ${relative(process.cwd(), debugLogsDir)}`);
+		if (error) p.log.warn(`\x1B[33mPartial failure: ${error}\x1B[0m`);
+		if (warnings?.length) for (const w of warnings) p.log.warn(`\x1B[33m${w}\x1B[0m`);
+		const skillMd = generateSkillMd({
+			name: packageName,
+			version,
+			releasedAt: resolved.releasedAt,
+			dependencies: resolved.dependencies,
+			distTags: resolved.distTags,
+			body: optimized,
+			relatedSkills,
+			hasIssues,
+			hasDiscussions,
+			hasReleases,
+			hasChangelog,
+			docsType,
+			hasShippedDocs: shippedDocs,
+			pkgFiles,
+			generatedBy: getModelLabel(model),
+			dirName,
+			packages,
+			repoUrl: resolved.repoUrl,
+			features,
+			eject
+		});
+		writeFileSync(join(skillDir, "SKILL.md"), skillMd);
+	} else llmLog.error(`LLM optimization failed${error ? `: ${error}` : ""}`);
+}
+/**
+* Anonymous telemetry — fire-and-forget GET to add-skill.vercel.sh/t
+*
+* Opt-out: set DISABLE_TELEMETRY=1 or DO_NOT_TRACK=1
+* Auto-disabled in CI environments.
+*/
+const TELEMETRY_URL = "https://add-skill.vercel.sh/t";
+const SKILLS_VERSION = "1.3.9";
+function isEnabled() {
+	return !process.env.DISABLE_TELEMETRY && !process.env.DO_NOT_TRACK;
+}
+function track(data) {
+	if (!isEnabled()) return;
+	try {
+		const params = new URLSearchParams();
+		params.set("v", SKILLS_VERSION);
+		if (isCI) params.set("ci", "1");
+		for (const [key, value] of Object.entries(data)) if (value !== void 0 && value !== null) params.set(key, String(value));
+		fetch(`${TELEMETRY_URL}?${params.toString()}`).catch(() => {});
+	} catch {}
+}
+async function syncGitSkills(opts) {
+	const { source, agent, global: isGlobal, yes } = opts;
+	const cwd = process.cwd();
+	const agentConfig = targets[agent];
+	const baseDir = isGlobal ? join(CACHE_DIR, "skills") : join(cwd, agentConfig.skillsDir);
+	const label = source.type === "local" ? source.localPath : `${source.owner}/${source.repo}`;
+	const spin = timedSpinner();
+	spin.start(`Fetching skills from ${label}`);
+	const { skills } = await fetchGitSkills(source, (msg) => spin.message(msg));
+	if (skills.length === 0) {
+		if (source.type === "github" && source.owner && source.repo) {
+			spin.stop(`No pre-authored skills in ${label}, generating from repo docs...`);
+			return syncGitHubRepo(opts);
+		}
+		spin.stop(`No skills found in ${label}`);
+		return;
+	}
+	spin.stop(`Found ${skills.length} skill(s) in ${label}`);
+	let selected = skills;
+	if (opts.skillFilter?.length) {
+		const filterSet = new Set(opts.skillFilter.map((s) => s.toLowerCase().replace(/-skilld$/, "")));
+		selected = skills.filter((s) => filterSet.has(s.name.toLowerCase().replace(/-skilld$/, "")));
+		if (selected.length === 0) {
+			p.log.warn(`No skills matched: ${opts.skillFilter.join(", ")}`);
+			p.log.message(`Available: ${skills.map((s) => s.name).join(", ")}`);
+			return;
+		}
+	} else if (source.skillPath) selected = skills;
+	else if (skills.length > 1 && !yes) {
+		const choices = await p.autocompleteMultiselect({
+			message: `Select skills to install from ${label}`,
+			options: skills.map((s) => ({
+				label: s.name.replace(/-skilld$/, ""),
+				value: s.name,
+				hint: s.description || s.path
+			})),
+			initialValues: []
+		});
+		if (p.isCancel(choices)) return;
+		const selectedNames = new Set(choices);
+		selected = skills.filter((s) => selectedNames.has(s.name));
+		if (selected.length === 0) return;
+	}
+	mkdirSync(baseDir, { recursive: true });
+	for (const skill of selected) {
+		const skillDir = join(baseDir, skill.name);
+		mkdirSync(skillDir, { recursive: true });
+		writeFileSync(join(skillDir, "SKILL.md"), sanitizeMarkdown(skill.content));
+		if (skill.files.length > 0) for (const f of skill.files) {
+			const filePath = join(skillDir, f.path);
+			mkdirSync(dirname(filePath), { recursive: true });
+			writeFileSync(filePath, f.content);
+		}
+		const sourceType = source.type === "local" ? "local" : source.type;
+		writeLock(baseDir, skill.name, {
+			source: sourceType,
+			repo: source.type === "local" ? source.localPath : `${source.owner}/${source.repo}`,
+			path: skill.path || void 0,
+			ref: source.ref || "main",
+			syncedAt: (/* @__PURE__ */ new Date()).toISOString().split("T")[0],
+			generator: "external"
+		});
+	}
+	if (!isGlobal) registerProject(cwd);
+	if (source.type !== "local" && source.owner && source.repo) track({
+		event: "install",
+		source: `${source.owner}/${source.repo}`,
+		skills: selected.map((s) => s.name).join(","),
+		agents: agent,
+		...isGlobal && { global: "1" },
+		sourceType: source.type
+	});
+	const names = selected.map((s) => `\x1B[36m${s.name}\x1B[0m`).join(", ");
+	p.log.success(`Installed ${names}`);
+}
+/**
+* Generate a skill from a GitHub repo's docs (no npm package required).
+* Uses the same pipeline as npm packages: resolve → fetch → cache → generate → LLM enhance.
+*/
+async function syncGitHubRepo(opts) {
+	const { source, agent, global: isGlobal, yes } = opts;
+	const owner = source.owner;
+	const repo = source.repo;
+	const cwd = process.cwd();
+	const spin = timedSpinner();
+	spin.start(`Resolving ${owner}/${repo}`);
+	const resolved = await resolveGitHubRepo(owner, repo, (msg) => spin.message(msg));
+	if (!resolved) {
+		spin.stop(`Could not find docs for ${owner}/${repo}`);
+		return;
+	}
+	const repoUrl = `https://github.com/${owner}/${repo}`;
+	const packageName = `${owner}-${repo}`;
+	const version = resolved.version || "main";
+	const versionKey = getVersionKey(version);
+	const useCache = isCached(packageName, version);
+	spin.stop(`Resolved ${owner}/${repo}@${useCache ? versionKey : version}${useCache ? " (cached)" : ""}`);
+	ensureCacheDir();
+	const baseDir = resolveBaseDir(cwd, agent, isGlobal);
+	const skillDirName = sanitizeName(`${owner}-${repo}`);
+	const skillDir = join(baseDir, skillDirName);
+	mkdirSync(skillDir, { recursive: true });
+	const features = readConfig().features ?? defaultFeatures;
+	const resSpin = timedSpinner();
+	resSpin.start("Finding resources");
+	const resources = await fetchAndCacheResources({
+		packageName,
+		resolved,
+		version,
+		useCache,
+		features,
+		from: opts.from,
+		onProgress: (msg) => resSpin.message(msg)
+	});
+	const resParts = [];
+	if (resources.docsToIndex.length > 0) {
+		const docCount = resources.docsToIndex.filter((d) => d.metadata?.type === "doc").length;
+		if (docCount > 0) resParts.push(`${docCount} docs`);
+	}
+	if (resources.hasIssues) resParts.push("issues");
+	if (resources.hasDiscussions) resParts.push("discussions");
+	if (resources.hasReleases) resParts.push("releases");
+	resSpin.stop(`Fetched ${resParts.length > 0 ? resParts.join(", ") : "resources"}`);
+	for (const w of resources.warnings) p.log.warn(`\x1B[33m${w}\x1B[0m`);
+	linkAllReferences(skillDir, packageName, cwd, version, resources.docsType, void 0, features);
+	if (features.search) {
+		const idxSpin = timedSpinner();
+		idxSpin.start("Creating search index");
+		await indexResources({
+			packageName,
+			version,
+			cwd,
+			docsToIndex: resources.docsToIndex,
+			features,
+			onProgress: (msg) => idxSpin.message(msg)
+		});
+		idxSpin.stop("Search index ready");
+	}
+	const hasChangelog = detectChangelog(resolvePkgDir(packageName, cwd, version), getCacheDir(packageName, version));
+	const shippedDocs = hasShippedDocs(packageName, cwd, version);
+	const pkgFiles = getPkgKeyFiles(packageName, cwd, version);
+	writeLock(baseDir, skillDirName, {
+		packageName,
+		version,
+		repo: `${owner}/${repo}`,
+		source: resources.docSource,
+		syncedAt: (/* @__PURE__ */ new Date()).toISOString().split("T")[0],
+		generator: "skilld"
+	});
+	const baseSkillMd = generateSkillMd({
+		name: packageName,
+		version,
+		releasedAt: resolved.releasedAt,
+		description: resolved.description,
+		relatedSkills: [],
+		hasIssues: resources.hasIssues,
+		hasDiscussions: resources.hasDiscussions,
+		hasReleases: resources.hasReleases,
+		hasChangelog,
+		docsType: resources.docsType,
+		hasShippedDocs: shippedDocs,
+		pkgFiles,
+		dirName: skillDirName,
+		repoUrl,
+		features
+	});
+	writeFileSync(join(skillDir, "SKILL.md"), baseSkillMd);
+	p.log.success(`Created base skill: ${relative(cwd, skillDir)}`);
+	if (!readConfig().skipLlm && (!yes || opts.model)) {
+		const llmConfig = await selectLlmConfig(opts.model);
+		if (llmConfig) {
+			p.log.step(getModelLabel(llmConfig.model));
+			await enhanceSkillWithLLM({
+				packageName,
+				version,
+				skillDir,
+				dirName: skillDirName,
+				model: llmConfig.model,
+				resolved,
+				relatedSkills: [],
+				hasIssues: resources.hasIssues,
+				hasDiscussions: resources.hasDiscussions,
+				hasReleases: resources.hasReleases,
+				hasChangelog,
+				docsType: resources.docsType,
+				hasShippedDocs: shippedDocs,
+				pkgFiles,
+				force: opts.force,
+				debug: opts.debug,
+				sections: llmConfig.sections,
+				customPrompt: llmConfig.customPrompt,
+				features
+			});
+		}
+	}
+	const shared = !isGlobal && getSharedSkillsDir(cwd);
+	if (shared) linkSkillToAgents(skillDirName, shared, cwd);
+	if (!isGlobal) {
+		registerProject(cwd);
+		await ensureGitignore(shared || targets[agent].skillsDir, cwd, isGlobal);
+		await ensureAgentInstructions(agent, cwd, isGlobal);
+	}
+	await shutdownWorker();
+	track({
+		event: "install",
+		source: `${owner}/${repo}`,
+		skills: skillDirName,
+		agents: agent,
+		...isGlobal && { global: "1" },
+		sourceType: "github-generated"
+	});
+	p.outro(`Synced ${owner}/${repo} to ${relative(cwd, skillDir)}`);
+}
+const STATUS_ICONS = {
+	pending: "○",
+	resolving: "◐",
+	downloading: "◒",
+	embedding: "◓",
+	exploring: "◔",
+	thinking: "◔",
+	generating: "◑",
+	done: "✓",
+	error: "✗"
+};
+const STATUS_COLORS = {
+	pending: "\x1B[90m",
+	resolving: "\x1B[36m",
+	downloading: "\x1B[36m",
+	embedding: "\x1B[36m",
+	exploring: "\x1B[34m",
+	thinking: "\x1B[35m",
+	generating: "\x1B[33m",
+	done: "\x1B[32m",
+	error: "\x1B[31m"
+};
+async function syncPackagesParallel(config) {
+	const { packages, concurrency = 5 } = config;
+	const agent = targets[config.agent];
+	const states = /* @__PURE__ */ new Map();
+	const cwd = process.cwd();
+	for (const pkg of packages) states.set(pkg, {
+		name: pkg,
+		status: "pending",
+		message: "Waiting..."
+	});
+	function render() {
+		const maxNameLen = Math.max(...packages.map((p) => p.length), 20);
+		const lines = [...states.values()].map((s) => {
+			const icon = STATUS_ICONS[s.status];
+			const color = STATUS_COLORS[s.status];
+			const reset = "\x1B[0m";
+			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}${elapsed}${preview}`;
+		});
+		const doneCount = [...states.values()].filter((s) => s.status === "done").length;
+		const errorCount = [...states.values()].filter((s) => s.status === "error").length;
+		logUpdate(`\x1B[1m${config.mode === "update" ? "Updating" : "Syncing"} ${packages.length} packages\x1B[0m (${doneCount} done${errorCount > 0 ? `, ${errorCount} failed` : ""})\n` + lines.join("\n"));
+	}
+	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;
+		if (version) state.version = version;
+		render();
+	}
+	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]);
+			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);
+			errors.push({
+				pkg: packages[i],
+				reason
+			});
+		}
+	}
+	const pastVerb = config.mode === "update" ? "Updated" : "Created";
+	const skillMsg = `${pastVerb} ${successfulPkgs.length} base skills${shippedPkgs.length > 1 ? ` (Skipping ${shippedPkgs.length})` : ""}`;
+	p.log.success(skillMsg);
+	for (const [, data] of skillData) for (const w of data.warnings) p.log.warn(`\x1B[33m${w}\x1B[0m`);
+	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 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(getSharedSkillsDir(cwd) ? SHARED_SKILLS_DIR : agent.skillsDir, cwd, config.global);
+	await ensureAgentInstructions(config.agent, cwd, config.global);
+	await shutdownWorker();
+	p.outro(`${pastVerb} ${successfulPkgs.length}/${packages.length} packages`);
+}
+/** Phase 1: Generate base skill (no LLM). Returns 'shipped' if shipped skill was linked, or BaseSkillData. */
+async function syncBaseSkill(packageSpec, config, cwd, update) {
+	const { name: packageName, tag: requestedTag } = parsePackageSpec(packageSpec);
+	const localVersion = (await readLocalDependencies(cwd).catch(() => [])).find((d) => d.name === packageName)?.version;
+	const { package: resolvedPkg, attempts } = await resolvePackageDocsWithAttempts(requestedTag ? packageSpec : packageName, {
+		version: localVersion,
+		cwd,
+		onProgress: (step) => update(packageName, "resolving", RESOLVE_STEP_LABELS[step])
+	});
+	let resolved = resolvedPkg;
+	if (!resolved) {
+		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") {
+			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}`);
+	}
+	const version = localVersion || resolved.version || "latest";
+	const versionKey = getVersionKey(version);
+	if (!existsSync(join(cwd, "node_modules", packageName))) {
+		update(packageName, "downloading", "Downloading dist...", versionKey);
+		await fetchPkgDist(packageName, version);
+	}
+	const shippedResult = handleShippedSkills(packageName, version, cwd, config.agent, config.global);
+	if (shippedResult) {
+		const shared = !config.global && getSharedSkillsDir(cwd);
+		if (shared) for (const shipped of shippedResult.shipped) linkSkillToAgents(shipped.skillName, shared, cwd);
+		update(packageName, "done", "Published SKILL.md", versionKey);
+		return "shipped";
+	}
+	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 baseDir = resolveBaseDir(cwd, config.agent, config.global);
+	const skillDirName = computeSkillDirName(packageName);
+	const skillDir = join(baseDir, skillDirName);
+	mkdirSync(skillDir, { recursive: true });
+	const features = readConfig().features ?? defaultFeatures;
+	const resources = await fetchAndCacheResources({
+		packageName,
+		resolved,
+		version,
+		useCache,
+		features,
+		onProgress: (msg) => update(packageName, "downloading", msg, versionKey)
+	});
+	update(packageName, "downloading", "Linking references...", versionKey);
+	linkAllReferences(skillDir, packageName, cwd, version, resources.docsType, void 0, features, resources.repoInfo);
+	if (features.search) {
+		update(packageName, "embedding", "Indexing docs", versionKey);
+		await indexResources({
+			packageName,
+			version,
+			cwd,
+			docsToIndex: resources.docsToIndex,
+			features,
+			onProgress: (msg) => update(packageName, "embedding", msg, versionKey)
+		});
+	}
+	const hasChangelog = detectChangelog(resolvePkgDir(packageName, cwd, version), getCacheDir(packageName, 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,
+		releasedAt: resolved.releasedAt,
+		description: resolved.description,
+		dependencies: resolved.dependencies,
+		distTags: resolved.distTags,
+		relatedSkills,
+		hasIssues: resources.hasIssues,
+		hasDiscussions: resources.hasDiscussions,
+		hasReleases: resources.hasReleases,
+		hasChangelog,
+		docsType: resources.docsType,
+		hasShippedDocs: shippedDocs,
+		pkgFiles,
+		dirName: skillDirName,
+		packages: allPackages.length > 1 ? allPackages : void 0,
+		repoUrl: resolved.repoUrl,
+		features
+	});
+	writeFileSync(join(skillDir, "SKILL.md"), skillMd);
+	const shared = !config.global && getSharedSkillsDir(cwd);
+	if (shared) linkSkillToAgents(skillDirName, shared, cwd);
+	if (!config.global) registerProject(cwd);
+	update(packageName, "done", config.mode === "update" ? "Skill updated" : "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,
+		warnings: resources.warnings,
+		features,
+		usedCache: resources.usedCache
+	};
+}
+/** Phase 2: Enhance skill with LLM */
+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: data.version,
+		hasGithub,
+		hasReleases: data.hasReleases,
+		hasChangelog: data.hasChangelog,
+		docFiles,
+		docsType: data.docsType,
+		hasShippedDocs: data.shippedDocs,
+		noCache: config.force,
+		debug: config.debug,
+		sections,
+		customPrompt,
+		features: data.features,
+		pkgFiles: data.pkgFiles,
+		onProgress: (progress) => {
+			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) {
+		update(packageName, "error", error, versionKey);
+		throw new Error(error);
+	}
+	if (wasOptimized) {
+		const skillMd = generateSkillMd({
+			name: packageName,
+			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,
+			features: data.features
+		});
+		writeFileSync(join(skillDir, "SKILL.md"), skillMd);
+	}
+	update(packageName, "done", "Skill optimized", versionKey);
+}
+function showResolveAttempts(attempts) {
+	if (attempts.length === 0) return;
+	p.log.message("\x1B[90mResolution attempts:\x1B[0m");
+	for (const attempt of attempts) {
+		const icon = attempt.status === "success" ? "\x1B[32m✓\x1B[0m" : "\x1B[90m✗\x1B[0m";
+		const source = `\x1B[90m${attempt.source}\x1B[0m`;
+		const msg = attempt.message ? ` - ${attempt.message}` : "";
+		p.log.message(`  ${icon} ${source}${msg}`);
+	}
+}
+async function syncCommand(state, opts) {
+	if (opts.packages && opts.packages.length > 0) {
+		if (opts.packages.length > 1) return syncPackagesParallel({
+			packages: opts.packages,
+			global: opts.global,
+			agent: opts.agent,
+			model: opts.model,
+			yes: opts.yes,
+			force: opts.force,
+			debug: opts.debug,
+			mode: opts.mode
+		});
+		await syncSinglePackage(opts.packages[0], opts);
+		return;
+	}
+	const packages = await interactivePicker(state);
+	if (!packages || packages.length === 0) {
+		p.outro("No packages selected");
+		return;
+	}
+	if (packages.length > 1) return syncPackagesParallel({
+		packages,
+		global: opts.global,
+		agent: opts.agent,
+		model: opts.model,
+		yes: opts.yes,
+		force: opts.force,
+		debug: opts.debug,
+		mode: opts.mode
+	});
+	await syncSinglePackage(packages[0], opts);
+}
+async function interactivePicker(state) {
+	const spin = timedSpinner();
+	spin.start("Detecting imports...");
+	const { packages: detected, error } = await detectImportedPackages(process.cwd());
+	const declaredMap = state.deps;
+	if (error || detected.length === 0) {
+		spin.stop(error ? `Detection failed: ${error}` : "No imports detected");
+		if (declaredMap.size === 0) {
+			p.log.warn("No dependencies found");
+			return null;
+		}
+		return pickFromList([...declaredMap.entries()].map(([name, version]) => ({
+			name,
+			version: maskPatch(version),
+			count: 0,
+			inPkgJson: true
+		})), state);
+	}
+	spin.stop(`Loaded ${detected.length} project skills`);
+	return pickFromList(detected.map((pkg) => ({
+		name: pkg.name,
+		version: declaredMap.get(pkg.name),
+		count: pkg.count,
+		inPkgJson: declaredMap.has(pkg.name)
+	})), state);
+}
+function maskPatch(version) {
+	if (!version) return void 0;
+	const parts = version.split(".");
+	if (parts.length >= 3) {
+		parts[2] = "x";
+		return parts.slice(0, 3).join(".");
+	}
+	return version;
+}
+async function pickFromList(packages, state) {
+	const missingSet = new Set(state.missing);
+	const outdatedSet = new Set(state.outdated.map((s) => s.name));
+	const options = packages.map((pkg) => ({
+		label: pkg.inPkgJson ? `${pkg.name} ★` : pkg.name,
+		value: pkg.name,
+		hint: [maskPatch(pkg.version), pkg.count > 0 ? `${pkg.count} imports` : null].filter(Boolean).join(" · ") || void 0
+	}));
+	const initialValues = packages.filter((pkg) => missingSet.has(pkg.name) || outdatedSet.has(pkg.name)).map((pkg) => pkg.name);
+	const selected = await p.multiselect({
+		message: "Select packages to sync",
+		options,
+		required: false,
+		initialValues
+	});
+	if (p.isCancel(selected)) {
+		p.cancel("Cancelled");
+		return null;
+	}
+	return selected;
+}
+async function syncSinglePackage(packageSpec, config) {
+	const { name: packageName, tag: requestedTag } = parsePackageSpec(packageSpec);
+	const spin = timedSpinner();
+	spin.start(`Resolving ${packageSpec}`);
+	const cwd = process.cwd();
+	const localVersion = (await readLocalDependencies(cwd).catch(() => [])).find((d) => d.name === packageName)?.version;
+	const resolveResult = await resolvePackageDocsWithAttempts(requestedTag ? packageSpec : packageName, {
+		version: localVersion,
+		cwd,
+		onProgress: (step) => spin.message(`${packageName}: ${RESOLVE_STEP_LABELS[step]}`)
+	});
+	let resolved = resolveResult.package;
+	if (!resolved) {
+		spin.message(`Resolving local package: ${packageName}`);
+		resolved = await resolveLocalDep(packageName, cwd);
+	}
+	if (!resolved) {
+		spin.message(`Searching npm for "${packageName}"...`);
+		const suggestions = await searchNpmPackages(packageName);
+		if (suggestions.length > 0) {
+			spin.stop(`Package "${packageName}" not found on npm`);
+			showResolveAttempts(resolveResult.attempts);
+			const selected = await p.select({
+				message: "Did you mean one of these?",
+				options: [...suggestions.map((s) => ({
+					label: s.name,
+					value: s.name,
+					hint: s.description
+				})), {
+					label: "None of these",
+					value: "_none_"
+				}]
+			});
+			if (!p.isCancel(selected) && selected !== "_none_") return syncSinglePackage(selected, config);
+			return;
+		}
+		spin.stop(`Could not find docs for: ${packageName}`);
+		showResolveAttempts(resolveResult.attempts);
+		return;
+	}
+	const version = localVersion || resolved.version || "latest";
+	const versionKey = getVersionKey(version);
+	if (config.force) forceClearCache(packageName, version);
+	const useCache = isCached(packageName, version);
+	if (!existsSync(join(cwd, "node_modules", packageName))) {
+		spin.message(`Downloading ${packageName}@${version} dist`);
+		await fetchPkgDist(packageName, version);
+	}
+	const shippedResult = handleShippedSkills(packageName, version, cwd, config.agent, config.global);
+	if (shippedResult) {
+		const shared = !config.global && getSharedSkillsDir(cwd);
+		for (const shipped of shippedResult.shipped) {
+			if (shared) linkSkillToAgents(shipped.skillName, shared, cwd);
+			p.log.success(`Using published SKILL.md: ${shipped.skillName} → ${relative(cwd, shipped.skillDir)}`);
+		}
+		spin.stop(`Using published SKILL.md(s) from ${packageName}`);
+		return;
+	}
+	spin.stop(`Resolved ${packageName}@${useCache ? versionKey : version}${config.force ? " (force)" : useCache ? " (cached)" : ""}`);
+	if (!localVersion && !requestedTag && !isPrerelease(version)) {
+		const nextTag = resolved.distTags?.next ?? resolved.distTags?.beta ?? resolved.distTags?.alpha;
+		if (nextTag) p.log.warn(`\x1B[33mNo local dependency found — using latest stable (${version}). Prerelease ${nextTag.version} available: skilld add ${packageName}@beta\x1B[0m`);
+	}
+	ensureCacheDir();
+	const baseDir = resolveBaseDir(cwd, config.agent, config.global);
+	const skillDirName = config.name ? sanitizeName(config.name) : computeSkillDirName(packageName);
+	const skillDir = config.eject ? typeof config.eject === "string" ? join(resolve(cwd, config.eject), skillDirName) : join(cwd, "skills", skillDirName) : join(baseDir, skillDirName);
+	mkdirSync(skillDir, { recursive: true });
+	const existingLock = config.eject ? void 0 : readLock(baseDir)?.skills[skillDirName];
+	if (existingLock && existingLock.packageName && existingLock.packageName !== packageName) {
+		spin.stop(`Merging ${packageName} into ${skillDirName}`);
+		linkPkgNamed(skillDir, packageName, cwd, version);
+		const repoSlug = resolved.repoUrl?.match(/github\.com\/([^/]+\/[^/]+?)(?:\.git)?(?:[/#]|$)/)?.[1];
+		writeLock(baseDir, skillDirName, {
+			packageName,
+			version,
+			repo: repoSlug,
+			source: existingLock.source,
+			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 relatedSkills = await findRelatedSkills(packageName, baseDir);
+		const pkgFiles = getPkgKeyFiles(existingLock.packageName, cwd, existingLock.version);
+		const shippedDocs = hasShippedDocs(existingLock.packageName, cwd, existingLock.version);
+		const mergeFeatures = readConfig().features ?? defaultFeatures;
+		const skillMd = generateSkillMd({
+			name: existingLock.packageName,
+			version: existingLock.version,
+			relatedSkills,
+			hasIssues: mergeFeatures.issues && existsSync(join(skillDir, ".skilld", "issues")),
+			hasDiscussions: mergeFeatures.discussions && existsSync(join(skillDir, ".skilld", "discussions")),
+			hasReleases: mergeFeatures.releases && existsSync(join(skillDir, ".skilld", "releases")),
+			docsType: existingLock.source?.includes("llms.txt") ? "llms.txt" : "docs",
+			hasShippedDocs: shippedDocs,
+			pkgFiles,
+			dirName: skillDirName,
+			packages: allPackages,
+			features: mergeFeatures
+		});
+		writeFileSync(join(skillDir, "SKILL.md"), skillMd);
+		const mergeShared = !config.global && getSharedSkillsDir(cwd);
+		if (mergeShared) linkSkillToAgents(skillDirName, mergeShared, cwd);
+		if (!config.global) registerProject(cwd);
+		p.outro(`Merged ${packageName} into ${skillDirName}`);
+		return;
+	}
+	const features = readConfig().features ?? defaultFeatures;
+	const resSpin = timedSpinner();
+	resSpin.start("Finding resources");
+	const resources = await fetchAndCacheResources({
+		packageName,
+		resolved,
+		version,
+		useCache,
+		features,
+		from: config.from,
+		onProgress: (msg) => resSpin.message(msg)
+	});
+	const resParts = [];
+	if (resources.docsToIndex.length > 0) {
+		const docCount = resources.docsToIndex.filter((d) => d.metadata?.type === "doc").length;
+		if (docCount > 0) resParts.push(`${docCount} docs`);
+	}
+	if (resources.hasIssues) resParts.push("issues");
+	if (resources.hasDiscussions) resParts.push("discussions");
+	if (resources.hasReleases) resParts.push("releases");
+	resSpin.stop(resources.usedCache ? `Loaded ${resParts.length > 0 ? resParts.join(", ") : "resources"} (cached)` : `Fetched ${resParts.length > 0 ? resParts.join(", ") : "resources"}`);
+	for (const w of resources.warnings) p.log.warn(`\x1B[33m${w}\x1B[0m`);
+	linkAllReferences(skillDir, packageName, cwd, version, resources.docsType, void 0, features, resources.repoInfo);
+	if (features.search) {
+		const idxSpin = timedSpinner();
+		idxSpin.start("Creating search index");
+		await indexResources({
+			packageName,
+			version,
+			cwd,
+			docsToIndex: resources.docsToIndex,
+			features,
+			onProgress: (msg) => idxSpin.message(msg)
+		});
+		idxSpin.stop("Search index ready");
+	}
+	const hasChangelog = detectChangelog(resolvePkgDir(packageName, cwd, version), getCacheDir(packageName, 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];
+	if (!config.eject) linkPkgNamed(skillDir, packageName, cwd, version);
+	if (!config.eject) writeLock(baseDir, skillDirName, {
+		packageName,
+		version,
+		repo: repoSlug,
+		source: resources.docSource,
+		syncedAt: (/* @__PURE__ */ new Date()).toISOString().split("T")[0],
+		generator: "skilld"
+	});
+	const allPackages = parsePackages((config.eject ? void 0 : readLock(baseDir)?.skills[skillDirName])?.packages).map((p) => ({ name: p.name }));
+	const isEject = !!config.eject;
+	const baseSkillMd = generateSkillMd({
+		name: packageName,
+		version,
+		releasedAt: resolved.releasedAt,
+		description: resolved.description,
+		dependencies: resolved.dependencies,
+		distTags: resolved.distTags,
+		relatedSkills,
+		hasIssues: resources.hasIssues,
+		hasDiscussions: resources.hasDiscussions,
+		hasReleases: resources.hasReleases,
+		hasChangelog,
+		docsType: resources.docsType,
+		hasShippedDocs: shippedDocs,
+		pkgFiles,
+		dirName: skillDirName,
+		packages: allPackages.length > 1 ? allPackages : void 0,
+		repoUrl: resolved.repoUrl,
+		features,
+		eject: isEject
+	});
+	writeFileSync(join(skillDir, "SKILL.md"), baseSkillMd);
+	p.log.success(config.mode === "update" ? `Updated skill: ${relative(cwd, skillDir)}` : `Created base skill: ${relative(cwd, skillDir)}`);
+	if (!readConfig().skipLlm && (!config.yes || config.model)) {
+		const llmConfig = await selectLlmConfig(config.model);
+		if (llmConfig) {
+			p.log.step(getModelLabel(llmConfig.model));
+			await enhanceSkillWithLLM({
+				packageName,
+				version,
+				skillDir,
+				dirName: skillDirName,
+				model: llmConfig.model,
+				resolved,
+				relatedSkills,
+				hasIssues: resources.hasIssues,
+				hasDiscussions: resources.hasDiscussions,
+				hasReleases: resources.hasReleases,
+				hasChangelog,
+				docsType: resources.docsType,
+				hasShippedDocs: shippedDocs,
+				pkgFiles,
+				force: config.force,
+				debug: config.debug,
+				sections: llmConfig.sections,
+				customPrompt: llmConfig.customPrompt,
+				packages: allPackages.length > 1 ? allPackages : void 0,
+				features,
+				eject: isEject
+			});
+		}
+	}
+	if (isEject) {
+		const skilldDir = join(skillDir, ".skilld");
+		if (existsSync(skilldDir) && !config.debug) rmSync(skilldDir, {
+			recursive: true,
+			force: true
+		});
+		ejectReferences(skillDir, packageName, cwd, version, resources.docsType, features, resources.repoInfo);
+	}
+	if (!isEject) {
+		const shared = !config.global && getSharedSkillsDir(cwd);
+		if (shared) linkSkillToAgents(skillDirName, shared, cwd);
+		if (!config.global) registerProject(cwd);
+		await ensureGitignore(shared ? SHARED_SKILLS_DIR : targets[config.agent].skillsDir, cwd, config.global);
+		await ensureAgentInstructions(config.agent, cwd, config.global);
+	}
+	await shutdownWorker();
+	const ejectMsg = isEject ? " (ejected)" : "";
+	p.outro(config.mode === "update" ? `Updated ${packageName}${ejectMsg}` : `Synced ${packageName} to ${relative(cwd, skillDir)}${ejectMsg}`);
+}
+const addCommandDef = defineCommand({
+	meta: {
+		name: "add",
+		description: "Add skills for package(s)"
+	},
+	args: {
+		package: {
+			type: "positional",
+			description: "Package(s) to sync (space or comma-separated, e.g., vue nuxt pinia)",
+			required: true
+		},
+		skill: {
+			type: "string",
+			alias: "s",
+			description: "Select specific skills from a git repo (comma-separated)",
+			valueHint: "name"
+		},
+		...sharedArgs
+	},
+	async run({ args }) {
+		const cwd = process.cwd();
+		let agent = resolveAgent(args.agent);
+		if (!agent) {
+			agent = await promptForAgent();
+			if (!agent) return;
+		}
+		if (!hasCompletedWizard()) await runWizard();
+		const rawInputs = [...new Set([args.package, ...args._ || []].map((s) => s.trim()).filter(Boolean))];
+		const gitSources = [];
+		const npmTokens = [];
+		for (const input of rawInputs) {
+			const git = parseGitSkillInput(input);
+			if (git) gitSources.push(git);
+			else npmTokens.push(input);
+		}
+		if (gitSources.length > 0) for (const source of gitSources) {
+			const skillFilter = args.skill ? args.skill.split(/[,\s]+/).map((s) => s.trim()).filter(Boolean) : void 0;
+			await syncGitSkills({
+				source,
+				global: args.global,
+				agent,
+				yes: args.yes,
+				model: args.model,
+				force: args.force,
+				debug: args.debug,
+				skillFilter
+			});
+		}
+		if (npmTokens.length > 0) {
+			const packages = [...new Set(npmTokens.flatMap((s) => s.split(/[,\s]+/)).map((s) => s.trim()).filter(Boolean))];
+			const state = await getProjectState(cwd);
+			p.intro(introLine({ state }));
+			return syncCommand(state, {
+				packages,
+				global: args.global,
+				agent,
+				model: args.model,
+				yes: args.yes,
+				force: args.force,
+				debug: args.debug
+			});
+		}
+	}
+});
+const ejectCommandDef = defineCommand({
+	meta: {
+		name: "eject",
+		description: "Eject skill with references as real files (portable, no symlinks)"
+	},
+	args: {
+		package: {
+			type: "positional",
+			description: "Package to eject",
+			required: true
+		},
+		name: {
+			type: "string",
+			alias: "n",
+			description: "Custom skill directory name (default: derived from package)"
+		},
+		out: {
+			type: "string",
+			alias: "o",
+			description: "Output directory path override"
+		},
+		from: {
+			type: "string",
+			description: "Collect releases/issues/discussions from this date onward (YYYY-MM-DD)"
+		},
+		...sharedArgs
+	},
+	async run({ args }) {
+		const cwd = process.cwd();
+		const agent = resolveAgent(args.agent) || "claude-code";
+		if (!hasCompletedWizard()) await runWizard();
+		const state = await getProjectState(cwd);
+		p.intro(introLine({ state }));
+		return syncCommand(state, {
+			packages: [args.package],
+			global: args.global,
+			agent,
+			model: args.model,
+			yes: args.yes,
+			force: args.force,
+			debug: args.debug,
+			eject: args.out || true,
+			name: args.name,
+			from: args.from
+		});
+	}
+});
+const updateCommandDef = defineCommand({
+	meta: {
+		name: "update",
+		description: "Update outdated skills"
+	},
+	args: {
+		package: {
+			type: "positional",
+			description: "Package(s) to update (space or comma-separated). Without args, syncs all outdated.",
+			required: false
+		},
+		background: {
+			type: "boolean",
+			alias: "b",
+			description: "Run in background (detached process, non-interactive)",
+			default: false
+		},
+		...sharedArgs
+	},
+	async run({ args }) {
+		const cwd = process.cwd();
+		if (args.background) {
+			const { spawn } = await import("node:child_process");
+			const updateArgs = [
+				"update",
+				...args.package ? [args.package] : [],
+				...args.agent ? ["--agent", args.agent] : [],
+				...args.model ? ["--model", args.model] : []
+			];
+			spawn(process.execPath, [process.argv[1], ...updateArgs], {
+				cwd,
+				detached: true,
+				stdio: "ignore"
+			}).unref();
+			return;
+		}
+		const silent = !isInteractive();
+		let agent = resolveAgent(args.agent);
+		if (!agent) {
+			if (silent) return;
+			agent = await promptForAgent();
+			if (!agent) return;
+		}
+		const config = readConfig();
+		const state = await getProjectState(cwd);
+		if (!silent) {
+			const generators = getInstalledGenerators();
+			p.intro(introLine({
+				state,
+				generators,
+				modelId: config.model
+			}));
+		}
+		if (args.package) return syncCommand(state, {
+			packages: [...new Set([args.package, ...args._ || []].flatMap((s) => s.split(/[,\s]+/)).map((s) => s.trim()).filter(Boolean))],
+			global: args.global,
+			agent,
+			model: args.model || (silent ? config.model : void 0),
+			yes: args.yes || silent,
+			force: args.force,
+			debug: args.debug,
+			mode: "update"
+		});
+		if (state.outdated.length === 0) {
+			p.log.success("All skills up to date");
+			return;
+		}
+		return syncCommand(state, {
+			packages: state.outdated.map((s) => s.packageName || s.name),
+			global: args.global,
+			agent,
+			model: args.model || (silent ? config.model : void 0),
+			yes: args.yes || silent,
+			force: args.force,
+			debug: args.debug,
+			mode: "update"
+		});
+	}
+});
+export { DEFAULT_SECTIONS as a, classifyCachedDoc as c, ensureGitignore as d, indexResources as f, selectSkillSections as h, updateCommandDef as i, enhanceSkillWithLLM as l, selectModel as m, ejectCommandDef as n, SKILLD_MARKER_END as o, selectLlmConfig as p, syncCommand as r, SKILLD_MARKER_START as s, addCommandDef as t, ensureAgentInstructions as u };
+
+//# sourceMappingURL=sync.mjs.map