skilld 0.15.4 → 1.0.0

package/dist/cli.mjs

@@ -1,87 +1,20 @@
 #!/usr/bin/env node
-import { a as getRepoCacheDir, i as getPackageDbPath, o as getCacheDir, t as CACHE_DIR } from "./_chunks/config.mjs";
-import { n as sanitizeMarkdown } from "./_chunks/sanitize.mjs";
-import { _ as resolvePkgDir, a as getShippedSkills, f as linkShippedSkill, h as readCachedDocs, i as getPkgKeyFiles, m as listReferenceFiles, o as hasShippedDocs, r as ensureCacheDir, s as isCached, u as linkPkgNamed, y as writeToCache } from "./_chunks/cache.mjs";
+import { i as getPackageDbPath, o as getCacheDir, t as CACHE_DIR } from "./_chunks/config.mjs";
+import "./_chunks/sanitize.mjs";
+import "./_chunks/cache.mjs";
 import "./_chunks/yaml.mjs";
 import "./_chunks/markdown.mjs";
-import { createIndex } from "./retriv/index.mjs";
-import { a as semverGt, n as getSharedSkillsDir, r as mapInsert, t as SHARED_SKILLS_DIR } from "./_chunks/shared.mjs";
-import { C as downloadLlmsDocs, D as normalizeLlmsLinks, G as $fetch, M as resolveEntryFiles, T as fetchLlmsTxt, X as parseGitHubUrl, b as isShallowGitDocs, d as resolvePackageDocs, h as fetchGitDocs, k as fetchGitSkills, r as fetchNpmRegistryMeta, t as fetchLatestVersion, v as fetchReadmeContent, y as filterFrameworkDocs } from "./_chunks/sources.mjs";
-import { _ as targets, g as getAgentVersion, i as linkSkillToAgents, o as unlinkSkillFromAgents, t as generateSkillMd } from "./_chunks/prompts.mjs";
-import { i as getModelLabel, n as createToolProgress, o as optimizeDocs, r as getAvailableModels, t as detectImportedPackages } from "./_chunks/agent.mjs";
-import { C as getRegisteredProjects, E as readConfig, O as unregisterProject, S as defaultFeatures, T as hasConfig, _ as relativeTime, a as mergeLocks, b as sharedArgs, c as removeLockEntry, d as formatStatus, f as getInstalledGenerators, g as promptForAgent, h as isInteractive, i as iterateSkills, k as updateConfig, l as syncLockfilesToDirs, m as introLine, n as getSkillsDir, o as parsePackages, p as getRepoHint, r as isOutdated, s as readLock, t as getProjectState, u as writeLock, v as requireInteractive, w as hasCompletedWizard, x as version, y as resolveAgent } from "./_chunks/skills.mjs";
-import { n as clearEmbeddingCache } from "./_chunks/embedding-cache.mjs";
-import { c as timeAgo, i as formatSource, l as timedSpinner } from "./_chunks/formatting.mjs";
-import { n as shutdownWorker } from "./_chunks/pool.mjs";
-import { a as runWizard, c as SKILLD_MARKER_START, l as classifyCachedDoc, m as selectLlmConfig, p as indexResources, s as SKILLD_MARKER_END } from "./_chunks/sync.mjs";
-import "./_chunks/search.mjs";
-import "./_chunks/search-interactive2.mjs";
-import { homedir } from "node:os";
-import { dirname, join, resolve } from "pathe";
-import { copyFileSync, existsSync, lstatSync, mkdirSync, readFileSync, readdirSync, realpathSync, rmSync, statSync, symlinkSync, unlinkSync, writeFileSync } from "node:fs";
+import { a as semverGt, n as getSharedSkillsDir, r as mapInsert } from "./_chunks/shared.mjs";
+import { r as fetchNpmRegistryMeta, t as fetchLatestVersion } from "./_chunks/sources.mjs";
+import { _ as targets, g as getAgentVersion, o as unlinkSkillFromAgents } from "./_chunks/prompts.mjs";
+import { r as getAvailableModels, t as detectImportedPackages } from "./_chunks/agent.mjs";
+import { A as version, C as introLine, D as requireInteractive, E as relativeTime, F as readConfig, N as hasCompletedWizard, O as resolveAgent, P as hasConfig, R as updateConfig, S as getRepoHint, T as promptForAgent, _ as removeLockEntry, b as formatStatus, c as timeAgo, d as getSkillsDir, f as isOutdated, h as parsePackages, i as formatSource, j as defaultFeatures, k as sharedArgs, l as timedSpinner, p as iterateSkills, u as getProjectState, w as isInteractive, x as getInstalledGenerators } from "./_chunks/formatting.mjs";
+import { join, resolve } from "pathe";
+import { existsSync, readFileSync, readdirSync, realpathSync, rmSync, statSync } from "node:fs";
+import { execSync } from "node:child_process";
 import pLimit from "p-limit";
 import * as p from "@clack/prompts";
 import { defineCommand, runMain } from "citty";
-/**
-* Cache management commands
-*/
-const LLM_CACHE_DIR = join(CACHE_DIR, "llm-cache");
-const LLM_CACHE_MAX_AGE = 10080 * 60 * 1e3;
-async function cacheCleanCommand() {
-	let expiredLlm = 0;
-	let freedBytes = 0;
-	if (existsSync(LLM_CACHE_DIR)) {
-		const now = Date.now();
-		for (const entry of readdirSync(LLM_CACHE_DIR)) {
-			const path = join(LLM_CACHE_DIR, entry);
-			try {
-				const { timestamp } = JSON.parse(readFileSync(path, "utf-8"));
-				if (now - timestamp > LLM_CACHE_MAX_AGE) {
-					const size = statSync(path).size;
-					rmSync(path);
-					expiredLlm++;
-					freedBytes += size;
-				}
-			} catch {
-				const size = statSync(path).size;
-				rmSync(path);
-				expiredLlm++;
-				freedBytes += size;
-			}
-		}
-	}
-	const embeddingDbPath = join(CACHE_DIR, "embeddings.db");
-	let embeddingCleared = false;
-	if (existsSync(embeddingDbPath)) {
-		const size = statSync(embeddingDbPath).size;
-		clearEmbeddingCache();
-		freedBytes += size;
-		embeddingCleared = true;
-	}
-	const freedKB = Math.round(freedBytes / 1024);
-	if (expiredLlm > 0 || embeddingCleared) {
-		const parts = [];
-		if (expiredLlm > 0) parts.push(`${expiredLlm} expired LLM cache entries`);
-		if (embeddingCleared) parts.push("embedding cache");
-		p.log.success(`Removed ${parts.join(" + ")} (${freedKB}KB freed)`);
-	} else p.log.info("Cache is clean — no expired entries");
-}
-const cacheCommandDef = defineCommand({
-	meta: {
-		name: "cache",
-		description: "Cache management",
-		hidden: true
-	},
-	args: { clean: {
-		type: "boolean",
-		description: "Remove expired LLM cache entries",
-		default: true
-	} },
-	async run() {
-		p.intro(`\x1B[1m\x1B[35mskilld\x1B[0m cache clean`);
-		await cacheCleanCommand();
-	}
-});
 async function configCommand() {
 	const config = readConfig();
 	const features = config.features ?? defaultFeatures;
@@ -215,580 +148,6 @@ const configCommandDef = defineCommand({
 		return configCommand();
 	}
 });
-async function installCommand(opts) {
-	const cwd = process.cwd();
-	const agent = targets[opts.agent];
-	const shared = !opts.global && getSharedSkillsDir(cwd);
-	const skillsDir = opts.global ? join(homedir(), ".skilld", "skills") : shared || join(cwd, agent.skillsDir);
-	const allSkillsDirs = shared ? [shared] : Object.values(targets).map((t) => opts.global ? t.globalSkillsDir : join(cwd, t.skillsDir));
-	const allLocks = allSkillsDirs.map((dir) => readLock(dir)).filter((l) => !!l && Object.keys(l.skills).length > 0);
-	if (allLocks.length === 0) {
-		p.log.warn("No skilld-lock.yaml found. Run `skilld` to sync skills first.");
-		return;
-	}
-	const lock = mergeLocks(allLocks);
-	const skills = Object.entries(lock.skills);
-	const toRestore = [];
-	const features = readConfig().features ?? defaultFeatures;
-	for (const [name, info] of skills) {
-		if (!info.version) continue;
-		if (info.source === "shipped") {
-			if (!existsSync(join(skillsDir, name))) toRestore.push({
-				name,
-				info
-			});
-			continue;
-		}
-		const skillDir = join(skillsDir, name);
-		const referencesPath = join(skillDir, ".skilld");
-		const skillMdPath = join(skillDir, "SKILL.md");
-		if (!existsSync(skillDir) || !existsSync(skillMdPath) || !existsSync(referencesPath) || hasStaleReferences(referencesPath, info.packageName || name, info.version, features)) toRestore.push({
-			name,
-			info
-		});
-	}
-	if (toRestore.length === 0) {
-		p.log.success("All up to date");
-		return;
-	}
-	p.log.info(`Restoring ${toRestore.length} references`);
-	ensureCacheDir();
-	const allSkillNames = skills.map(([, info]) => info.packageName || "").filter(Boolean);
-	const regenerated = [];
-	for (const { name, info } of toRestore) {
-		const version = info.version;
-		const pkgName = info.packageName || unsanitizeName(name, info.source);
-		if (info.source === "shipped") {
-			const match = getShippedSkills(pkgName, cwd, version).find((s) => s.skillName === name);
-			if (match) {
-				linkShippedSkill(skillsDir, name, match.skillDir);
-				p.log.success(`Linked ${name}`);
-			} else p.log.warn(`${name}: package ${pkgName} no longer ships this skill`);
-			continue;
-		}
-		if (info.source === "github" || info.source === "gitlab" || info.source === "local") {
-			const match = (await fetchGitSkills({
-				type: info.source,
-				...info.repo?.includes("/") ? {
-					owner: info.repo.split("/")[0],
-					repo: info.repo.split("/")[1]
-				} : {},
-				skillPath: info.path,
-				ref: info.ref,
-				...info.source === "local" ? { localPath: info.repo } : {}
-			})).skills.find((s) => s.name === name);
-			if (match) {
-				const skillDir = join(skillsDir, name);
-				mkdirSync(skillDir, { recursive: true });
-				writeFileSync(join(skillDir, "SKILL.md"), sanitizeMarkdown(match.content));
-				for (const f of match.files) {
-					const filePath = join(skillDir, f.path);
-					mkdirSync(dirname(filePath), { recursive: true });
-					writeFileSync(filePath, f.content);
-				}
-				p.log.success(`Restored ${name} from ${info.repo}`);
-			} else p.log.warn(`${name}: skill not found in ${info.repo}`);
-			continue;
-		}
-		const skillDir = join(skillsDir, name);
-		const referencesPath = join(skillDir, ".skilld");
-		const globalCachePath = getCacheDir(pkgName, version);
-		const spin = timedSpinner();
-		if (isCached(pkgName, version)) {
-			spin.start(`Linking ${name}`);
-			mkdirSync(skillDir, { recursive: true });
-			mkdirSync(referencesPath, { recursive: true });
-			linkPkgSymlink(referencesPath, pkgName, cwd, version);
-			for (const pkg of parsePackages(info.packages)) linkPkgNamed(skillDir, pkg.name, cwd, pkg.version);
-			if (!pkgHasShippedDocs(pkgName, cwd, version) && !isReadmeOnly(globalCachePath)) {
-				const docsLink = join(referencesPath, "docs");
-				const cachedDocs = join(globalCachePath, "docs");
-				if (existsSync(docsLink)) unlinkSync(docsLink);
-				if (existsSync(cachedDocs)) symlinkSync(cachedDocs, docsLink, "junction");
-			}
-			const repoGh = info.repo ? parseGitHubUrl(`https://github.com/${info.repo}`) : null;
-			const repoCachePath = repoGh ? getRepoCacheDir(repoGh.owner, repoGh.repo) : null;
-			if (features.issues) {
-				const issuesLink = join(referencesPath, "issues");
-				const repoIssues = repoCachePath ? join(repoCachePath, "issues") : null;
-				const cachedIssues = repoIssues && existsSync(repoIssues) ? repoIssues : join(globalCachePath, "issues");
-				if (existsSync(issuesLink)) unlinkSync(issuesLink);
-				if (existsSync(cachedIssues)) symlinkSync(cachedIssues, issuesLink, "junction");
-			}
-			if (features.discussions) {
-				const discussionsLink = join(referencesPath, "discussions");
-				const repoDiscussions = repoCachePath ? join(repoCachePath, "discussions") : null;
-				const cachedDiscussions = repoDiscussions && existsSync(repoDiscussions) ? repoDiscussions : join(globalCachePath, "discussions");
-				if (existsSync(discussionsLink)) unlinkSync(discussionsLink);
-				if (existsSync(cachedDiscussions)) symlinkSync(cachedDiscussions, discussionsLink, "junction");
-			}
-			if (features.releases) {
-				const releasesLink = join(referencesPath, "releases");
-				const repoReleases = repoCachePath ? join(repoCachePath, "releases") : null;
-				const cachedReleases = repoReleases && existsSync(repoReleases) ? repoReleases : join(globalCachePath, "releases");
-				if (existsSync(releasesLink)) unlinkSync(releasesLink);
-				if (existsSync(cachedReleases)) symlinkSync(cachedReleases, releasesLink, "junction");
-			}
-			const sectionsLink = join(referencesPath, "sections");
-			const cachedSections = join(globalCachePath, "sections");
-			if (existsSync(sectionsLink)) unlinkSync(sectionsLink);
-			if (existsSync(cachedSections)) symlinkSync(cachedSections, sectionsLink, "junction");
-			if (features.search && !existsSync(getPackageDbPath(pkgName, version))) {
-				spin.message(`Indexing ${name}`);
-				await indexResources({
-					packageName: pkgName,
-					version,
-					cwd,
-					docsToIndex: readCachedDocs(pkgName, version).map((d) => ({
-						id: d.path,
-						content: d.content,
-						metadata: {
-							package: pkgName,
-							source: d.path,
-							type: classifyCachedDoc(d.path).type
-						}
-					})),
-					features,
-					onProgress: (msg) => spin.message(msg)
-				});
-			}
-			if (!copyFromExistingAgent(skillDir, name, allSkillsDirs)) {
-				if (regenerateBaseSkillMd(skillDir, pkgName, version, cwd, allSkillNames, info.source, info.packages)) regenerated.push({
-					name,
-					pkgName,
-					version,
-					skillDir,
-					packages: info.packages
-				});
-			}
-			spin.stop(`Linked ${name}`);
-			continue;
-		}
-		spin.start(`Downloading ${name}@${version}`);
-		const resolved = await resolvePackageDocs(pkgName, { version });
-		if (!resolved) {
-			spin.stop(`Could not resolve: ${name}`);
-			continue;
-		}
-		const cachedDocs = [];
-		const docsToIndex = [];
-		const isFrameworkDoc = (path) => filterFrameworkDocs([path], pkgName).length > 0;
-		if (resolved.gitDocsUrl && resolved.repoUrl) {
-			const gh = parseGitHubUrl(resolved.repoUrl);
-			if (gh) {
-				const gitDocs = await fetchGitDocs(gh.owner, gh.repo, version, pkgName);
-				if (gitDocs?.files.length) {
-					const BATCH_SIZE = 20;
-					for (let i = 0; i < gitDocs.files.length; i += BATCH_SIZE) {
-						const batch = gitDocs.files.slice(i, i + BATCH_SIZE);
-						const results = await Promise.all(batch.map(async (file) => {
-							const content = await $fetch(`${gitDocs.baseUrl}/${file}`, { responseType: "text" }).catch(() => null);
-							if (!content) return null;
-							return {
-								file,
-								content
-							};
-						}));
-						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: pkgName,
-									source: cachePath,
-									type: "doc"
-								}
-							});
-						}
-					}
-					if (isShallowGitDocs(cachedDocs.length) && resolved.llmsUrl) {
-						cachedDocs.length = 0;
-						docsToIndex.length = 0;
-					} else if (cachedDocs.length > 0 && resolved.llmsUrl) {
-						const llmsContent = await fetchLlmsTxt(resolved.llmsUrl);
-						if (llmsContent) {
-							const baseUrl = resolved.docsUrl || new URL(resolved.llmsUrl).origin;
-							cachedDocs.push({
-								path: "llms.txt",
-								content: normalizeLlmsLinks(llmsContent.raw)
-							});
-							if (llmsContent.links.length > 0) {
-								const docs = await downloadLlmsDocs(llmsContent, baseUrl);
-								for (const doc of docs) {
-									if (!isFrameworkDoc(doc.url)) continue;
-									const localPath = doc.url.startsWith("/") ? doc.url.slice(1) : doc.url;
-									cachedDocs.push({
-										path: join("llms-docs", ...localPath.split("/")),
-										content: doc.content
-									});
-								}
-							}
-						}
-					}
-				}
-			}
-		}
-		if (resolved.llmsUrl && cachedDocs.length === 0) {
-			const llmsContent = await fetchLlmsTxt(resolved.llmsUrl);
-			if (llmsContent) {
-				cachedDocs.push({
-					path: "llms.txt",
-					content: normalizeLlmsLinks(llmsContent.raw)
-				});
-				if (llmsContent.links.length > 0) {
-					const docs = await downloadLlmsDocs(llmsContent, resolved.docsUrl || new URL(resolved.llmsUrl).origin);
-					for (const doc of docs) {
-						if (!isFrameworkDoc(doc.url)) continue;
-						const cachePath = join("docs", ...(doc.url.startsWith("/") ? doc.url.slice(1) : doc.url).split("/"));
-						cachedDocs.push({
-							path: cachePath,
-							content: doc.content
-						});
-						docsToIndex.push({
-							id: doc.url,
-							content: doc.content,
-							metadata: {
-								package: pkgName,
-								source: cachePath,
-								type: "doc"
-							}
-						});
-					}
-				}
-			}
-		}
-		if (resolved.readmeUrl && cachedDocs.length === 0) {
-			const content = await fetchReadmeContent(resolved.readmeUrl);
-			if (content) {
-				cachedDocs.push({
-					path: "docs/README.md",
-					content
-				});
-				docsToIndex.push({
-					id: "README.md",
-					content,
-					metadata: {
-						package: pkgName,
-						source: "docs/README.md",
-						type: "doc"
-					}
-				});
-			}
-		}
-		if (cachedDocs.length > 0) {
-			writeToCache(pkgName, version, cachedDocs);
-			mkdirSync(referencesPath, { recursive: true });
-			linkPkgSymlink(referencesPath, pkgName, cwd, version);
-			for (const pkg of parsePackages(info.packages)) linkPkgNamed(skillDir, pkg.name, cwd, pkg.version);
-			if (!isReadmeOnly(globalCachePath)) {
-				const docsLink = join(referencesPath, "docs");
-				const cachedDocsDir = join(globalCachePath, "docs");
-				if (existsSync(docsLink)) unlinkSync(docsLink);
-				if (existsSync(cachedDocsDir)) symlinkSync(cachedDocsDir, docsLink, "junction");
-			}
-			if (features.search) {
-				if (docsToIndex.length > 0) await createIndex(docsToIndex, { dbPath: getPackageDbPath(pkgName, version) });
-				const pkgDir = resolvePkgDir(pkgName, cwd, version);
-				const entryFiles = pkgDir ? await resolveEntryFiles(pkgDir) : [];
-				if (entryFiles.length > 0) await createIndex(entryFiles.map((e) => ({
-					id: e.path,
-					content: e.content,
-					metadata: {
-						package: pkgName,
-						source: `pkg/${e.path}`,
-						type: e.type
-					}
-				})), { dbPath: getPackageDbPath(pkgName, version) });
-			}
-			if (!copyFromExistingAgent(skillDir, name, allSkillsDirs)) {
-				if (regenerateBaseSkillMd(skillDir, pkgName, version, cwd, allSkillNames, info.source, info.packages)) regenerated.push({
-					name,
-					pkgName,
-					version,
-					skillDir,
-					packages: info.packages
-				});
-			}
-			spin.stop(`Downloaded and linked ${name}`);
-		} else spin.stop(`No docs found for ${name}`);
-	}
-	if (regenerated.length > 0 && !readConfig().skipLlm) {
-		const llmConfig = await selectLlmConfig(void 0, `Enhance SKILL.md for ${regenerated.map((r) => r.name).join(", ")}`);
-		if (llmConfig) {
-			p.log.step(getModelLabel(llmConfig.model));
-			for (const { pkgName, version, skillDir, packages: pkgPackages } of regenerated) await enhanceRegenerated(pkgName, version, skillDir, llmConfig.model, llmConfig.sections, llmConfig.customPrompt, pkgPackages);
-		}
-	}
-	for (const [name, info] of Object.entries(lock.skills)) writeLock(skillsDir, name, info);
-	if (shared) for (const [name] of skills) linkSkillToAgents(name, shared, cwd);
-	else syncLockfilesToDirs(lock, allSkillsDirs.filter((d) => d !== skillsDir));
-	await shutdownWorker();
-	p.outro("Install complete");
-}
-/** Copy SKILL.md from another agent's skill dir if one exists */
-function copyFromExistingAgent(skillDir, name, allSkillsDirs) {
-	const targetMd = join(skillDir, "SKILL.md");
-	if (existsSync(targetMd)) return false;
-	for (const dir of allSkillsDirs) {
-		if (dir === skillDir) continue;
-		const candidateMd = join(dir, name, "SKILL.md");
-		if (existsSync(candidateMd) && !lstatSync(candidateMd).isSymbolicLink()) {
-			mkdirSync(skillDir, { recursive: true });
-			copyFileSync(candidateMd, targetMd);
-			return true;
-		}
-	}
-	return false;
-}
-/** Try to recover original package name from sanitized name + source */
-function unsanitizeName(sanitized, source) {
-	if (source?.includes("ungh://")) {
-		const match = source.match(/ungh:\/\/([^/]+)\/(.+)/);
-		if (match) return `@${match[1]}/${match[2]}`;
-	}
-	if (sanitized.startsWith("antfu-")) return `@antfu/${sanitized.slice(6)}`;
-	if (sanitized.startsWith("clack-")) return `@clack/${sanitized.slice(6)}`;
-	if (sanitized.startsWith("nuxt-")) return `@nuxt/${sanitized.slice(5)}`;
-	if (sanitized.startsWith("vue-")) return `@vue/${sanitized.slice(4)}`;
-	if (sanitized.startsWith("vueuse-")) return `@vueuse/${sanitized.slice(7)}`;
-	return sanitized;
-}
-/** Create pkg symlink inside references dir (links to entire package or cached dist) */
-function linkPkgSymlink(referencesDir, name, cwd, version) {
-	const pkgPath = resolvePkgDir(name, cwd, version);
-	if (!pkgPath) return;
-	const pkgLink = join(referencesDir, "pkg");
-	if (existsSync(pkgLink)) unlinkSync(pkgLink);
-	symlinkSync(pkgPath, pkgLink, "junction");
-}
-/** Check if cache only has docs/README.md (pkg/ already has this) */
-function isReadmeOnly(cacheDir) {
-	const docsDir = join(cacheDir, "docs");
-	if (!existsSync(docsDir)) return false;
-	const files = readdirSync(docsDir);
-	return files.length === 1 && files[0] === "README.md";
-}
-/** Check if package ships its own docs folder */
-function pkgHasShippedDocs(name, cwd, version) {
-	const pkgPath = resolvePkgDir(name, cwd, version);
-	if (!pkgPath) return false;
-	for (const candidate of [
-		"docs",
-		"documentation",
-		"doc"
-	]) if (existsSync(join(pkgPath, candidate))) return true;
-	return false;
-}
-/** Run LLM enhancement on a regenerated SKILL.md */
-async function enhanceRegenerated(pkgName, version, skillDir, model, sections, customPrompt, packages) {
-	const llmLog = p.taskLog({ title: `Agent exploring ${pkgName}` });
-	const docFiles = listReferenceFiles(skillDir);
-	const globalCachePath = getCacheDir(pkgName, version);
-	const hasIssues = existsSync(join(globalCachePath, "issues"));
-	const hasDiscussions = existsSync(join(globalCachePath, "discussions"));
-	const hasGithub = hasIssues || hasDiscussions;
-	const hasReleases = existsSync(join(globalCachePath, "releases"));
-	const features = readConfig().features ?? defaultFeatures;
-	const { optimized, wasOptimized } = await optimizeDocs({
-		packageName: pkgName,
-		skillDir,
-		model,
-		version,
-		hasGithub,
-		hasReleases,
-		docFiles,
-		sections,
-		customPrompt,
-		features,
-		pkgFiles: getPkgKeyFiles(pkgName, process.cwd(), version),
-		onProgress: createToolProgress(llmLog)
-	});
-	if (wasOptimized) {
-		llmLog.success("Generated best practices");
-		const cwd = process.cwd();
-		const pkgPath = resolvePkgDir(pkgName, cwd, version);
-		let description;
-		let dependencies;
-		if (pkgPath) {
-			const pkgJsonPath = join(pkgPath, "package.json");
-			if (existsSync(pkgJsonPath)) {
-				const pkg = JSON.parse(readFileSync(pkgJsonPath, "utf-8"));
-				description = pkg.description;
-				dependencies = pkg.dependencies;
-			}
-		}
-		let docsType = "docs";
-		if (existsSync(join(globalCachePath, "docs", "llms.txt"))) docsType = "llms.txt";
-		else if (isReadmeOnly(globalCachePath)) docsType = "readme";
-		const dirName = skillDir.split("/").pop();
-		const allPackages = parsePackages(packages).map((p) => ({ name: p.name }));
-		const skillMd = generateSkillMd({
-			name: pkgName,
-			version,
-			description,
-			dependencies,
-			body: optimized,
-			relatedSkills: [],
-			hasIssues,
-			hasDiscussions,
-			hasReleases,
-			docsType,
-			hasShippedDocs: hasShippedDocs(pkgName, cwd, version),
-			pkgFiles: getPkgKeyFiles(pkgName, cwd, version),
-			dirName,
-			packages: allPackages.length > 1 ? allPackages : void 0,
-			features
-		});
-		writeFileSync(join(skillDir, "SKILL.md"), skillMd);
-	} else llmLog.error("LLM optimization skipped");
-}
-const installCommandDef = defineCommand({
-	meta: {
-		name: "install",
-		description: "Restore references from lockfile"
-	},
-	args: {
-		global: sharedArgs.global,
-		agent: sharedArgs.agent
-	},
-	async run({ args }) {
-		let agent = resolveAgent(args.agent);
-		if (!agent) {
-			agent = await promptForAgent();
-			if (!agent) return;
-		}
-		p.intro(`\x1B[1m\x1B[35mskilld\x1B[0m install`);
-		return installCommand({
-			global: args.global,
-			agent
-		});
-	}
-});
-/** Regenerate base SKILL.md from local metadata if missing */
-function regenerateBaseSkillMd(skillDir, pkgName, version, cwd, allSkillNames, source, packages) {
-	const skillMdPath = join(skillDir, "SKILL.md");
-	if (existsSync(skillMdPath)) return false;
-	const pkgPath = resolvePkgDir(pkgName, cwd, version);
-	let description;
-	let dependencies;
-	if (pkgPath) {
-		const pkgJsonPath = join(pkgPath, "package.json");
-		if (existsSync(pkgJsonPath)) {
-			const pkg = JSON.parse(readFileSync(pkgJsonPath, "utf-8"));
-			description = pkg.description;
-			dependencies = pkg.dependencies;
-		}
-	}
-	const globalCachePath = getCacheDir(pkgName, version);
-	let docsType = "docs";
-	if (source?.includes("llms.txt") || existsSync(join(globalCachePath, "docs", "llms.txt"))) docsType = "llms.txt";
-	else if (isReadmeOnly(globalCachePath)) docsType = "readme";
-	const feat = readConfig().features ?? defaultFeatures;
-	const hasIssues = feat.issues && existsSync(join(globalCachePath, "issues"));
-	const hasDiscussions = feat.discussions && existsSync(join(globalCachePath, "discussions"));
-	const hasReleases = feat.releases && existsSync(join(globalCachePath, "releases"));
-	const relatedSkills = allSkillNames.filter((n) => n !== pkgName);
-	const dirName = skillDir.split("/").pop();
-	const allPackages = parsePackages(packages).map((p) => ({ name: p.name }));
-	const content = generateSkillMd({
-		name: pkgName,
-		version,
-		description,
-		dependencies,
-		relatedSkills,
-		hasIssues,
-		hasDiscussions,
-		hasReleases,
-		docsType,
-		hasShippedDocs: hasShippedDocs(pkgName, cwd, version),
-		pkgFiles: getPkgKeyFiles(pkgName, cwd, version),
-		dirName,
-		packages: allPackages.length > 1 ? allPackages : void 0,
-		features: readConfig().features ?? defaultFeatures
-	});
-	mkdirSync(skillDir, { recursive: true });
-	writeFileSync(skillMdPath, content);
-	return true;
-}
-/** Check if .skilld/ has broken symlinks or is missing expected references from global cache */
-function hasStaleReferences(referencesPath, pkgName, version, features) {
-	for (const entry of readdirSync(referencesPath)) {
-		const entryPath = join(referencesPath, entry);
-		if (lstatSync(entryPath).isSymbolicLink() && !existsSync(entryPath)) return true;
-	}
-	if (!existsSync(join(referencesPath, "pkg"))) return true;
-	const globalCachePath = getCacheDir(pkgName, version);
-	const expected = [
-		["docs", existsSync(join(globalCachePath, "docs"))],
-		["issues", features.issues && existsSync(join(globalCachePath, "issues"))],
-		["discussions", features.discussions && existsSync(join(globalCachePath, "discussions"))],
-		["releases", features.releases && existsSync(join(globalCachePath, "releases"))],
-		["sections", existsSync(join(globalCachePath, "sections"))]
-	];
-	for (const [name, shouldExist] of expected) if (shouldExist && !existsSync(join(referencesPath, name))) return true;
-	return false;
-}
-function listCommand(opts = {}) {
-	const skills = [...iterateSkills({ scope: opts.global ? "global" : "all" })];
-	const seen = /* @__PURE__ */ new Set();
-	const entries = [];
-	for (const skill of skills) {
-		const key = skill.info?.packageName || skill.name;
-		if (seen.has(key)) continue;
-		seen.add(key);
-		entries.push({
-			name: skill.name,
-			version: skill.info?.version || "",
-			source: formatSource(skill.info?.source),
-			synced: timeAgo(skill.info?.syncedAt)
-		});
-	}
-	if (opts.json) {
-		process.stdout.write(`${JSON.stringify(entries)}\n`);
-		return;
-	}
-	if (entries.length === 0) {
-		process.stdout.write("No skills installed\n");
-		return;
-	}
-	const nameW = Math.max(...entries.map((e) => e.name.length));
-	const verW = Math.max(...entries.map((e) => e.version.length));
-	const srcW = Math.max(...entries.map((e) => e.source.length));
-	for (const e of entries) {
-		const line = [
-			e.name.padEnd(nameW),
-			e.version.padEnd(verW),
-			e.source.padEnd(srcW),
-			e.synced
-		].join("  ");
-		process.stdout.write(`${line}\n`);
-	}
-}
-const listCommandDef = defineCommand({
-	meta: {
-		name: "list",
-		description: "List installed skills"
-	},
-	args: {
-		global: sharedArgs.global,
-		json: {
-			type: "boolean",
-			description: "Output as JSON",
-			default: false
-		}
-	},
-	run({ args }) {
-		return listCommand({
-			global: args.global,
-			json: args.json
-		});
-	}
-});
 async function removeCommand(state, opts) {
 	const scope = opts.global ? "global" : "local";
 	const allSkills = [...iterateSkills({ scope })];
@@ -1050,194 +409,98 @@ const infoCommandDef = defineCommand({
 		return statusCommand({ global: args.global });
 	}
 });
-/**
-* Remove the skilld marker block from an agent's instruction file.
-*/
-function removeAgentInstructions(agent, projectPath) {
-	const agentConfig = targets[agent];
-	if (!agentConfig.instructionFile) return false;
-	const filePath = join(projectPath, agentConfig.instructionFile);
-	if (!existsSync(filePath)) return false;
-	const content = readFileSync(filePath, "utf-8");
-	const startIdx = content.indexOf(SKILLD_MARKER_START);
-	if (startIdx === -1) return false;
-	const endIdx = content.indexOf(SKILLD_MARKER_END, startIdx);
-	if (endIdx === -1) return false;
-	const before = content.slice(0, startIdx).replace(/\n+$/, "");
-	const after = content.slice(endIdx + SKILLD_MARKER_END.length).replace(/^\n+/, "");
-	const updated = before + (before && after ? "\n" : "") + after;
-	if (updated.trim() === "") rmSync(filePath);
-	else writeFileSync(filePath, updated.endsWith("\n") ? updated : `${updated}\n`);
-	return true;
-}
-/**
-* Uninstall skilld skills by scope:
-* - project: Remove project skills (cwd)
-* - all: All registered projects + global skills + cache
-*/
-async function uninstallCommand(opts) {
-	let scope = opts.scope;
-	const registeredProjects = getRegisteredProjects();
-	if (!scope) if (!isInteractive()) scope = "project";
-	else {
-		const allHint = registeredProjects.length > 0 ? `${registeredProjects.length} projects + global + cache` : "global skills + cache";
-		const selected = await p.select({
-			message: "What do you want to uninstall?",
-			options: [{
-				label: "This project",
-				value: "project",
-				hint: "current project only"
-			}, {
-				label: "Everything",
-				value: "all",
-				hint: allHint
-			}]
-		});
-		if (p.isCancel(selected)) {
-			p.cancel("Cancelled");
-			return;
-		}
-		scope = selected;
+function hasGhCli() {
+	if (process.env.SKILLD_NO_GH) return false;
+	try {
+		execSync("gh --version", { stdio: "ignore" });
+		return true;
+	} catch {
+		return false;
 	}
-	const toRemove = [];
-	const seenPaths = /* @__PURE__ */ new Set();
-	const projectsToUnregister = [];
-	const agentFilter = opts.agent ? [opts.agent] : void 0;
-	const addToRemove = (label, path, version) => {
-		if (seenPaths.has(path)) return;
-		seenPaths.add(path);
-		toRemove.push({
-			label,
-			path,
-			version
-		});
-	};
-	const addSkillsFromLock = (skillsDir, label) => {
-		const trackedNames = [];
-		const lock = readLock(skillsDir);
-		if (lock?.skills) {
-			for (const [skillName, info] of Object.entries(lock.skills)) {
-				trackedNames.push(skillName);
-				const skillDir = join(skillsDir, skillName);
-				if (existsSync(skillDir)) {
-					const version = info.version ? `${info.version.split(".").slice(0, 2).join(".")}.x` : void 0;
-					addToRemove(`${label}: ${skillName}`, skillDir, version);
-				}
+}
+async function runWizard() {
+	if (!isInteractive()) return;
+	p.note("Skilld gives your AI agent skill knowledge on your NPM\ndependencies gathered from versioned docs, source code\nand GitHub issues.", "Welcome to skilld");
+	const ghInstalled = hasGhCli();
+	if (ghInstalled) p.log.success("GitHub CLI detected — will use it to pull issues and discussions.");
+	else p.log.warn("GitHub CLI not found. Install it to enable issues/discussions:\n  \x1B[36mhttps://cli.github.com\x1B[0m");
+	const selected = await p.multiselect({
+		message: "Which features would you like to enable?",
+		options: [
+			{
+				label: "Semantic + token search",
+				value: "search",
+				hint: "local query engine to cut token costs and speed up grep"
+			},
+			{
+				label: "Release notes",
+				value: "releases",
+				hint: "track changelogs for installed packages"
+			},
+			{
+				label: "GitHub issues",
+				value: "issues",
+				hint: "surface common problems and solutions",
+				disabled: !ghInstalled
+			},
+			{
+				label: "GitHub discussions",
+				value: "discussions",
+				hint: "include Q&A and community knowledge",
+				disabled: !ghInstalled
 			}
-			const lockPath = join(skillsDir, "skilld-lock.yaml");
-			if (existsSync(lockPath)) addToRemove(`${label}: skilld-lock.yaml`, lockPath);
-		}
-		return trackedNames;
-	};
-	const findUntrackedSkills = (skillsDir, trackedNames) => {
-		if (!existsSync(skillsDir)) return [];
-		const tracked = new Set(trackedNames);
-		return readdirSync(skillsDir).filter((f) => !f.startsWith(".") && f !== "skilld-lock.yaml" && !tracked.has(f));
+		],
+		initialValues: [...Object.entries(defaultFeatures).filter(([, v]) => v).map(([k]) => k), ...ghInstalled ? ["issues", "discussions"] : []],
+		required: false
+	});
+	if (p.isCancel(selected)) {
+		p.cancel("Setup cancelled");
+		process.exit(0);
+	}
+	const features = {
+		search: selected.includes("search"),
+		issues: selected.includes("issues"),
+		discussions: selected.includes("discussions"),
+		releases: selected.includes("releases")
 	};
-	const untrackedByDir = /* @__PURE__ */ new Map();
-	const processedDirs = /* @__PURE__ */ new Set();
-	const processSkillsDir = (skillsDir, label) => {
-		if (processedDirs.has(skillsDir)) return;
-		processedDirs.add(skillsDir);
-		const untracked = findUntrackedSkills(skillsDir, addSkillsFromLock(skillsDir, label));
-		if (untracked.length > 0) untrackedByDir.set(skillsDir, {
-			label,
-			skills: untracked
+	const allModels = process.env.SKILLD_NO_AGENTS ? [] : await getAvailableModels();
+	let modelId;
+	if (allModels.length > 0) {
+		p.note("Skills work without an LLM, but one can rewrite your\nSKILL.md files with best practices and better structure.\n\x1B[90mThis is separate from the agent where skills are installed —\nthe target agent is auto-detected from your project files.\x1B[0m", "Optional: LLM optimization");
+		const modelChoice = await p.select({
+			message: "Model for generating SKILL.md",
+			options: [{
+				label: "Skip",
+				value: "",
+				hint: "use raw docs, no LLM needed"
+			}, ...allModels.map((m) => ({
+				label: m.recommended ? `${m.name} (Recommended)` : m.name,
+				value: m.id,
+				hint: `${m.agentName} · ${m.hint}`
+			}))]
 		});
-	};
-	if (scope === "project") {
-		const sharedDir = join(process.cwd(), SHARED_SKILLS_DIR);
-		if (existsSync(sharedDir)) processSkillsDir(sharedDir, "project (.skills)");
-		for (const [name, agent] of Object.entries(targets)) {
-			if (agentFilter && !agentFilter.includes(name)) continue;
-			processSkillsDir(join(process.cwd(), agent.skillsDir), "project");
-		}
-		projectsToUnregister.push(process.cwd());
-	}
-	if (scope === "all") {
-		const projectPaths = registeredProjects.length > 0 ? registeredProjects : [process.cwd()];
-		if (registeredProjects.length > 0) {
-			p.log.info("Projects to uninstall from:");
-			for (const proj of projectPaths) p.log.message(`  ${proj}`);
-		}
-		for (const projectPath of projectPaths) {
-			if (!existsSync(projectPath)) continue;
-			const shortPath = projectPath.replace(process.env.HOME || "", "~");
-			const sharedDir = join(projectPath, SHARED_SKILLS_DIR);
-			if (existsSync(sharedDir)) processSkillsDir(sharedDir, `${shortPath} (.skills)`);
-			for (const [name, agent] of Object.entries(targets)) {
-				if (agentFilter && !agentFilter.includes(name)) continue;
-				processSkillsDir(join(projectPath, agent.skillsDir), shortPath);
-			}
-			projectsToUnregister.push(projectPath);
-		}
-		for (const [name, agent] of Object.entries(targets)) {
-			if (agentFilter && !agentFilter.includes(name)) continue;
-			if (!agent.globalSkillsDir) continue;
-			processSkillsDir(agent.globalSkillsDir, "user");
-		}
-		if (existsSync(CACHE_DIR)) addToRemove("~/.skilld cache", CACHE_DIR);
-	}
-	if (untrackedByDir.size > 0) {
-		const groupedUntracked = /* @__PURE__ */ new Map();
-		for (const [_dir, { label, skills }] of untrackedByDir) {
-			const set = mapInsert(groupedUntracked, label, () => /* @__PURE__ */ new Set());
-			for (const s of skills) set.add(s);
-		}
-		const totalUntracked = [...groupedUntracked.values()].reduce((sum, s) => sum + s.size, 0);
-		p.log.warn(`${totalUntracked} untracked skill(s) will remain (not managed by skilld):`);
-		for (const [label, skills] of groupedUntracked) p.log.message(`  ${label}: ${[...skills].join(", ")}`);
-	}
-	if (toRemove.length === 0) {
-		p.log.info("Nothing to uninstall");
-		return;
-	}
-	const groups = /* @__PURE__ */ new Map();
-	for (const item of toRemove) {
-		const [prefix, name] = item.label.includes(": ") ? item.label.split(": ", 2) : ["other", item.label];
-		mapInsert(groups, prefix, () => []).push({
-			name,
-			version: item.version
+		if (p.isCancel(modelChoice)) {
+			p.cancel("Setup cancelled");
+			process.exit(0);
+		}
+		modelId = modelChoice || void 0;
+	} else {
+		p.log.warn("No supported LLM CLIs detected (claude, gemini, codex).\n  Skills will still work, but won't be LLM-optimized.");
+		const proceed = await p.confirm({
+			message: "Continue without LLM optimization?",
+			initialValue: true
 		});
-	}
-	const formatGroup = (items) => items.map((i) => i.version ? `${i.name}@${i.version}` : i.name).join(", ");
-	p.log.info(`Will remove ${toRemove.length} items:`);
-	for (const [prefix, items] of groups) p.log.message(`  ${prefix}: ${formatGroup(items)}`);
-	if (!opts.yes && isInteractive()) {
-		const confirmed = await p.confirm({ message: "Proceed with uninstall?" });
-		if (p.isCancel(confirmed) || !confirmed) {
-			p.cancel("Cancelled");
-			return;
+		if (p.isCancel(proceed) || !proceed) {
+			p.cancel("Setup cancelled");
+			process.exit(0);
 		}
 	}
-	for (const item of toRemove) rmSync(item.path, {
-		recursive: true,
-		force: true
+	updateConfig({
+		features,
+		...modelId ? { model: modelId } : { skipLlm: true }
 	});
-	for (const [prefix, items] of groups) p.log.success(`Removed ${prefix}: ${formatGroup(items)}`);
-	const agentTypes = agentFilter || Object.keys(targets);
-	for (const proj of projectsToUnregister) for (const agent of agentTypes) if (removeAgentInstructions(agent, proj)) {
-		const file = targets[agent].instructionFile;
-		p.log.success(`Cleaned ${file}`);
-	}
-	if (scope !== "all") for (const proj of projectsToUnregister) unregisterProject(proj);
-	p.outro("skilld uninstalled");
+	p.outro("Thanks, you're all set! Change config anytime with `skilld config`.");
 }
-const uninstallCommandDef = defineCommand({
-	meta: {
-		name: "uninstall",
-		description: "Remove skilld data"
-	},
-	args: { ...sharedArgs },
-	async run({ args }) {
-		p.intro(`\x1B[1m\x1B[35mskilld\x1B[0m uninstall`);
-		return uninstallCommand({
-			scope: args.global ? "all" : void 0,
-			agent: args.agent,
-			yes: args.yes
-		});
-	}
-});
 const _emit = process.emit;
 process.emit = (event, ...args) => event === "warning" && args[0]?.name === "ExperimentalWarning" && args[0]?.message?.includes("SQLite") ? false : _emit.apply(process, [event, ...args]);
 const NOISE_CHARS = "⣿⡿⣷⣾⣽⣻⢿⡷⣯⣟⡾⣵⣳⢾⡽⣞⡷⣝⢯";
@@ -1352,13 +615,13 @@ runMain(defineCommand({
 		add: () => import("./_chunks/sync2.mjs").then((m) => m.addCommandDef),
 		eject: () => import("./_chunks/sync2.mjs").then((m) => m.ejectCommandDef),
 		update: () => import("./_chunks/sync2.mjs").then((m) => m.updateCommandDef),
-		info: () => import("./_chunks/status.mjs").then((m) => m.infoCommandDef),
+		info: () => infoCommandDef,
 		list: () => import("./_chunks/list.mjs").then((m) => m.listCommandDef),
-		config: () => import("./_chunks/config2.mjs").then((m) => m.configCommandDef),
-		remove: () => import("./_chunks/remove.mjs").then((m) => m.removeCommandDef),
+		config: () => configCommandDef,
+		remove: () => removeCommandDef,
 		install: () => import("./_chunks/install.mjs").then((m) => m.installCommandDef),
 		uninstall: () => import("./_chunks/uninstall.mjs").then((m) => m.uninstallCommandDef),
-		search: () => import("./_chunks/search2.mjs").then((m) => m.searchCommandDef),
+		search: () => import("./_chunks/search.mjs").then((m) => m.searchCommandDef),
 		cache: () => import("./_chunks/cache2.mjs").then((m) => m.cacheCommandDef),
 		validate: () => import("./_chunks/validate.mjs").then((m) => m.validateCommandDef)
 	},
@@ -1718,6 +981,6 @@ runMain(defineCommand({
 		}
 	}
 }));
-export { removeCommand as a, listCommandDef as c, configCommand as d, configCommandDef as f, statusCommand as i, installCommand as l, cacheCommandDef as m, uninstallCommandDef as n, removeCommandDef as o, cacheCleanCommand as p, infoCommandDef as r, listCommand as s, uninstallCommand as t, installCommandDef as u };
+export { runWizard as t };
 
 //# sourceMappingURL=cli.mjs.map