skilld 0.0.1 → 0.1.2

package/dist/cli.mjs

@@ -1,503 +1,2704 @@
 #!/usr/bin/env node
-import { generateSkill } from "./index.mjs";
-import { getInstalledSkillVersion, readLocalDependencies, resolvePackageDocs } from "./npm.mjs";
-import { agents, detectCurrentAgent, generateSkillMd, installSkillForAgents, sanitizeName } from "./agents.mjs";
-import { join } from "node:path";
-import { defineCommand, runMain } from "citty";
-import consola from "consola";
+import { a as getCacheDir, i as getPackageDbPath, n as REFERENCES_DIR, s as getVersionKey, t as CACHE_DIR } from "./_chunks/config.mjs";
+import { _ as writeToCache, a as getShippedSkills, c as linkGithub, d as linkReleases, f as linkShippedSkill, g as resolvePkgDir, h as readCachedDocs, i as getPkgKeyFiles, l as linkPkg, m as listReferenceFiles, n as clearCache, o as hasShippedDocs, r as ensureCacheDir, s as isCached, u as linkReferences } from "./_chunks/storage.mjs";
+import "./cache/index.mjs";
+import { createIndex, searchSnippets } from "./retriv/index.mjs";
+import { A as resolveEntryFiles, E as parseGitHubUrl, F as isGhAvailable, M as formatDiscussionsAsMarkdown, N as fetchGitHubIssues, P as formatIssuesAsMarkdown, S as fetchReadmeContent, _ as normalizeLlmsLinks, a as fetchPkgDist, c as readLocalDependencies, d as resolvePackageDocs, f as resolvePackageDocsWithAttempts, h as fetchLlmsTxt, i as fetchNpmRegistryMeta, j as fetchGitHubDiscussions, n as fetchLatestVersion, p as downloadLlmsDocs, r as fetchNpmPackage, t as fetchReleaseNotes, u as resolveLocalPackageDocs, y as fetchGitDocs } from "./_chunks/releases.mjs";
+import "./sources/index.mjs";
+import { c as sanitizeName, d as detectTargetAgent, f as getAgentVersion, i as generateSkillMd, l as detectImportedPackages, n as getModelName, p as agents, r as optimizeDocs, t as getAvailableModels, u as detectInstalledAgents } from "./_chunks/llm.mjs";
+import "./agent/index.mjs";
+import { createRequire } from "node:module";
+import { homedir } from "node:os";
+import { join, relative, resolve } from "node:path";
+import { appendFileSync, existsSync, lstatSync, mkdirSync, readFileSync, readdirSync, realpathSync, rmSync, statSync, symlinkSync, unlinkSync, writeFileSync } from "node:fs";
 import { execSync } from "node:child_process";
-async function getAvailableModels() {
-	const models = [];
-	if ((() => {
+import * as p from "@clack/prompts";
+import { defineCommand, runMain } from "citty";
+import pLimit from "p-limit";
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+const defaultFeatures = {
+	search: true,
+	issues: false,
+	discussions: false,
+	releases: true
+};
+const CONFIG_DIR = join(homedir(), ".skilld");
+const CONFIG_PATH = join(CONFIG_DIR, "config.yaml");
+function hasConfig() {
+	return existsSync(CONFIG_PATH);
+}
+function readConfig() {
+	if (!existsSync(CONFIG_PATH)) return {};
+	const content = readFileSync(CONFIG_PATH, "utf-8");
+	const config = {};
+	let inBlock = null;
+	const projects = [];
+	const features = {};
+	for (const line of content.split("\n")) {
+		if (line.startsWith("projects:")) {
+			inBlock = "projects";
+			continue;
+		}
+		if (line.startsWith("features:")) {
+			inBlock = "features";
+			continue;
+		}
+		if (inBlock === "projects") {
+			if (line.startsWith("  - ")) {
+				projects.push(line.slice(4).trim().replace(/^["']|["']$/g, ""));
+				continue;
+			}
+			inBlock = null;
+		}
+		if (inBlock === "features") {
+			const m = line.match(/^ {2}(\w+):\s*(.+)/);
+			if (m) {
+				const key = m[1];
+				if (key in defaultFeatures) features[key] = m[2] === "true";
+				continue;
+			}
+			inBlock = null;
+		}
+		const [key, ...rest] = line.split(":");
+		const value = rest.join(":").trim().replace(/^["']|["']$/g, "");
+		if (key === "model" && value) config.model = value;
+		if (key === "agent" && value) config.agent = value;
+		if (key === "skipLlm") config.skipLlm = value === "true";
+	}
+	if (projects.length > 0) config.projects = projects;
+	if (Object.keys(features).length > 0) config.features = {
+		...defaultFeatures,
+		...features
+	};
+	return config;
+}
+function writeConfig(config) {
+	mkdirSync(CONFIG_DIR, { recursive: true });
+	let yaml = "";
+	if (config.model) yaml += `model: ${config.model}\n`;
+	if (config.agent) yaml += `agent: ${config.agent}\n`;
+	if (config.skipLlm) yaml += `skipLlm: true\n`;
+	if (config.features) {
+		yaml += "features:\n";
+		for (const [k, v] of Object.entries(config.features)) yaml += `  ${k}: ${v}\n`;
+	}
+	if (config.projects?.length) {
+		yaml += "projects:\n";
+		for (const p of config.projects) yaml += `  - ${p}\n`;
+	}
+	writeFileSync(CONFIG_PATH, yaml);
+}
+function updateConfig(updates) {
+	writeConfig({
+		...readConfig(),
+		...updates
+	});
+}
+function registerProject(projectPath) {
+	const config = readConfig();
+	const projects = new Set(config.projects || []);
+	projects.add(projectPath);
+	writeConfig({
+		...config,
+		projects: [...projects]
+	});
+}
+function unregisterProject(projectPath) {
+	const config = readConfig();
+	const projects = (config.projects || []).filter((p) => p !== projectPath);
+	writeConfig({
+		...config,
+		projects
+	});
+}
+function getRegisteredProjects() {
+	return readConfig().projects || [];
+}
+async function configCommand() {
+	const config = readConfig();
+	const features = config.features ?? defaultFeatures;
+	const enabledCount = Object.values(features).filter(Boolean).length;
+	const action = await p.select({
+		message: "Settings",
+		options: [
+			{
+				label: "Change features",
+				value: "features",
+				hint: `${enabledCount}/4 enabled`
+			},
+			{
+				label: "Change model",
+				value: "model",
+				hint: config.model || "auto"
+			},
+			{
+				label: "Change agent",
+				value: "agent",
+				hint: config.agent || "auto-detect"
+			}
+		]
+	});
+	if (p.isCancel(action)) {
+		p.cancel("Cancelled");
+		return;
+	}
+	switch (action) {
+		case "features": {
+			const selected = await p.multiselect({
+				message: "Enable features",
+				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"
+					},
+					{
+						label: "GitHub discussions",
+						value: "discussions",
+						hint: "include Q&A and community knowledge"
+					}
+				].map((f) => ({
+					label: f.label,
+					value: f.value,
+					hint: f.hint
+				})),
+				initialValues: Object.entries(features).filter(([, v]) => v).map(([k]) => k),
+				required: false
+			});
+			if (p.isCancel(selected)) return;
+			updateConfig({ features: {
+				search: selected.includes("search"),
+				issues: selected.includes("issues"),
+				discussions: selected.includes("discussions"),
+				releases: selected.includes("releases")
+			} });
+			p.log.success(`Features updated: ${selected.length} enabled`);
+			break;
+		}
+		case "model": {
+			const available = await getAvailableModels();
+			if (available.length === 0) {
+				p.log.warn("No LLM CLIs found");
+				return;
+			}
+			const model = await p.select({
+				message: "Select default model",
+				options: [{
+					label: "Auto (prompt each time)",
+					value: ""
+				}, ...available.map((m) => ({
+					label: m.recommended ? `${m.name} (Recommended)` : m.name,
+					value: m.id,
+					hint: m.hint
+				}))],
+				initialValue: config.model || ""
+			});
+			if (p.isCancel(model)) return;
+			updateConfig({ model: model || void 0 });
+			p.log.success(model ? `Default model set to ${model}` : "Model will be prompted each time");
+			break;
+		}
+		case "agent": {
+			const agentChoice = await p.select({
+				message: "Select default agent",
+				options: [{
+					label: "Auto-detect",
+					value: ""
+				}, ...Object.entries(agents).map(([id, a]) => ({
+					label: a.displayName,
+					value: id,
+					hint: a.skillsDir
+				}))],
+				initialValue: config.agent || ""
+			});
+			if (p.isCancel(agentChoice)) return;
+			updateConfig({ agent: agentChoice || void 0 });
+			p.log.success(agentChoice ? `Default agent set to ${agentChoice}` : "Agent will be auto-detected");
+			break;
+		}
+	}
+}
+function parseSkillFrontmatter(skillPath) {
+	if (!existsSync(skillPath)) return null;
+	const match = readFileSync(skillPath, "utf-8").match(/^---\n([\s\S]*?)\n---/);
+	if (!match) return null;
+	const info = {};
+	const lines = match[1].split("\n");
+	for (const line of lines) {
+		const [key, ...rest] = line.split(":");
+		const value = rest.join(":").trim().replace(/^["']|["']$/g, "");
+		if (key === "packageName") info.packageName = value;
+		if (key === "version") info.version = value;
+		if (key === "source") info.source = value;
+		if (key === "syncedAt") info.syncedAt = value;
+		if (key === "generator") info.generator = value;
+	}
+	return info;
+}
+function readLock(skillsDir) {
+	const lockPath = join(skillsDir, "skilld-lock.yaml");
+	if (!existsSync(lockPath)) return null;
+	const content = readFileSync(lockPath, "utf-8");
+	const skills = {};
+	let currentSkill = null;
+	for (const line of content.split("\n")) {
+		const skillMatch = line.match(/^ {2}(\S+):$/);
+		if (skillMatch) {
+			currentSkill = skillMatch[1];
+			skills[currentSkill] = {};
+			continue;
+		}
+		if (currentSkill && line.startsWith("    ")) {
+			const [key, ...rest] = line.trim().split(":");
+			const value = rest.join(":").trim().replace(/^["']|["']$/g, "");
+			if (key && value) skills[currentSkill][key] = value;
+		}
+	}
+	return { skills };
+}
+function writeLock(skillsDir, skillName, info) {
+	const lockPath = join(skillsDir, "skilld-lock.yaml");
+	let lock = { skills: {} };
+	if (existsSync(lockPath)) lock = readLock(skillsDir) || { skills: {} };
+	lock.skills[skillName] = info;
+	let yaml = "skills:\n";
+	for (const [name, skill] of Object.entries(lock.skills)) {
+		yaml += `  ${name}:\n`;
+		if (skill.packageName) yaml += `    packageName: "${skill.packageName}"\n`;
+		if (skill.version) yaml += `    version: "${skill.version}"\n`;
+		if (skill.source) yaml += `    source: "${skill.source}"\n`;
+		if (skill.syncedAt) yaml += `    syncedAt: "${skill.syncedAt}"\n`;
+		if (skill.generator) yaml += `    generator: "${skill.generator}"\n`;
+	}
+	writeFileSync(lockPath, yaml);
+}
+function removeLockEntry(skillsDir, skillName) {
+	const lockPath = join(skillsDir, "skilld-lock.yaml");
+	const lock = readLock(skillsDir);
+	if (!lock) return;
+	delete lock.skills[skillName];
+	if (Object.keys(lock.skills).length === 0) {
+		unlinkSync(lockPath);
+		return;
+	}
+	let yaml = "skills:\n";
+	for (const [name, skill] of Object.entries(lock.skills)) {
+		yaml += `  ${name}:\n`;
+		if (skill.packageName) yaml += `    packageName: "${skill.packageName}"\n`;
+		if (skill.version) yaml += `    version: "${skill.version}"\n`;
+		if (skill.source) yaml += `    source: "${skill.source}"\n`;
+		if (skill.syncedAt) yaml += `    syncedAt: "${skill.syncedAt}"\n`;
+		if (skill.generator) yaml += `    generator: "${skill.generator}"\n`;
+	}
+	writeFileSync(lockPath, yaml);
+}
+async function installCommand(opts) {
+	const cwd = process.cwd();
+	const agent = agents[opts.agent];
+	const skillsDir = opts.global ? join(__require("node:os").homedir(), ".skilld", "skills") : join(cwd, agent.skillsDir);
+	const lock = readLock(skillsDir);
+	if (!lock || Object.keys(lock.skills).length === 0) {
+		p.log.warn("No skilld-lock.yaml found. Run `skilld` to sync skills first.");
+		return;
+	}
+	const skills = Object.entries(lock.skills);
+	const toRestore = [];
+	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) || lstatSync(referencesPath).isSymbolicLink() && !existsSync(referencesPath) || existsSync(skillMdPath) && lstatSync(skillMdPath).isSymbolicLink() && !existsSync(skillMdPath)) toRestore.push({
+			name,
+			info
+		});
+	}
+	if (toRestore.length === 0) {
+		p.log.success("All references already linked");
+		return;
+	}
+	p.log.info(`Restoring ${toRestore.length} references`);
+	ensureCacheDir();
+	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;
+		}
+		const skillDir = join(skillsDir, name);
+		const referencesPath = join(skillDir, ".skilld");
+		const globalCachePath = getCacheDir(pkgName, version);
+		const spin = p.spinner();
+		if (isCached(pkgName, version)) {
+			spin.start(`Linking ${name}`);
+			mkdirSync(skillDir, { recursive: true });
+			mkdirSync(referencesPath, { recursive: true });
+			linkPkgSymlink(referencesPath, pkgName, cwd, 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 githubLink = join(referencesPath, "github");
+			const cachedGithub = join(globalCachePath, "github");
+			if (existsSync(githubLink)) unlinkSync(githubLink);
+			if (existsSync(cachedGithub)) symlinkSync(cachedGithub, githubLink, "junction");
+			const releasesLink = join(referencesPath, "releases");
+			const cachedReleases = join(globalCachePath, "releases");
+			if (existsSync(releasesLink)) unlinkSync(releasesLink);
+			if (existsSync(cachedReleases)) symlinkSync(cachedReleases, releasesLink, "junction");
+			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 = [];
+		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 url = `${gitDocs.baseUrl}/${file}`;
+							const res = await fetch(url, { headers: { "User-Agent": "skilld/1.0" } }).catch(() => null);
+							if (!res?.ok) return null;
+							return {
+								file,
+								content: await res.text()
+							};
+						}));
+						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 (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) {
+						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);
+			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 (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) });
+			spin.stop(`Downloaded and linked ${name}`);
+		} else spin.stop(`No docs found for ${name}`);
+	}
+	p.outro("Install complete");
+}
+function unsanitizeName(sanitized, source) {
+	if (source?.includes("ungh://")) {
+		const match = source.match(/ungh:\/\/([^/]+)\/(.+)/);
+		if (match) return `@${match[1]}/${match[2]}`;
+	}
+	if (sanitized.startsWith("antfu-")) return `@antfu/${sanitized.slice(6)}`;
+	if (sanitized.startsWith("clack-")) return `@clack/${sanitized.slice(6)}`;
+	if (sanitized.startsWith("nuxt-")) return `@nuxt/${sanitized.slice(5)}`;
+	if (sanitized.startsWith("vue-")) return `@vue/${sanitized.slice(4)}`;
+	if (sanitized.startsWith("vueuse-")) return `@vueuse/${sanitized.slice(7)}`;
+	return sanitized;
+}
+function linkPkgSymlink(referencesDir, name, cwd, version) {
+	const pkgPath = resolvePkgDir(name, cwd, version);
+	if (!pkgPath) return;
+	const pkgLink = join(referencesDir, "pkg");
+	if (existsSync(pkgLink)) unlinkSync(pkgLink);
+	symlinkSync(pkgPath, pkgLink, "junction");
+}
+function isReadmeOnly(cacheDir) {
+	const docsDir = join(cacheDir, "docs");
+	if (!existsSync(docsDir)) return false;
+	const files = readdirSync(docsDir);
+	return files.length === 1 && files[0] === "README.md";
+}
+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;
+}
+function* iterateSkills(opts = {}) {
+	const { scope = "all", cwd = process.cwd() } = opts;
+	const agentTypes = opts.agents ?? Object.keys(agents);
+	for (const agentType of agentTypes) {
+		const agent = agents[agentType];
+		if (scope === "local" || scope === "all") {
+			const localDir = join(cwd, agent.skillsDir);
+			if (existsSync(localDir)) {
+				const lock = readLock(localDir);
+				const entries = readdirSync(localDir).filter((f) => !f.startsWith(".") && f !== "skilld-lock.yaml");
+				for (const name of entries) {
+					const dir = join(localDir, name);
+					if (lock?.skills[name]) yield {
+						name,
+						dir,
+						agent: agentType,
+						info: lock.skills[name],
+						scope: "local"
+					};
+					else {
+						const info = parseSkillFrontmatter(join(dir, "_SKILL.md"));
+						if (info?.generator === "skilld") yield {
+							name,
+							dir,
+							agent: agentType,
+							info,
+							scope: "local"
+						};
+					}
+				}
+			}
+		}
+		if ((scope === "global" || scope === "all") && agent.globalSkillsDir) {
+			const globalDir = agent.globalSkillsDir;
+			if (existsSync(globalDir)) {
+				const lock = readLock(globalDir);
+				const entries = readdirSync(globalDir).filter((f) => !f.startsWith(".") && f !== "skilld-lock.yaml");
+				for (const name of entries) {
+					const dir = join(globalDir, name);
+					if (lock?.skills[name]) yield {
+						name,
+						dir,
+						agent: agentType,
+						info: lock.skills[name],
+						scope: "global"
+					};
+					else {
+						const info = parseSkillFrontmatter(join(dir, "_SKILL.md"));
+						if (info?.generator === "skilld") yield {
+							name,
+							dir,
+							agent: agentType,
+							info,
+							scope: "global"
+						};
+					}
+				}
+			}
+		}
+	}
+}
+function isOutdated(skill, depVersion) {
+	if (!skill.info?.version) return true;
+	return skill.info.version.split(".").slice(0, 2).join(".") !== depVersion.replace(/^[\^~]/, "").split(".").slice(0, 2).join(".");
+}
+async function getProjectState(cwd = process.cwd()) {
+	const skills = [...iterateSkills({
+		scope: "local",
+		cwd
+	})];
+	const localDeps = await readLocalDependencies(cwd).catch(() => []);
+	const deps = new Map(localDeps.map((d) => [d.name, d.version]));
+	const skillByName = new Map(skills.map((s) => [s.name, s]));
+	const skillByPkgName = /* @__PURE__ */ new Map();
+	for (const s of skills) if (s.info?.packageName) skillByPkgName.set(s.info.packageName, s);
+	const missing = [];
+	const outdated = [];
+	const synced = [];
+	const matchedSkillNames = /* @__PURE__ */ new Set();
+	for (const [pkgName, version] of deps) {
+		const normalizedName = pkgName.replace(/^@/, "").replace(/\//g, "-");
+		const skill = skillByName.get(normalizedName) || skillByName.get(pkgName) || skillByPkgName.get(pkgName);
+		if (!skill) missing.push(pkgName);
+		else {
+			matchedSkillNames.add(skill.name);
+			if (isOutdated(skill, version)) outdated.push({
+				...skill,
+				packageName: pkgName,
+				latestVersion: version
+			});
+			else synced.push({
+				...skill,
+				packageName: pkgName,
+				latestVersion: version
+			});
+		}
+	}
+	return {
+		skills,
+		deps,
+		missing,
+		outdated,
+		synced,
+		unmatched: skills.filter((s) => !matchedSkillNames.has(s.name))
+	};
+}
+function getSkillsDir(agent, scope, cwd = process.cwd()) {
+	const agentConfig = agents[agent];
+	if (scope === "global") {
+		if (!agentConfig.globalSkillsDir) throw new Error(`Agent ${agent} does not support global skills`);
+		return agentConfig.globalSkillsDir;
+	}
+	return join(cwd, agentConfig.skillsDir);
+}
+async function removeCommand(state, opts) {
+	const scope = opts.global ? "global" : "local";
+	const allSkills = [...iterateSkills({ scope })];
+	const skills = opts.packages ? allSkills.filter((s) => opts.packages.includes(s.name)) : await pickSkillsToRemove(allSkills, scope);
+	if (!skills || skills.length === 0) {
+		p.log.info("No skills selected");
+		return;
+	}
+	if (!opts.yes) {
+		const confirmed = await p.confirm({ message: `Remove ${skills.length} skill(s)? ${skills.map((s) => s.name).join(", ")}` });
+		if (p.isCancel(confirmed) || !confirmed) {
+			p.cancel("Cancelled");
+			return;
+		}
+	}
+	for (const skill of skills) {
+		const skillsDir = getSkillsDir(skill.agent, skill.scope);
+		if (existsSync(skill.dir)) {
+			rmSync(skill.dir, {
+				recursive: true,
+				force: true
+			});
+			removeLockEntry(skillsDir, skill.name);
+			p.log.success(`Removed ${skill.name}`);
+		} else p.log.warn(`${skill.name} not found`);
+	}
+	p.outro(`Removed ${skills.length} skill(s)`);
+}
+async function pickSkillsToRemove(skills, scope) {
+	if (skills.length === 0) {
+		p.log.warn(`No ${scope} skills installed`);
+		return null;
+	}
+	const options = skills.map((skill) => ({
+		label: skill.name,
+		value: skill.name,
+		hint: skill.info?.version ? `@${skill.info.version}` : void 0
+	}));
+	const selected = await p.multiselect({
+		message: "Select skills to remove",
+		options,
+		required: false
+	});
+	if (p.isCancel(selected)) {
+		p.cancel("Cancelled");
+		return null;
+	}
+	const selectedSet = new Set(selected);
+	return skills.filter((s) => selectedSet.has(s.name));
+}
+function highlightTerms(content, terms) {
+	if (terms.length === 0) return content;
+	const sorted = [...terms].sort((a, b) => b.length - a.length);
+	const pattern = new RegExp(`(${sorted.map((t) => t.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("|")})`, "gi");
+	return content.replace(pattern, "\x1B[33m$1\x1B[0m");
+}
+function formatSnippet(r) {
+	const refPath = `.claude/skills/${r.package}/.skilld/${r.source}`;
+	const lineRange = r.lineStart === r.lineEnd ? `L${r.lineStart}` : `L${r.lineStart}-${r.lineEnd}`;
+	const score = `\x1B[90m${r.score.toFixed(2)}\x1B[0m`;
+	const scopeStr = r.scope?.length ? `${r.scope.map((e) => e.name).join(".")} → ` : "";
+	const entityStr = r.entities?.map((e) => e.signature || `${e.type} ${e.name}`).join(", ");
+	const highlighted = highlightTerms(r.content, r.highlights);
+	return [
+		`${r.package} ${score}${entityStr ? `  \x1B[36m${scopeStr}${entityStr}\x1B[0m` : ""}`,
+		`\x1B[90m${refPath}:${lineRange}\x1B[0m`,
+		`  ${highlighted.replace(/\n/g, "\n  ")}`
+	].join("\n");
+}
+function findPackageDbs(packageFilter) {
+	if (!existsSync(REFERENCES_DIR)) return [];
+	const normalize = (s) => s.toLowerCase().replace(/[-_]/g, "");
+	return readdirSync(REFERENCES_DIR).filter((name) => name.includes("@")).filter((name) => {
+		if (!packageFilter) return true;
+		const pkg = name.split("@")[0];
+		const filter = normalize(packageFilter);
+		return normalize(pkg).includes(filter) || pkg.startsWith(packageFilter);
+	}).map((dir) => join(REFERENCES_DIR, dir, "search.db")).filter((db) => existsSync(db));
+}
+async function searchCommand(rawQuery, packageFilter) {
+	const dbs = findPackageDbs(packageFilter);
+	if (dbs.length === 0) {
+		if (packageFilter) p.log.warn(`No docs indexed for "${packageFilter}". Run \`skilld add ${packageFilter}\` first.`);
+		else p.log.warn("No docs indexed yet. Run `skilld add <package>` first.");
+		return;
+	}
+	let query = rawQuery;
+	let filter;
+	const prefixMatch = rawQuery.match(/^(issues?|docs?|releases?):(.+)$/i);
+	if (prefixMatch) {
+		const prefix = prefixMatch[1].toLowerCase();
+		query = prefixMatch[2];
+		if (prefix.startsWith("issue")) filter = { type: "issue" };
+		else if (prefix.startsWith("release")) filter = { type: "release" };
+		else filter = { type: { $in: ["doc", "docs"] } };
+	}
+	const start = performance.now();
+	const merged = (await Promise.all(dbs.map((dbPath) => searchSnippets(query, { dbPath }, {
+		limit: filter ? 10 : 5,
+		filter
+	})))).flat().sort((a, b) => b.score - a.score).slice(0, 5);
+	const elapsed = ((performance.now() - start) / 1e3).toFixed(2);
+	if (merged.length === 0) {
+		p.log.warn(`No results for "${query}"`);
+		return;
+	}
+	const output = merged.map((r) => formatSnippet(r)).join("\n\n");
+	p.log.message(`${output}\n\n${merged.length} results (${elapsed}s)`);
+}
+const require$1 = createRequire(import.meta.url);
+const { version: skilldVersion } = require$1("../package.json");
+function countDocs(packageName, version) {
+	if (!version) return 0;
+	const cacheDir = getCacheDir(packageName, version);
+	if (!existsSync(cacheDir)) return 0;
+	let count = 0;
+	const walk = (dir, depth = 0) => {
+		if (depth > 3) return;
 		try {
-			execSync("which claude", { stdio: "ignore" });
-			return true;
-		} catch {
-			return false;
-		}
-	})()) models.push({
-		id: "haiku",
-		name: "Haiku",
-		description: "Fast and cheap",
-		available: true
-	}, {
-		id: "sonnet",
-		name: "Sonnet",
-		description: "Balanced",
-		available: true
-	}, {
-		id: "opus",
-		name: "Opus",
-		description: "Most capable",
-		available: true
+			for (const entry of readdirSync(dir, { withFileTypes: true })) {
+				if (entry.name === "search.db") continue;
+				if (entry.isDirectory()) walk(join(dir, entry.name), depth + 1);
+				else if (entry.name.endsWith(".md") || entry.name.endsWith(".mdx")) count++;
+			}
+		} catch {}
+	};
+	walk(cacheDir);
+	return count;
+}
+function countEmbeddings(packageName, version) {
+	if (!version) return null;
+	const dbPath = getPackageDbPath(packageName, version);
+	if (!existsSync(dbPath)) return null;
+	try {
+		const { DatabaseSync } = require$1("node:sqlite");
+		const db = new DatabaseSync(dbPath, {
+			open: true,
+			readOnly: true
+		});
+		const row = db.prepare("SELECT count(*) as cnt FROM vector_metadata").get();
+		db.close();
+		return row?.cnt ?? null;
+	} catch {
+		return null;
+	}
+}
+function countRefDocs(skillDir) {
+	const refsDir = join(skillDir, ".skilld");
+	if (!existsSync(refsDir)) return 0;
+	let count = 0;
+	const walk = (dir, depth = 0) => {
+		if (depth > 3) return;
+		try {
+			for (const entry of readdirSync(dir, { withFileTypes: true })) if (entry.isDirectory() || entry.isSymbolicLink()) try {
+				if (statSync(join(dir, entry.name)).isDirectory()) walk(join(dir, entry.name), depth + 1);
+			} catch {
+				continue;
+			}
+			else if (entry.name.endsWith(".md") || entry.name.endsWith(".mdx")) count++;
+		} catch {}
+	};
+	walk(refsDir);
+	return count;
+}
+function timeAgo(iso) {
+	if (!iso) return "";
+	const diff = Date.now() - new Date(iso).getTime();
+	const days = Math.floor(diff / 864e5);
+	if (days <= 0) return "today";
+	if (days === 1) return "1d ago";
+	if (days < 7) return `${days}d ago`;
+	if (days < 30) return `${Math.floor(days / 7)}w ago`;
+	return `${Math.floor(days / 30)}mo ago`;
+}
+function formatSource(source) {
+	if (!source) return "";
+	if (source === "shipped") return "shipped";
+	if (source.includes("llms.txt")) return "llms.txt";
+	if (source.includes("github.com")) return source.replace(/https?:\/\/github\.com\//, "");
+	return source;
+}
+const dim = (s) => `\x1B[90m${s}\x1B[0m`;
+const bold = (s) => `\x1B[1m${s}\x1B[0m`;
+const green = (s) => `\x1B[32m${s}\x1B[0m`;
+function getLastSynced$1() {
+	let latest = null;
+	for (const skill of iterateSkills()) if (skill.info?.syncedAt) {
+		const d = new Date(skill.info.syncedAt);
+		if (!latest || d > latest) latest = d;
+	}
+	if (!latest) return null;
+	return timeAgo(latest.toISOString());
+}
+function buildConfigLines() {
+	const config = readConfig();
+	const lines = [];
+	lines.push(`Version   v${skilldVersion}`);
+	const lastSynced = getLastSynced$1();
+	if (lastSynced) lines.push(`Synced    ${dim(lastSynced)}`);
+	lines.push(`Config    ${dim(join(CACHE_DIR, "config.yaml"))}${hasConfig() ? "" : dim(" (not created)")}`);
+	lines.push(`Cache     ${dim(CACHE_DIR)}`);
+	const withCli = Object.entries(agents).filter(([_, a]) => a.cli);
+	const installed = [];
+	for (const [id, agent] of withCli) {
+		const ver = getAgentVersion(id);
+		if (ver) installed.push(`${agent.displayName} v${ver}`);
+	}
+	if (installed.length > 0) lines.push(`Agents    ${installed.join(", ")}`);
+	if (config.model) lines.push(`Model     ${config.model}`);
+	const features = {
+		...defaultFeatures,
+		...config.features
+	};
+	const parts = Object.entries(features).map(([k, v]) => `${k}: ${v ? green("on") : dim("off")}`);
+	lines.push(`Features  ${parts.join(", ")}`);
+	if (config.projects?.length) lines.push(`Projects  ${config.projects.length} registered`);
+	return lines;
+}
+function statusCommand(opts = {}) {
+	const allSkills = [...iterateSkills({ scope: opts.global ? "global" : "all" })];
+	p.log.step(bold("Skilld Config"));
+	p.log.message(buildConfigLines().join("\n"));
+	if (allSkills.length === 0) {
+		p.log.step(bold("Skills"));
+		p.log.message(`${dim("(none)")}\n\nRun ${bold("skilld add <package>")} to install skills`);
+		return;
+	}
+	const localPkgs = /* @__PURE__ */ new Map();
+	const globalPkgs = /* @__PURE__ */ new Map();
+	for (const skill of allSkills) {
+		const key = skill.info?.packageName || skill.name;
+		const map = skill.scope === "local" ? localPkgs : globalPkgs;
+		if (!map.has(key)) map.set(key, {
+			name: skill.name,
+			info: skill.info || {},
+			agents: new Set([skill.agent]),
+			scope: skill.scope
+		});
+		else map.get(key).agents.add(skill.agent);
+	}
+	const buildPackageLines = (pkgs) => {
+		const lines = [];
+		for (const [, pkg] of pkgs) {
+			const { info } = pkg;
+			const parts = [`${info.source === "shipped" ? "▶" : "◆"} ${bold(pkg.name)}`];
+			if (info.version) parts.push(dim(info.version));
+			const source = formatSource(info.source);
+			if (source && source !== "shipped") parts.push(dim(source));
+			lines.push(parts.join("  "));
+			const meta = [];
+			const pkgName = info.packageName || pkg.name;
+			const docs = countDocs(pkgName, info.version) || countRefDocs(join(pkg.scope === "global" ? agents[pkg.agents.values().next().value].globalSkillsDir : join(process.cwd(), agents[pkg.agents.values().next().value].skillsDir), pkg.name));
+			if (docs > 0) meta.push(`${docs} docs`);
+			const embeddings = countEmbeddings(pkgName, info.version);
+			if (embeddings !== null) meta.push(`${embeddings} chunks`);
+			const ago = timeAgo(info.syncedAt);
+			if (ago) meta.push(`synced ${ago}`);
+			if (pkg.agents.size > 0) {
+				const agentNames = [...pkg.agents].map((a) => agents[a].displayName);
+				meta.push(agentNames.join(", "));
+			}
+			if (meta.length > 0) lines.push(`  ${dim(meta.join(" · "))}`);
+		}
+		return lines;
+	};
+	if (!opts.global && localPkgs.size > 0) {
+		p.log.step(`${bold("Local")} (project)`);
+		p.log.message(buildPackageLines(localPkgs).join("\n"));
+	}
+	if (globalPkgs.size > 0) {
+		p.log.step(bold("Global"));
+		p.log.message(buildPackageLines(globalPkgs).join("\n"));
+	}
+	if (!opts.global && localPkgs.size === 0) {
+		p.log.step(`${bold("Local")} (project)`);
+		p.log.message(dim("(none)"));
+	}
+	const total = localPkgs.size + globalPkgs.size;
+	p.log.info(`${total} package${total !== 1 ? "s" : ""}`);
+}
+const RESOLVE_STEP_LABELS = {
+	"npm": "npm registry",
+	"github-docs": "GitHub docs",
+	"github-meta": "GitHub meta",
+	"github-search": "GitHub search",
+	"readme": "README",
+	"llms.txt": "llms.txt",
+	"local": "node_modules"
+};
+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}`);
+	}
+}
+function formatTaskResults(results) {
+	return results.map((r) => {
+		if (r.status === "error") return `\x1B[31m✖\x1B[0m  ${r.msg}`;
+		if (r.status === "warn") return `\x1B[33m▲\x1B[0m  ${r.msg}`;
+		return `\x1B[32m✓\x1B[0m  ${r.msg}`;
+	}).join("\n");
+}
+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;
+	}
+	p.log.info(`\x1B[1mGit guidance:\x1B[0m\n  \x1B[32m✓\x1B[0m Commit: \x1B[36m${skillsDir}/*/SKILL.md\x1B[0m\n  \x1B[32m✓\x1B[0m Commit: \x1B[36m${skillsDir}/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");
+}
+async function syncCommand(state, opts) {
+	if (opts.packages && opts.packages.length > 0) {
+		if (opts.packages.length > 1) {
+			const { syncPackagesParallel } = await import("./_chunks/sync-parallel.mjs");
+			return syncPackagesParallel({
+				packages: opts.packages,
+				global: opts.global,
+				agent: opts.agent,
+				model: opts.model,
+				yes: opts.yes,
+				force: opts.force
+			});
+		}
+		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) {
+		const { syncPackagesParallel } = await import("./_chunks/sync-parallel.mjs");
+		return syncPackagesParallel({
+			packages,
+			global: opts.global,
+			agent: opts.agent,
+			model: opts.model,
+			yes: opts.yes,
+			force: opts.force
+		});
+	}
+	await syncSinglePackage(packages[0], opts);
+}
+async function interactivePicker(state) {
+	const spin = p.spinner();
+	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 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 (config.model && available.some((m) => m.id === config.model)) return config.model;
+	if (skipPrompt) 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;
+}
+async function selectSkillSections() {
+	const selected = await p.multiselect({
+		message: "Generate SKILL.md with LLM",
+		options: [
+			{
+				label: "Best practices",
+				value: "best-practices",
+				hint: "gotchas, pitfalls, patterns"
+			},
+			{
+				label: "API reference",
+				value: "api",
+				hint: "exported functions & composables"
+			},
+			{
+				label: "Custom prompt",
+				value: "custom",
+				hint: "add your own instructions"
+			}
+		],
+		initialValues: ["best-practices", "api"],
+		required: false
+	});
+	if (p.isCancel(selected)) return {
+		sections: [],
+		cancelled: true
+	};
+	const sections = selected;
+	if (sections.length === 0) return {
+		sections: [],
+		cancelled: false
+	};
+	let customPrompt;
+	if (sections.includes("custom")) {
+		const text = await p.text({
+			message: "Custom instructions",
+			placeholder: "e.g. \"Focus on SSR patterns\" or \"Include migration notes from v2 to v3\""
+		});
+		if (p.isCancel(text)) return {
+			sections: [],
+			cancelled: true
+		};
+		customPrompt = text;
+	}
+	return {
+		sections,
+		customPrompt,
+		cancelled: false
+	};
+}
+async function syncSinglePackage(packageName, config) {
+	const spin = p.spinner();
+	spin.start(`Resolving ${packageName}`);
+	const cwd = process.cwd();
+	const localVersion = (await readLocalDependencies(cwd).catch(() => [])).find((d) => d.name === packageName)?.version;
+	const resolveResult = await resolvePackageDocsWithAttempts(packageName, {
+		version: localVersion,
+		cwd,
+		onProgress: (step) => spin.message(`${packageName}: ${RESOLVE_STEP_LABELS[step]}`)
+	});
+	let resolved = resolveResult.package;
+	if (!resolved) {
+		const { readFileSync, existsSync } = await import("node:fs");
+		const { join, resolve } = await import("node:path");
+		const pkgPath = join(cwd, "package.json");
+		if (existsSync(pkgPath)) {
+			const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+			const depVersion = {
+				...pkg.dependencies,
+				...pkg.devDependencies
+			}[packageName];
+			if (depVersion?.startsWith("link:")) {
+				spin.message(`Resolving local package: ${packageName}`);
+				resolved = await resolveLocalPackageDocs(resolve(cwd, depVersion.slice(5)));
+			}
+		}
+	}
+	if (!resolved) {
+		spin.stop(`Could not find docs for: ${packageName}`);
+		showResolveAttempts(resolveResult.attempts);
+		return;
+	}
+	const version = localVersion || resolved.version || "latest";
+	const versionKey = getVersionKey(version);
+	if (!existsSync(join(cwd, "node_modules", packageName))) {
+		spin.message(`Downloading ${packageName}@${version} dist`);
+		await fetchPkgDist(packageName, version);
+	}
+	const shippedSkills = getShippedSkills(packageName, cwd, version);
+	if (shippedSkills.length > 0) {
+		const agent = agents[config.agent];
+		const baseDir = config.global ? join(CACHE_DIR, "skills") : join(cwd, agent.skillsDir);
+		mkdirSync(baseDir, { recursive: true });
+		for (const shipped of shippedSkills) {
+			linkShippedSkill(baseDir, shipped.skillName, shipped.skillDir);
+			writeLock(baseDir, shipped.skillName, {
+				packageName,
+				version,
+				source: "shipped",
+				syncedAt: (/* @__PURE__ */ new Date()).toISOString().split("T")[0],
+				generator: "skilld"
+			});
+			p.log.success(`Linked shipped skill: ${shipped.skillName} → ${relative(cwd, shipped.skillDir)}`);
+		}
+		if (!config.global) registerProject(cwd);
+		spin.stop(`Shipped ${shippedSkills.length} skill(s) from ${packageName}`);
+		return;
+	}
+	if (config.force) {
+		clearCache(packageName, version);
+		const forcedDbPath = getPackageDbPath(packageName, version);
+		if (existsSync(forcedDbPath)) rmSync(forcedDbPath, {
+			recursive: true,
+			force: true
+		});
+	}
+	const useCache = isCached(packageName, version);
+	spin.stop(`Resolved ${packageName}@${useCache ? versionKey : version}${config.force ? " (force)" : useCache ? " (cached)" : ""}`);
+	ensureCacheDir();
+	const agent = agents[config.agent];
+	const baseDir = config.global ? join(CACHE_DIR, "skills") : join(cwd, agent.skillsDir);
+	const skillDir = join(baseDir, sanitizeName(packageName));
+	mkdirSync(skillDir, { recursive: true });
+	let docSource = resolved.readmeUrl || "readme";
+	let docsType = "readme";
+	const fetchedDocs = [];
+	const fetchedIssues = [];
+	const fetchedDiscussions = [];
+	const fetchedReleases = [];
+	const resourceTasks = [];
+	if (!useCache) resourceTasks.push({
+		title: "Fetching documentation",
+		task: async (message) => {
+			const cachedDocs = [];
+			if (resolved.gitDocsUrl && resolved.repoUrl) {
+				const gh = parseGitHubUrl(resolved.repoUrl);
+				if (gh) {
+					const gitDocs = await fetchGitDocs(gh.owner, gh.repo, version, packageName);
+					if (gitDocs && gitDocs.files.length > 0) {
+						message(`Downloading ${gitDocs.files.length} docs from ${gitDocs.ref}`);
+						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);
+							const batchResults = await Promise.all(batch.map(async (file) => {
+								const url = `${gitDocs.baseUrl}/${file}`;
+								const res = await fetch(url, { headers: { "User-Agent": "skilld/1.0" } }).catch(() => null);
+								if (!res?.ok) return null;
+								return {
+									file,
+									content: await res.text()
+								};
+							}));
+							results.push(...batchResults);
+						}
+						for (const r of results) if (r) {
+							const cachePath = gitDocs.docsPrefix ? r.file.replace(gitDocs.docsPrefix, "") : r.file;
+							cachedDocs.push({
+								path: cachePath,
+								content: r.content
+							});
+							fetchedDocs.push({
+								id: cachePath,
+								content: r.content,
+								metadata: {
+									package: packageName,
+									source: cachePath,
+									type: "doc"
+								}
+							});
+						}
+						const downloaded = results.filter(Boolean).length;
+						if (downloaded > 0) {
+							docSource = `${resolved.repoUrl}/tree/${gitDocs.ref}/docs`;
+							docsType = "docs";
+							writeToCache(packageName, version, cachedDocs);
+							return `Downloaded ${downloaded} git docs`;
+						}
+					}
+				}
+			}
+			if (resolved.llmsUrl && cachedDocs.length === 0) {
+				message("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) {
+						message(`Downloading ${llmsContent.links.length} linked docs`);
+						const docs = await downloadLlmsDocs(llmsContent, baseUrl);
+						for (const doc of docs) {
+							const cachePath = join("docs", ...(doc.url.startsWith("/") ? doc.url.slice(1) : doc.url).split("/"));
+							cachedDocs.push({
+								path: cachePath,
+								content: doc.content
+							});
+							fetchedDocs.push({
+								id: doc.url,
+								content: doc.content,
+								metadata: {
+									package: packageName,
+									source: cachePath,
+									type: "doc"
+								}
+							});
+						}
+						writeToCache(packageName, version, cachedDocs);
+						return `Saved ${docs.length + 1} docs from llms.txt`;
+					}
+					writeToCache(packageName, version, cachedDocs);
+					return "Saved llms.txt";
+				}
+			}
+			if (resolved.readmeUrl && cachedDocs.length === 0) {
+				message("Fetching README");
+				const content = await fetchReadmeContent(resolved.readmeUrl);
+				if (content) {
+					cachedDocs.push({
+						path: "docs/README.md",
+						content
+					});
+					fetchedDocs.push({
+						id: "README.md",
+						content,
+						metadata: {
+							package: packageName,
+							source: "docs/README.md",
+							type: "doc"
+						}
+					});
+					writeToCache(packageName, version, cachedDocs);
+					return "Saved README.md";
+				}
+			}
+			return "No docs found";
+		}
 	});
-	if (process.env.ANTHROPIC_API_KEY) {
-		if (models.length === 0) models.push({
-			id: "haiku",
-			name: "Haiku (API)",
-			description: "Fast and cheap",
-			available: true
-		}, {
-			id: "sonnet",
-			name: "Sonnet (API)",
-			description: "Balanced",
-			available: true
+	const features = readConfig().features ?? defaultFeatures;
+	const issuesPath = join(getCacheDir(packageName, version), "github", "RECENT-ISSUES.md");
+	if (features.issues && resolved.repoUrl && isGhAvailable() && !existsSync(issuesPath)) {
+		const gh = parseGitHubUrl(resolved.repoUrl);
+		if (gh) resourceTasks.push({
+			title: "Fetching GitHub issues",
+			task: async () => {
+				const issues = await fetchGitHubIssues(gh.owner, gh.repo, 20);
+				if (issues.length > 0) {
+					writeToCache(packageName, version, [{
+						path: "github/RECENT-ISSUES.md",
+						content: formatIssuesAsMarkdown(issues)
+					}]);
+					for (const issue of issues) fetchedIssues.push({
+						id: `issue-${issue.number}`,
+						content: `#${issue.number}: ${issue.title}\n\n${issue.body || ""}`,
+						metadata: {
+							package: packageName,
+							source: "github/RECENT-ISSUES.md",
+							type: "issue",
+							number: issue.number
+						}
+					});
+					return `Cached ${issues.length} issues`;
+				}
+				return "No issues found";
+			}
+		});
+	}
+	const discussionsPath = join(getCacheDir(packageName, version), "github", "RECENT-DISCUSSIONS.md");
+	if (features.discussions && resolved.repoUrl && isGhAvailable() && !existsSync(discussionsPath)) {
+		const gh = parseGitHubUrl(resolved.repoUrl);
+		if (gh) resourceTasks.push({
+			title: "Fetching GitHub discussions",
+			task: async () => {
+				const discussions = await fetchGitHubDiscussions(gh.owner, gh.repo, 20);
+				if (discussions.length > 0) {
+					writeToCache(packageName, version, [{
+						path: "github/RECENT-DISCUSSIONS.md",
+						content: formatDiscussionsAsMarkdown(discussions)
+					}]);
+					for (const d of discussions) fetchedDiscussions.push({
+						id: `discussion-${d.number}`,
+						content: `#${d.number}: ${d.title}\n\n${d.body || ""}`,
+						metadata: {
+							package: packageName,
+							source: "github/RECENT-DISCUSSIONS.md",
+							type: "discussion",
+							number: d.number
+						}
+					});
+					return `Cached ${discussions.length} discussions`;
+				}
+				return "No discussions found";
+			}
+		});
+	}
+	const releasesPath = join(getCacheDir(packageName, version), "releases");
+	if (features.releases && resolved.repoUrl && !existsSync(releasesPath)) {
+		const gh = parseGitHubUrl(resolved.repoUrl);
+		if (gh) resourceTasks.push({
+			title: "Fetching release notes",
+			task: async () => {
+				const releaseDocs = await fetchReleaseNotes(gh.owner, gh.repo, version, resolved.gitRef, packageName);
+				if (releaseDocs.length > 0) {
+					writeToCache(packageName, version, releaseDocs);
+					for (const doc of releaseDocs) fetchedReleases.push({
+						id: doc.path,
+						content: doc.content,
+						metadata: {
+							package: packageName,
+							source: doc.path,
+							type: "release"
+						}
+					});
+					return `Cached ${releaseDocs.length} release note(s)`;
+				}
+				return "No releases found";
+			}
+		});
+	}
+	if (resourceTasks.length > 0) {
+		const resSpin = p.spinner();
+		resSpin.start("Finding resources");
+		const resResults = [];
+		for (const task of resourceTasks) {
+			resSpin.message(task.title);
+			try {
+				const result = await task.task((msg) => resSpin.message(msg));
+				if (result === "No discussions found") continue;
+				resResults.push({
+					msg: result,
+					status: result.startsWith("No ") ? "warn" : "ok"
+				});
+			} catch {
+				resResults.push({
+					msg: `${task.title} failed`,
+					status: "error"
+				});
+			}
+		}
+		resSpin.stop("Fetched resources");
+		p.log.message(formatTaskResults(resResults));
+	}
+	try {
+		linkPkg(skillDir, packageName, cwd, version);
+		if (!hasShippedDocs(packageName, cwd, version) && docsType !== "readme") linkReferences(skillDir, packageName, version);
+		linkGithub(skillDir, packageName, version);
+		linkReleases(skillDir, packageName, version);
+	} catch {}
+	const dbPath = getPackageDbPath(packageName, version);
+	const indexTasks = [];
+	if (!existsSync(dbPath)) if (fetchedDocs.length > 0 || fetchedIssues.length > 0 || fetchedDiscussions.length > 0 || fetchedReleases.length > 0) {
+		if (fetchedDocs.length > 0) indexTasks.push({
+			title: `Indexing ${fetchedDocs.length} docs`,
+			task: async (message) => {
+				await createIndex(fetchedDocs, {
+					dbPath,
+					onProgress: (current, total, doc) => {
+						message(`Indexing doc ${doc?.id ? doc.id.split("/").pop() : ""} - ${current}/${total}`);
+					}
+				});
+				return `Indexed ${fetchedDocs.length} docs`;
+			}
+		});
+		if (fetchedIssues.length > 0) indexTasks.push({
+			title: `Indexing ${fetchedIssues.length} issues`,
+			task: async (message) => {
+				await createIndex(fetchedIssues, {
+					dbPath,
+					onProgress: (current, total, doc) => {
+						message(`Indexing doc ${doc?.id ? doc.id.split("/").pop() : ""} - ${current}/${total}`);
+					}
+				});
+				return `Indexed ${fetchedIssues.length} issues`;
+			}
+		});
+		if (fetchedDiscussions.length > 0) indexTasks.push({
+			title: `Indexing ${fetchedDiscussions.length} discussions`,
+			task: async (message) => {
+				await createIndex(fetchedDiscussions, {
+					dbPath,
+					onProgress: (current, total, doc) => {
+						message(`Indexing doc ${doc?.id ? doc.id.split("/").pop() : ""} - ${current}/${total}`);
+					}
+				});
+				return `Indexed ${fetchedDiscussions.length} discussions`;
+			}
+		});
+		if (fetchedReleases.length > 0) indexTasks.push({
+			title: `Indexing ${fetchedReleases.length} releases`,
+			task: async (message) => {
+				await createIndex(fetchedReleases, {
+					dbPath,
+					onProgress: (current, total, doc) => {
+						message(`Indexing doc ${doc?.id ? doc.id.split("/").pop() : ""} - ${current}/${total}`);
+					}
+				});
+				return `Indexed ${fetchedReleases.length} releases`;
+			}
+		});
+	} else indexTasks.push({
+		title: "Indexing cached docs",
+		task: async (message) => {
+			const cachedDocs = readCachedDocs(packageName, version);
+			if (cachedDocs.length === 0) return "No docs to index";
+			const docsToIndex = cachedDocs.filter((doc) => !doc.path.startsWith("github/")).map((doc) => ({
+				id: doc.path,
+				content: doc.content,
+				metadata: {
+					package: packageName,
+					source: doc.path,
+					type: "doc"
+				}
+			}));
+			const issuesDoc = cachedDocs.find((doc) => doc.path === "github/RECENT-ISSUES.md");
+			if (issuesDoc) {
+				const issueBlocks = issuesDoc.content.split(/\n---\n/).filter(Boolean);
+				for (const block of issueBlocks) {
+					const match = block.match(/## #(\d+): (.+)/);
+					if (match) docsToIndex.push({
+						id: `issue-${match[1]}`,
+						content: block,
+						metadata: {
+							package: packageName,
+							source: "github/RECENT-ISSUES.md",
+							type: "issue",
+							number: Number(match[1])
+						}
+					});
+				}
+			}
+			const discussionsDoc = cachedDocs.find((doc) => doc.path === "github/RECENT-DISCUSSIONS.md");
+			if (discussionsDoc) {
+				const discussionBlocks = discussionsDoc.content.split(/\n---\n/).filter(Boolean);
+				for (const block of discussionBlocks) {
+					const match = block.match(/## #(\d+): (.+)/);
+					if (match) docsToIndex.push({
+						id: `discussion-${match[1]}`,
+						content: block,
+						metadata: {
+							package: packageName,
+							source: "github/RECENT-DISCUSSIONS.md",
+							type: "discussion",
+							number: Number(match[1])
+						}
+					});
+				}
+			}
+			await createIndex(docsToIndex, {
+				dbPath,
+				onProgress: (current, total, doc) => {
+					message(`Indexing ${doc?.type === "source" || doc?.type === "types" ? "code" : "doc"} ${doc?.id ? doc.id.split("/").pop() : ""} - ${current}/${total}`);
+				}
+			});
+			return `Indexed ${docsToIndex.length} docs`;
+		}
+	});
+	const pkgDir = resolvePkgDir(packageName, cwd, version);
+	const entryFiles = features.search && pkgDir ? await resolveEntryFiles(pkgDir) : [];
+	if (entryFiles.length > 0) {
+		const entryLabel = entryFiles.length === 1 ? entryFiles[0].path : `${entryFiles.length} entry files`;
+		indexTasks.push({
+			title: `Indexing ${entryLabel}`,
+			task: async (message) => {
+				await createIndex(entryFiles.map((e) => ({
+					id: e.path,
+					content: e.content,
+					metadata: {
+						package: packageName,
+						source: `pkg/${e.path}`,
+						type: e.type
+					}
+				})), {
+					dbPath,
+					onProgress: (current, total, doc) => {
+						message(`Indexing code ${doc?.id ? doc.id.split("/").pop() : ""} - ${current}/${total}`);
+					}
+				});
+				return `Indexed ${entryLabel}`;
+			}
 		});
 	}
-	return models;
+	if (indexTasks.length > 0) {
+		const idxSpin = p.spinner();
+		idxSpin.start("Creating search index");
+		const idxResults = [];
+		for (const task of indexTasks) {
+			idxSpin.message(task.title);
+			try {
+				const result = await task.task((msg) => idxSpin.message(msg));
+				idxResults.push({
+					msg: result,
+					status: result.startsWith("No ") ? "warn" : "ok"
+				});
+			} catch {
+				idxResults.push({
+					msg: `${task.title} failed`,
+					status: "error"
+				});
+			}
+		}
+		idxSpin.stop("Search index ready");
+		p.log.message(formatTaskResults(idxResults));
+	}
+	const cacheDir = getCacheDir(packageName, version);
+	if (useCache) {
+		if (existsSync(join(cacheDir, "docs", "index.md")) || existsSync(join(cacheDir, "docs", "guide"))) {
+			docSource = resolved.repoUrl ? `${resolved.repoUrl}/tree/v${version}/docs` : "git";
+			docsType = "docs";
+		} else if (existsSync(join(cacheDir, "llms.txt"))) {
+			docSource = resolved.llmsUrl || "llms.txt";
+			docsType = "llms.txt";
+		} else if (existsSync(join(cacheDir, "docs", "README.md"))) docsType = "readme";
+	}
+	const hasGithub = existsSync(join(getCacheDir(packageName, version), "github"));
+	const hasReleases = existsSync(releasesPath);
+	const hasChangelog = pkgDir ? ["CHANGELOG.md", "changelog.md"].find((f) => existsSync(join(pkgDir, f))) || false : false;
+	const relatedSkills = await findRelatedSkills(packageName, baseDir);
+	const shippedDocs = hasShippedDocs(packageName, cwd, version);
+	const pkgFiles = getPkgKeyFiles(packageName, cwd, version);
+	const baseSkillMd = generateSkillMd({
+		name: packageName,
+		version,
+		releasedAt: resolved.releasedAt,
+		description: resolved.description,
+		dependencies: resolved.dependencies,
+		distTags: resolved.distTags,
+		relatedSkills,
+		hasGithub,
+		hasReleases,
+		hasChangelog,
+		docsType,
+		hasShippedDocs: shippedDocs,
+		pkgFiles
+	});
+	writeFileSync(join(skillDir, "SKILL.md"), baseSkillMd);
+	writeLock(baseDir, sanitizeName(packageName), {
+		packageName,
+		version,
+		source: docSource,
+		syncedAt: (/* @__PURE__ */ new Date()).toISOString().split("T")[0],
+		generator: "skilld"
+	});
+	p.log.success(`Created base skill: ${relative(cwd, skillDir)}`);
+	if (!readConfig().skipLlm && (!config.yes || config.model)) {
+		const { sections, customPrompt, cancelled } = config.model ? {
+			sections: ["best-practices", "api"],
+			customPrompt: void 0,
+			cancelled: false
+		} : await selectSkillSections();
+		if (!cancelled && sections.length > 0) {
+			const model = config.model ?? await selectModel(false);
+			if (model) await enhanceSkillWithLLM({
+				packageName,
+				version,
+				skillDir,
+				model,
+				resolved,
+				relatedSkills,
+				hasGithub,
+				hasReleases,
+				hasChangelog,
+				docsType,
+				hasShippedDocs: shippedDocs,
+				pkgFiles,
+				force: config.force,
+				sections,
+				customPrompt
+			});
+		}
+	}
+	if (!config.global) registerProject(cwd);
+	await ensureGitignore(agent.skillsDir, cwd, config.global);
+	p.outro(`Synced ${packageName} to ${relative(cwd, skillDir)}`);
 }
-const OPTIMIZE_PROMPT = `You are a technical documentation optimizer for coding agents.
-
-Your task: Transform raw package documentation into a concise skill reference focused on what an AI coding assistant needs.
-
-## EXTRACT THESE (IMPORTANT):
-
-### 1. Public API Reference
-- All exported functions, components, composables with their signatures
-- Required vs optional parameters and their types
-- Return types and what they represent
-- Export names exactly as they should be imported
-
-### 2. Non-Obvious Best Practices
-- Gotchas and common mistakes developers make
-- Edge cases that cause bugs
-- Performance considerations (what's expensive, what to cache)
-- Order-of-operations requirements
-- Initialization patterns that aren't obvious
-- When NOT to use certain features
-
-### 3. Integration Patterns
-- How this integrates with common frameworks/tools
-- Required peer dependencies and version constraints
-- Configuration that's easy to get wrong
-
-## REMOVE THESE:
-- Installation instructions (npm install, etc.)
-- Badges, shields, contributor info
-- License information
-- Changelog/version history
-- Generic "what is this" introductions
-- Marketing language
-- Links to external resources (keep inline code examples)
-
-## OUTPUT FORMAT:
-Use clear markdown with code blocks. Be dense and direct - no filler. Prefer tables for API references.
-Organize as: Quick Reference → API → Best Practices → Gotchas
-
-## INPUT DOCUMENTATION:
-`;
-async function optimizeDocs(content, packageName, agent, model = "haiku") {
-	if (agent === "claude-code" || !agent) {
-		const result = await tryClaudeCode(content, packageName, model);
-		if (result) return {
-			optimized: result,
-			wasOptimized: true
-		};
+async function enhanceSkillWithLLM(opts) {
+	const { packageName, version, skillDir, model, resolved, relatedSkills, hasGithub, hasReleases, hasChangelog, docsType, hasShippedDocs: shippedDocs, pkgFiles, force, sections, customPrompt } = opts;
+	const llmSpin = p.spinner();
+	llmSpin.start(`Agent exploring ${packageName}`);
+	const { optimized, wasOptimized } = await optimizeDocs({
+		packageName,
+		skillDir,
+		model,
+		version,
+		hasGithub,
+		hasReleases,
+		hasChangelog,
+		docFiles: listReferenceFiles(skillDir),
+		noCache: force,
+		sections,
+		customPrompt,
+		onProgress: ({ type, chunk }) => {
+			if (type === "reasoning" && chunk.startsWith("[")) llmSpin.message(chunk);
+			else if (type === "text") llmSpin.message(`Writing...`);
+		}
+	});
+	if (wasOptimized) {
+		llmSpin.stop("Generated best practices");
+		const body = cleanSkillMd(optimized);
+		const skillMd = generateSkillMd({
+			name: packageName,
+			version,
+			releasedAt: resolved.releasedAt,
+			dependencies: resolved.dependencies,
+			distTags: resolved.distTags,
+			body,
+			relatedSkills,
+			hasGithub,
+			hasReleases,
+			hasChangelog,
+			docsType,
+			hasShippedDocs: shippedDocs,
+			pkgFiles
+		});
+		writeFileSync(join(skillDir, "SKILL.md"), skillMd);
+	} else llmSpin.stop("LLM optimization failed");
+}
+async function findRelatedSkills(packageName, skillsDir) {
+	const related = [];
+	const npmInfo = await fetchNpmPackage(packageName);
+	if (!npmInfo?.dependencies) return related;
+	const deps = Object.keys(npmInfo.dependencies);
+	if (!existsSync(skillsDir)) return related;
+	const installedSkills = readdirSync(skillsDir);
+	for (const skill of installedSkills) if (deps.some((d) => sanitizeName(d) === skill)) related.push(skill);
+	return related.slice(0, 5);
+}
+function cleanSkillMd(content) {
+	let cleaned = content.replace(/^```markdown\n?/m, "").replace(/\n?```$/m, "").trim();
+	const fmMatch = cleaned.match(/^-{3,}\n/);
+	if (fmMatch) {
+		const afterOpen = fmMatch[0].length;
+		const closeMatch = cleaned.slice(afterOpen).match(/\n-{3,}/);
+		if (closeMatch) cleaned = cleaned.slice(afterOpen + closeMatch.index + closeMatch[0].length).trim();
+		else cleaned = cleaned.slice(afterOpen).trim();
 	}
-	if (process.env.ANTHROPIC_API_KEY) {
-		const result = await tryAnthropicSDK(content, packageName, model);
-		if (result) return {
-			optimized: result,
-			wasOptimized: true
-		};
+	return cleaned;
+}
+async function uninstallCommand(opts) {
+	let scope = opts.scope;
+	const registeredProjects = getRegisteredProjects();
+	if (!scope) {
+		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;
 	}
-	return {
-		optimized: content,
-		wasOptimized: 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
+		});
 	};
-}
-async function tryClaudeCode(content, packageName, model) {
-	try {
-		execSync("which claude", { stdio: "ignore" });
-		const prompt = `${OPTIMIZE_PROMPT}\n\nPackage: ${packageName}\n\n${content}`;
-		const tempFile = `/tmp/skilld-optimize-${Date.now()}.txt`;
-		const { writeFileSync, unlinkSync } = await import("node:fs");
-		writeFileSync(tempFile, prompt);
-		try {
-			return execSync(`claude --model ${model} --print < "${tempFile}"`, {
-				encoding: "utf-8",
-				maxBuffer: 10 * 1024 * 1024,
-				timeout: 18e4
-			}).trim();
-		} finally {
-			unlinkSync(tempFile);
+	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);
+				}
+			}
+			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));
+	};
+	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
+		});
+	};
+	if (scope === "project") {
+		for (const [name, agent] of Object.entries(agents)) {
+			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 || "", "~");
+			for (const [name, agent] of Object.entries(agents)) {
+				if (agentFilter && !agentFilter.includes(name)) continue;
+				processSkillsDir(join(projectPath, agent.skillsDir), shortPath);
+			}
+			projectsToUnregister.push(projectPath);
+		}
+		for (const [name, agent] of Object.entries(agents)) {
+			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) {
+			if (!groupedUntracked.has(label)) groupedUntracked.set(label, /* @__PURE__ */ new Set());
+			for (const s of skills) groupedUntracked.get(label).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];
+		if (!groups.has(prefix)) groups.set(prefix, []);
+		groups.get(prefix).push({
+			name,
+			version: item.version
+		});
+	}
+	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) {
+		const confirmed = await p.confirm({ message: "Proceed with uninstall?" });
+		if (p.isCancel(confirmed) || !confirmed) {
+			p.cancel("Cancelled");
+			return;
 		}
-	} catch {
-		return null;
 	}
+	for (const item of toRemove) rmSync(item.path, {
+		recursive: true,
+		force: true
+	});
+	for (const [prefix, items] of groups) p.log.success(`Removed ${prefix}: ${formatGroup(items)}`);
+	if (scope !== "all") for (const proj of projectsToUnregister) unregisterProject(proj);
+	p.outro("skilld uninstalled");
 }
-const MODEL_MAP = {
-	haiku: "claude-3-5-haiku-latest",
-	sonnet: "claude-sonnet-4-20250514",
-	opus: "claude-opus-4-20250514"
-};
-async function tryAnthropicSDK(content, packageName, model) {
+function hasGhCli() {
+	if (process.env.SKILLD_NO_GH) return false;
 	try {
-		const { default: Anthropic } = await import("@anthropic-ai/sdk");
-		return (await new Anthropic().messages.create({
-			model: MODEL_MAP[model],
-			max_tokens: 8192,
-			messages: [{
-				role: "user",
-				content: `${OPTIMIZE_PROMPT}\n\nPackage: ${packageName}\n\n${content}`
-			}]
-		})).content.find((b) => b.type === "text")?.text || null;
+		execSync("gh --version", { stdio: "ignore" });
+		return true;
 	} catch {
-		return null;
+		return false;
+	}
+}
+async function runWizard() {
+	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
+			}
+		],
+		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 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 (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
+		});
+		if (p.isCancel(proceed) || !proceed) {
+			p.cancel("Setup cancelled");
+			process.exit(0);
+		}
+	}
+	updateConfig({
+		features,
+		...modelId ? { model: modelId } : { skipLlm: true }
+	});
+	p.outro("Thanks, you're all set! Change config anytime with `skilld config`.");
+}
+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 { version } = createRequire(import.meta.url)("../package.json");
+function getRepoHint(name, cwd) {
+	const pkgJsonPath = join(cwd, "node_modules", name, "package.json");
+	if (!existsSync(pkgJsonPath)) return void 0;
+	const pkg = JSON.parse(readFileSync(pkgJsonPath, "utf-8"));
+	const url = typeof pkg.repository === "string" ? pkg.repository : pkg.repository?.url;
+	if (!url) return void 0;
+	return url.replace(/^git\+/, "").replace(/\.git$/, "").replace(/^git:\/\//, "https://").replace(/^ssh:\/\/git@github\.com/, "https://github.com").replace(/^https?:\/\/(www\.)?github\.com\//, "");
+}
+function formatStatus(synced, outdated) {
+	const parts = [];
+	if (synced > 0) parts.push(`\x1B[32m${synced} synced\x1B[0m`);
+	if (outdated > 0) parts.push(`\x1B[33m${outdated} outdated\x1B[0m`);
+	return `Skills: ${parts.join(" · ")}`;
+}
+function relativeTime(date) {
+	const diff = Date.now() - date.getTime();
+	const mins = Math.floor(diff / 6e4);
+	const hours = Math.floor(diff / 36e5);
+	const days = Math.floor(diff / 864e5);
+	if (mins < 1) return "just now";
+	if (mins < 60) return `${mins}m ago`;
+	if (hours < 24) return `${hours}h ago`;
+	return `${days}d ago`;
+}
+function getLastSynced(state) {
+	let latest = null;
+	for (const skill of state.skills) if (skill.info?.syncedAt) {
+		const d = new Date(skill.info.syncedAt);
+		if (!latest || d > latest) latest = d;
+	}
+	return latest ? relativeTime(latest) : null;
+}
+const NOISE_CHARS = "⣿⡿⣷⣾⣽⣻⢿⡷⣯⣟⡾⣵⣳⢾⡽⣞⡷⣝⢯";
+function djb2(s) {
+	let h = 5381;
+	for (let i = 0; i < s.length; i++) h = (h << 5) + h + s.charCodeAt(i) >>> 0;
+	return h;
+}
+function hueToChannel(p, q, t) {
+	const t1 = t < 0 ? t + 1 : t > 1 ? t - 1 : t;
+	if (t1 < 1 / 6) return p + (q - p) * 6 * t1;
+	if (t1 < 1 / 2) return q;
+	if (t1 < 2 / 3) return p + (q - p) * (2 / 3 - t1) * 6;
+	return p;
+}
+function hsl(h, s, l) {
+	const q = l < .5 ? l * (1 + s) : l + s - l * s;
+	const p = 2 * l - q;
+	return [
+		Math.round(hueToChannel(p, q, h + 1 / 3) * 255),
+		Math.round(hueToChannel(p, q, h) * 255),
+		Math.round(hueToChannel(p, q, h - 1 / 3) * 255)
+	];
+}
+const BRAND_HUE = djb2(process.cwd()) % 360 / 360;
+function noiseChar(brightness, density = 0) {
+	if (brightness < .08) return " ";
+	const b = Math.min(brightness, 1);
+	const ch = Math.random() < density ? "⣿" : NOISE_CHARS[Math.floor(Math.random() * 19)];
+	const [r, g, bl] = hsl(BRAND_HUE, .4 + b * .15, .35 + b * .25);
+	return `\x1B[38;2;${r};${g};${bl}m${ch}`;
+}
+function noiseLine(len, brightnessFn, density = 0) {
+	let s = "";
+	for (let i = 0; i < len; i++) s += noiseChar(brightnessFn(i), density);
+	return `${s}\x1B[0m`;
+}
+function brandFrame(t, floor = 0, density = 0) {
+	const cx = 5;
+	const cy = 1;
+	const brightness = (x, y) => {
+		const d = Math.sqrt((x - cx) ** 2 + ((y - cy) * 3) ** 2);
+		let val = 0;
+		for (let ring = 0; ring < 3; ring++) {
+			const rt = t - ring * .5;
+			if (rt <= 0) continue;
+			const front = rt * 4;
+			const proximity = Math.abs(d - front);
+			val += Math.exp(-proximity * proximity * .8) * Math.exp(-rt * .4);
+		}
+		const base = Math.max(0, (t - 1.5) * .3) * (Math.random() * .3 + .1);
+		return Math.min(1, Math.max(floor, val + base));
+	};
+	return [
+		noiseLine(10, (x) => brightness(x, 0), density),
+		`${noiseLine(2, (x) => brightness(x, 1), density)} %NAME% ${noiseLine(2, (x) => brightness(x + 8, 1), density)} %VER%`,
+		noiseLine(10, (x) => brightness(x, 2), density)
+	].join("\n");
+}
+async function brandLoader(work, minMs = 1500) {
+	if (process.env.SKILLD_EFFECT === "none") return work();
+	const logUpdate = (await import("log-update")).default;
+	const name = "\x1B[1m\x1B[38;2;255;255;255mskilld\x1B[0m";
+	const ver = `\x1B[2mv${version}\x1B[0m`;
+	const status = "\x1B[2mSetting up your environment\x1B[0m";
+	const start = Date.now();
+	const sub = (raw) => raw.replace("%NAME%", name).replace("%VER%", ver);
+	let done = false;
+	const result = Promise.all([work(), new Promise((r) => setTimeout(r, minMs))]).then(([v]) => {
+		done = true;
+		return v;
+	});
+	while (!done) {
+		logUpdate(`\n  ${sub(brandFrame((Date.now() - start) / 1e3))}\n\n  ${status}`);
+		await new Promise((r) => setTimeout(r, 60));
+	}
+	const outroMs = 500;
+	const outroStart = Date.now();
+	const tFinal = (outroStart - start) / 1e3;
+	while (Date.now() - outroStart < outroMs) {
+		const p = (Date.now() - outroStart) / outroMs;
+		const eased = p * p;
+		logUpdate(`\n  ${sub(brandFrame(tFinal + p * .5, eased * .9, eased))}\n`);
+		await new Promise((r) => setTimeout(r, 40));
 	}
+	logUpdate(`\n  ${sub(brandFrame(tFinal + 1, .9, 1))}\n`);
+	logUpdate.done();
+	return result;
 }
-const main = defineCommand({
+function introLine({ state, generators, modelId }) {
+	const name = "\x1B[1m\x1B[35mskilld\x1B[0m";
+	const ver = `\x1B[90mv${version}\x1B[0m`;
+	const lastSynced = getLastSynced(state);
+	const synced = lastSynced ? ` · \x1B[90msynced ${lastSynced}\x1B[0m` : "";
+	const modelStr = modelId ? ` · ${getModelName(modelId)}` : "";
+	const genStr = generators?.length ? generators.map((g) => `${g.name} v${g.version}`).join(", ") : "";
+	return `${name} ${ver}${synced}${genStr ? `\n\x1B[90m↳ ${genStr}${modelStr}\x1B[0m` : ""}`;
+}
+function getInstalledGenerators() {
+	return detectInstalledAgents().filter((id) => agents[id].cli).map((id) => {
+		const version = getAgentVersion(id);
+		return version ? {
+			name: agents[id].displayName,
+			version
+		} : null;
+	}).filter((a) => a !== null);
+}
+async function prepareSync(cwd, agentFlag) {
+	const agent = resolveAgent(agentFlag);
+	if (!agent) return;
+	const state = await getProjectState(cwd);
+	if (state.outdated.length === 0) {
+		p.log.success("Skills up to date");
+		return;
+	}
+	await syncCommand(state, {
+		packages: state.outdated.map((s) => s.packageName || s.name),
+		global: false,
+		agent,
+		yes: true
+	});
+}
+function resolveAgent(agentFlag) {
+	return agentFlag ?? detectTargetAgent() ?? readConfig().agent ?? null;
+}
+const sharedArgs = {
+	global: {
+		type: "boolean",
+		alias: "g",
+		description: "Install globally to ~/.claude/skills",
+		default: false
+	},
+	agent: {
+		type: "string",
+		alias: "a",
+		description: "Agent where skills are installed (claude-code, cursor, windsurf, etc.)"
+	},
+	yes: {
+		type: "boolean",
+		alias: "y",
+		description: "Skip prompts, use defaults",
+		default: false
+	},
+	force: {
+		type: "boolean",
+		alias: "f",
+		description: "Ignore all caches, re-fetch docs and regenerate",
+		default: false
+	}
+};
+const SUBCOMMAND_NAMES = [
+	"add",
+	"update",
+	"status",
+	"config",
+	"remove",
+	"install",
+	"uninstall",
+	"search"
+];
+const addCommand = defineCommand({
 	meta: {
-		name: "skilld",
-		description: "Generate searchable skills from documentation sites or package.json dependencies"
+		name: "add",
+		description: "Add skills for package(s)"
 	},
 	args: {
-		url: {
+		package: {
 			type: "positional",
-			description: "URL or package name (omit to process package.json deps)",
-			required: false
-		},
-		output: {
-			type: "string",
-			alias: "o",
-			description: "Output directory (legacy mode)"
+			description: "Package(s) to sync, comma-separated (e.g., vue,nuxt,pinia)",
+			required: true
 		},
-		maxPages: {
-			type: "string",
-			alias: "m",
-			description: "Max pages to fetch",
-			default: "100"
-		},
-		chunkSize: {
-			type: "string",
-			description: "Chunk size in characters",
-			default: "1000"
-		},
-		model: {
-			type: "string",
-			description: "Embedding model",
-			default: "Xenova/bge-small-en-v1.5"
+		...sharedArgs
+	},
+	async run({ args }) {
+		const cwd = process.cwd();
+		const agent = resolveAgent(args.agent);
+		if (!agent) {
+			p.log.warn("Could not detect agent. Use --agent <name>");
+			return;
+		}
+		const state = await getProjectState(cwd);
+		p.intro(introLine({ state }));
+		return syncCommand(state, {
+			packages: args.package.split(",").map((s) => s.trim()).filter(Boolean),
+			global: args.global,
+			agent,
+			yes: args.yes,
+			force: args.force
+		});
+	}
+});
+const updateSubCommand = defineCommand({
+	meta: {
+		name: "update",
+		description: "Update outdated skills"
+	},
+	args: {
+		package: {
+			type: "positional",
+			description: "Package(s) to update, comma-separated. Without args, syncs all outdated.",
+			required: false
 		},
-		crawl: {
-			type: "boolean",
-			description: "Skip llms.txt and always crawl",
-			default: false
+		...sharedArgs
+	},
+	async run({ args }) {
+		const cwd = process.cwd();
+		const agent = resolveAgent(args.agent);
+		if (!agent) {
+			p.log.warn("Could not detect agent. Use --agent <name>");
+			return;
+		}
+		const state = await getProjectState(cwd);
+		const generators = getInstalledGenerators();
+		const config = readConfig();
+		p.intro(introLine({
+			state,
+			generators,
+			modelId: config.model
+		}));
+		if (args.package) return syncCommand(state, {
+			packages: args.package.split(",").map((s) => s.trim()).filter(Boolean),
+			global: args.global,
+			agent,
+			yes: args.yes,
+			force: args.force
+		});
+		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,
+			yes: args.yes,
+			force: args.force
+		});
+	}
+});
+const statusSubCommand = defineCommand({
+	meta: {
+		name: "status",
+		description: "Show skill status"
+	},
+	args: { global: sharedArgs.global },
+	run({ args }) {
+		return statusCommand({ global: args.global });
+	}
+});
+const configSubCommand = defineCommand({
+	meta: {
+		name: "config",
+		description: "Edit settings"
+	},
+	args: {},
+	async run() {
+		const state = await getProjectState(process.cwd());
+		const generators = getInstalledGenerators();
+		const config = readConfig();
+		p.intro(introLine({
+			state,
+			generators,
+			modelId: config.model
+		}));
+		return configCommand();
+	}
+});
+const removeSubCommand = defineCommand({
+	meta: {
+		name: "remove",
+		description: "Remove installed skills"
+	},
+	args: { ...sharedArgs },
+	async run({ args }) {
+		const cwd = process.cwd();
+		const agent = resolveAgent(args.agent);
+		if (!agent) {
+			p.log.warn("Could not detect agent. Use --agent <name>");
+			return;
+		}
+		const state = await getProjectState(cwd);
+		const generators = getInstalledGenerators();
+		const config = readConfig();
+		const scope = args.global ? "global" : "project";
+		const intro = {
+			state,
+			generators,
+			modelId: config.model
+		};
+		p.intro(`${introLine(intro)} · remove (${scope})`);
+		return removeCommand(state, {
+			global: args.global,
+			agent,
+			yes: args.yes
+		});
+	}
+});
+const installSubCommand = defineCommand({
+	meta: {
+		name: "install",
+		description: "Restore references from lockfile"
+	},
+	args: {
+		global: sharedArgs.global,
+		agent: sharedArgs.agent
+	},
+	async run({ args }) {
+		const agent = resolveAgent(args.agent);
+		if (!agent) {
+			p.log.warn("Could not detect agent. Use --agent <name>");
+			return;
+		}
+		p.intro(`\x1B[1m\x1B[35mskilld\x1B[0m install`);
+		return installCommand({
+			global: args.global,
+			agent
+		});
+	}
+});
+const uninstallSubCommand = 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 searchSubCommand = defineCommand({
+	meta: {
+		name: "search",
+		description: "Search indexed docs"
+	},
+	args: {
+		query: {
+			type: "positional",
+			description: "Search query (e.g., \"useFetch options\")",
+			required: true
 		},
-		concurrency: {
+		package: {
 			type: "string",
-			alias: "c",
-			description: "Concurrent package processing",
-			default: "3"
-		},
-		global: {
+			alias: "p",
+			description: "Filter by package name"
+		}
+	},
+	async run({ args }) {
+		return searchCommand(args.query, args.package || void 0);
+	}
+});
+runMain(defineCommand({
+	meta: {
+		name: "skilld",
+		description: "Sync package documentation for agentic use"
+	},
+	args: {
+		prepare: {
 			type: "boolean",
-			alias: "g",
-			description: "Install skills globally",
+			description: "Non-interactive sync for pnpm prepare hook (outdated only, no LLM, always exits 0)",
 			default: false
 		},
-		agent: {
-			type: "string",
-			alias: "a",
-			description: "Target specific agent (claude-code, cursor, windsurf, etc.)"
-		},
-		force: {
+		background: {
 			type: "boolean",
-			alias: "f",
-			description: "Force regenerate even if version matches",
+			alias: "b",
+			description: "Run --prepare in background (detached process)",
 			default: false
 		},
-		optimize: {
-			type: "boolean",
-			description: "Optimize docs with LLM (extracts APIs & best practices)",
-			default: true
-		},
-		yes: {
-			type: "boolean",
-			alias: "y",
-			description: "Skip prompts, use defaults",
-			default: false
-		}
+		agent: sharedArgs.agent
+	},
+	subCommands: {
+		add: addCommand,
+		update: updateSubCommand,
+		status: statusSubCommand,
+		config: configSubCommand,
+		remove: removeSubCommand,
+		install: installSubCommand,
+		uninstall: uninstallSubCommand,
+		search: searchSubCommand
 	},
 	async run({ args }) {
-		const maxPages = Number.parseInt(args.maxPages, 10);
-		const chunkSize = Number.parseInt(args.chunkSize, 10);
-		const concurrency = Number.parseInt(args.concurrency, 10);
-		const currentAgent = detectCurrentAgent();
-		if (!currentAgent && !args.agent && !args.output) {
-			consola.warn("Could not detect which agent is running. Use --agent <name> or --output <dir>");
-			consola.info("Supported agents: " + Object.keys(agents).join(", "));
-			return;
-		}
-		const targetAgents = args.agent ? [args.agent] : currentAgent ? [currentAgent] : [];
-		if (targetAgents.length > 0) consola.info(`Target agent: ${targetAgents.map((a) => agents[a].displayName).join(", ")}`);
-		if (args.url) {
-			await processUrl(args.url, {
-				outputDir: args.output,
-				maxPages,
-				chunkSize,
-				skipLlmsTxt: args.crawl,
-				model: args.model,
-				global: args.global,
-				agents: targetAgents,
-				optimize: args.optimize,
-				currentAgent
-			});
+		const firstArg = process.argv[2];
+		if (firstArg && !firstArg.startsWith("-") && SUBCOMMAND_NAMES.includes(firstArg)) return;
+		const cwd = process.cwd();
+		if (args.prepare) {
+			if (args.background) {
+				const { spawn } = await import("node:child_process");
+				spawn(process.execPath, [
+					process.argv[1],
+					"--prepare",
+					...args.agent ? ["--agent", args.agent] : []
+				], {
+					cwd,
+					detached: true,
+					stdio: "ignore"
+				}).unref();
+				return;
+			}
+			await prepareSync(cwd, args.agent).catch(() => {});
 			return;
 		}
-		consola.start("Reading package.json dependencies...");
-		const allDeps = await readLocalDependencies(process.cwd());
-		if (allDeps.length === 0) {
-			consola.warn("No dependencies found in package.json");
+		const currentAgent = resolveAgent(args.agent);
+		if (!currentAgent) {
+			p.log.warn("Could not detect agent. Use --agent <name> or `skilld config`");
+			p.log.info(`Supported: ${Object.keys(agents).join(", ")}`);
 			return;
 		}
-		const needsUpdate = [];
-		const upToDate = [];
-		for (const dep of allDeps) {
-			if (args.force) {
-				needsUpdate.push(dep);
-				continue;
+		const { state, selfUpdate } = await brandLoader(async () => {
+			const config = readConfig();
+			const state = await getProjectState(cwd);
+			let selfUpdate = null;
+			const tasks = [];
+			if (!(process.env.npm_command === "exec")) tasks.push(fetchNpmRegistryMeta("skilld", version).then((meta) => {
+				const latestTag = meta.distTags?.latest;
+				if (latestTag && latestTag.version !== version) selfUpdate = {
+					latest: latestTag.version,
+					releasedAt: latestTag.releasedAt
+				};
+			}).catch(() => {}));
+			if (state.unmatched.length > 0) {
+				const limit = pLimit(5);
+				tasks.push(Promise.all(state.unmatched.map((skill) => limit(async () => {
+					const pkgName = skill.info?.packageName || skill.name;
+					const latest = await fetchLatestVersion(pkgName);
+					if (latest && isOutdated(skill, latest)) state.outdated.push({
+						...skill,
+						packageName: pkgName,
+						latestVersion: latest
+					});
+					else if (latest) state.synced.push({
+						...skill,
+						packageName: pkgName,
+						latestVersion: latest
+					});
+				}))).then(() => {}));
 			}
-			if (targetAgents.length > 0) {
-				const agent = agents[targetAgents[0]];
-				const installedVersion = await getInstalledSkillVersion(join(process.cwd(), agent.skillsDir, sanitizeName(dep.name)));
-				if (installedVersion && installedVersion === dep.version) upToDate.push(dep);
-				else needsUpdate.push(dep);
-			} else needsUpdate.push(dep);
-		}
-		if (needsUpdate.length === 0) {
-			consola.success(`All ${allDeps.length} skills are up-to-date`);
-			return;
+			await Promise.all(tasks);
+			return {
+				config,
+				state,
+				selfUpdate
+			};
+		});
+		if (selfUpdate) {
+			const released = selfUpdate.releasedAt ? `\x1B[90m · ${relativeTime(new Date(selfUpdate.releasedAt))}\x1B[0m` : "";
+			const cmd = `npx nypm add${realpathSync(process.argv[1]).startsWith(resolve(cwd, "node_modules")) ? "" : " -g"} skilld@${selfUpdate.latest}`;
+			p.note(`\x1B[90m${version}\x1B[0m → \x1B[1m\x1B[32m${selfUpdate.latest}\x1B[0m${released}\n\x1B[36m${cmd}\x1B[0m`, "\x1B[33mUpdate available\x1B[0m");
 		}
-		consola.info(`Found ${needsUpdate.length} packages to sync (${upToDate.length} up-to-date)`);
-		let selectedDeps = needsUpdate;
-		if (!args.yes && needsUpdate.length > 1) {
-			const choices = needsUpdate.map((d) => ({
-				label: `${d.name}@${d.version}`,
-				value: d.name
-			}));
-			const selected = await consola.prompt("Select packages to sync:", {
-				type: "multiselect",
-				options: choices,
-				initial: choices.map((c) => c.value)
+		if (state.skills.length === 0) {
+			if (!hasConfig()) await runWizard();
+			const pkgJsonPath = join(cwd, "package.json");
+			const projectName = existsSync(pkgJsonPath) ? JSON.parse(readFileSync(pkgJsonPath, "utf-8")).name : void 0;
+			const projectLabel = projectName ? `Generating skills for \x1B[36m${projectName}\x1B[0m` : "Generating skills for current directory";
+			p.log.step(projectLabel);
+			p.log.info("Tip: Only generate skills for packages your agent struggles with.\n     The fewer skills, the more context you have for everything else :)");
+			const source = await p.select({
+				message: "How should I find packages?",
+				options: [
+					{
+						label: "Scan source files",
+						value: "imports",
+						hint: "Find actually used imports"
+					},
+					{
+						label: "Use package.json",
+						value: "deps",
+						hint: `All ${state.deps.size} dependencies`
+					},
+					{
+						label: "Enter manually",
+						value: "manual"
+					}
+				]
 			});
-			if (!selected || selected.length === 0) {
-				consola.warn("No packages selected");
+			if (p.isCancel(source)) {
+				p.cancel("Setup cancelled");
 				return;
 			}
-			selectedDeps = needsUpdate.filter((d) => selected.includes(d.name));
-		}
-		let optimizeModel = null;
-		if (args.optimize && !args.yes) {
-			const availableModels = await getAvailableModels();
-			if (availableModels.length > 0) {
-				const modelChoice = await consola.prompt("Optimize with LLM?", {
-					type: "select",
-					options: [...availableModels.map((m) => ({
-						label: `${m.name} ${m.available ? "(available)" : ""}`,
-						value: m.id,
-						hint: m.description
-					})), {
-						label: "Skip optimization",
-						value: "skip"
-					}],
-					initial: availableModels[0]?.id || "skip"
+			let selected;
+			if (source === "manual") {
+				const input = await p.text({
+					message: "Enter package names (comma-separated)",
+					placeholder: "vue, nuxt, pinia"
 				});
-				optimizeModel = modelChoice === "skip" ? null : modelChoice;
-			}
-		} else if (args.optimize) optimizeModel = "haiku";
-		const queue = [...selectedDeps];
-		let processed = 0;
-		let failed = 0;
-		const worker = async () => {
-			while (queue.length > 0) {
-				const dep = queue.shift();
-				if (!dep) break;
-				const { name: packageName, version: localVersion } = dep;
-				try {
-					consola.start(`[${processed + failed + 1}/${selectedDeps.length}] ${packageName}@${localVersion}`);
-					const resolved = await resolvePackageDocs(packageName);
-					if (!resolved) {
-						consola.warn(`  No docs found for ${packageName}`);
-						failed++;
-						continue;
-					}
-					const url = resolved.llmsUrl || resolved.docsUrl || resolved.readmeUrl;
-					if (!url) {
-						consola.warn(`  No URL resolved for ${packageName}`);
-						failed++;
-						continue;
+				if (p.isCancel(input) || !input) {
+					p.cancel("No packages entered");
+					return;
+				}
+				selected = input.split(",").map((s) => s.trim()).filter(Boolean);
+			} else {
+				let usages;
+				if (source === "imports") {
+					const spinner = p.spinner();
+					spinner.start("Scanning imports...");
+					const result = await detectImportedPackages(cwd);
+					spinner.stop(`Found ${result.packages.length} imported packages`);
+					if (result.packages.length === 0) {
+						p.log.warn("No imports found, falling back to package.json");
+						usages = [...state.deps.keys()].map((name) => ({
+							name,
+							count: 0
+						}));
+					} else {
+						const depSet = new Set(state.deps.keys());
+						usages = result.packages.filter((pkg) => depSet.has(pkg.name) || pkg.source === "preset");
+						if (usages.length === 0) {
+							p.log.warn("No matching dependencies, using all imports");
+							usages = result.packages;
+						}
 					}
-					await processUrl(url, {
-						outputDir: args.output,
-						maxPages,
-						chunkSize,
-						skipLlmsTxt: args.crawl,
-						model: args.model,
-						global: args.global,
-						agents: targetAgents,
-						packageName,
-						packageVersion: localVersion,
-						quiet: true,
-						optimize: !!optimizeModel,
-						optimizeModel,
-						currentAgent
-					});
-					processed++;
-					consola.success(`  Generated skill for ${packageName}@${localVersion}`);
-				} catch (e) {
-					consola.error(`  Failed: ${e.message}`);
-					failed++;
+				} else usages = [...state.deps.keys()].map((name) => ({
+					name,
+					count: 0
+				}));
+				const packages = usages.map((u) => u.name);
+				const sourceMap = new Map(usages.map((u) => [u.name, u.source]));
+				const maxLen = Math.max(...packages.map((n) => n.length));
+				const choice = await p.multiselect({
+					message: `Select packages (${packages.length} found)`,
+					options: packages.map((name) => {
+						const ver = state.deps.get(name)?.replace(/^[\^~>=<]/, "") || "";
+						const repo = getRepoHint(name, cwd);
+						const hint = sourceMap.get(name) === "preset" ? "nuxt module" : void 0;
+						const pad = " ".repeat(maxLen - name.length + 2);
+						const meta = [
+							ver,
+							hint,
+							repo
+						].filter(Boolean).join("  ");
+						return {
+							label: meta ? `${name}${pad}\x1B[90m${meta}\x1B[39m` : name,
+							value: name
+						};
+					}),
+					initialValues: packages
+				});
+				if (p.isCancel(choice) || choice.length === 0) {
+					p.cancel("No packages selected");
+					return;
 				}
+				selected = choice;
 			}
-		};
-		await Promise.all(Array.from({ length: concurrency }, () => worker()));
-		consola.box(`Generated ${processed} skills (${upToDate.length} up-to-date, ${failed} failed)`);
-	}
-});
-async function processUrl(url, config) {
-	let resolvedUrl = url;
-	let skillName = config.packageName;
-	let skillVersion = config.packageVersion;
-	let isRawReadme = false;
-	let description = "";
-	if (!url.includes("://") && !url.startsWith("http")) {
-		if (!config.quiet) consola.start(`Resolving docs for package: ${url}`);
-		skillName = url;
-		const resolved = await resolvePackageDocs(url);
-		if (!resolved) {
-			consola.error(`Could not find docs for package: ${url}`);
-			return;
-		}
-		description = resolved.description || "";
-		skillVersion = skillVersion || resolved.version;
-		if (resolved.llmsUrl) resolvedUrl = resolved.llmsUrl;
-		else if (resolved.docsUrl) resolvedUrl = resolved.docsUrl;
-		else if (resolved.readmeUrl) {
-			resolvedUrl = resolved.readmeUrl;
-			isRawReadme = true;
-		} else {
-			consola.error(`No documentation found for ${url}`);
-			return;
+			return syncCommand(state, {
+				packages: selected,
+				global: false,
+				agent: currentAgent,
+				yes: false
+			});
 		}
-		if (!config.quiet) consola.info(`Resolved to: ${resolvedUrl}${isRawReadme ? " (README)" : ""}`);
-	}
-	if (isRawReadme || resolvedUrl.includes("raw.githubusercontent.com") || resolvedUrl.startsWith("ungh://")) {
-		if (!config.quiet) consola.start(`Fetching README for ${skillName || "package"}`);
-		let readmeContent;
-		if (resolvedUrl.startsWith("ungh://")) {
-			const parts = resolvedUrl.replace("ungh://", "").split("/");
-			const owner = parts[0];
-			const repo = parts[1];
-			const subdir = parts.slice(2).join("/");
-			const unghUrl = subdir ? `https://ungh.cc/repos/${owner}/${repo}/files/main/${subdir}/README.md` : `https://ungh.cc/repos/${owner}/${repo}/readme`;
-			const res = await fetch(unghUrl, { headers: { "User-Agent": "skilld/1.0" } }).catch(() => null);
-			if (!res?.ok) {
-				consola.error(`Failed to fetch README from ungh: ${res?.status}`);
+		const status = formatStatus(state.synced.length, state.outdated.length);
+		p.log.info(status);
+		while (true) {
+			const options = [];
+			options.push({
+				label: "Add new skills",
+				value: "install"
+			});
+			if (state.outdated.length > 0) options.push({
+				label: "Update skills",
+				value: "update",
+				hint: `\x1B[33m${state.outdated.length} outdated\x1B[0m`
+			});
+			options.push({
+				label: "Remove skills",
+				value: "remove"
+			}, {
+				label: "Status",
+				value: "status"
+			}, {
+				label: "Configure",
+				value: "config"
+			});
+			const action = await p.select({
+				message: "What would you like to do?",
+				options
+			});
+			if (p.isCancel(action)) {
+				p.cancel("Cancelled");
 				return;
 			}
-			const text = await res.text();
-			try {
-				const json = JSON.parse(text);
-				readmeContent = json.markdown || json.file?.contents || "";
-			} catch {
-				readmeContent = text;
-			}
-		} else {
-			const res = await fetch(resolvedUrl, { headers: { "User-Agent": "skilld/1.0" } }).catch(() => null);
-			if (!res?.ok) {
-				consola.error(`Failed to fetch README: ${res?.status}`);
-				return;
+			switch (action) {
+				case "install": {
+					const installedNames = new Set(state.skills.map((s) => s.packageName || s.name));
+					const uninstalledDeps = [...state.deps.keys()].filter((d) => !installedNames.has(d));
+					const allDepsInstalled = uninstalledDeps.length === 0;
+					const source = await p.select({
+						message: "How should I find packages?",
+						options: [
+							{
+								label: "Scan source files",
+								value: "imports",
+								hint: allDepsInstalled ? "all installed" : "find actually used imports",
+								disabled: allDepsInstalled
+							},
+							{
+								label: "Use package.json",
+								value: "deps",
+								hint: allDepsInstalled ? "all installed" : `${uninstalledDeps.length} uninstalled`,
+								disabled: allDepsInstalled
+							},
+							{
+								label: "Enter manually",
+								value: "manual"
+							}
+						]
+					});
+					if (p.isCancel(source)) continue;
+					let selected;
+					if (source === "manual") {
+						const input = await p.text({
+							message: "Enter package names (comma-separated)",
+							placeholder: "vue, nuxt, pinia"
+						});
+						if (p.isCancel(input) || !input) continue;
+						selected = input.split(",").map((s) => s.trim()).filter(Boolean);
+						if (selected.length === 0) continue;
+					} else {
+						let usages;
+						if (source === "imports") {
+							const spinner = p.spinner();
+							spinner.start("Scanning imports...");
+							const result = await detectImportedPackages(cwd);
+							spinner.stop(`Found ${result.packages.length} imported packages`);
+							if (result.packages.length === 0) {
+								p.log.warn("No imports found, falling back to package.json");
+								usages = uninstalledDeps.map((name) => ({
+									name,
+									count: 0
+								}));
+							} else {
+								const depSet = new Set(state.deps.keys());
+								usages = result.packages.filter((pkg) => depSet.has(pkg.name) || pkg.source === "preset").filter((pkg) => !installedNames.has(pkg.name));
+								if (usages.length === 0) {
+									p.log.warn("All detected imports already have skills");
+									continue;
+								}
+							}
+						} else usages = uninstalledDeps.map((name) => ({
+							name,
+							count: 0
+						}));
+						const packages = usages.map((u) => u.name);
+						const sourceMap = new Map(usages.map((u) => [u.name, u.source]));
+						const maxLen = Math.max(...packages.map((n) => n.length));
+						const choice = await p.multiselect({
+							message: `Select packages (${packages.length} found)`,
+							options: packages.map((name) => {
+								const ver = state.deps.get(name)?.replace(/^[\^~>=<]/, "") || "";
+								const repo = getRepoHint(name, cwd);
+								const hint = sourceMap.get(name) === "preset" ? "nuxt module" : void 0;
+								const pad = " ".repeat(maxLen - name.length + 2);
+								const meta = [
+									ver,
+									hint,
+									repo
+								].filter(Boolean).join("  ");
+								return {
+									label: meta ? `${name}${pad}\x1B[90m${meta}\x1B[39m` : name,
+									value: name
+								};
+							}),
+							initialValues: packages
+						});
+						if (p.isCancel(choice) || choice.length === 0) continue;
+						selected = choice;
+					}
+					return syncCommand(state, {
+						packages: selected,
+						global: false,
+						agent: currentAgent,
+						yes: false
+					});
+				}
+				case "update": {
+					if (state.outdated.length === 0) {
+						p.log.success("All skills up to date");
+						return;
+					}
+					const selected = await p.multiselect({
+						message: "Select packages to update",
+						options: state.outdated.map((s) => ({
+							label: s.name,
+							value: s.packageName || s.name,
+							hint: `${s.info?.version ?? "unknown"} → ${s.latestVersion}`
+						})),
+						initialValues: state.outdated.map((s) => s.packageName || s.name)
+					});
+					if (p.isCancel(selected) || selected.length === 0) continue;
+					return syncCommand(state, {
+						packages: selected,
+						global: false,
+						agent: currentAgent,
+						yes: false
+					});
+				}
+				case "remove":
+					await removeCommand(state, {
+						global: false,
+						agent: currentAgent,
+						yes: false
+					});
+					continue;
+				case "status":
+					await statusCommand({ global: false });
+					continue;
+				case "config":
+					await configCommand();
+					continue;
 			}
-			readmeContent = await res.text();
-		}
-		if (!readmeContent) {
-			consola.error("README content is empty");
-			return;
 		}
-		const name = skillName || "package";
-		let finalContent = readmeContent;
-		if (config.optimize !== false && config.optimizeModel) {
-			!config.quiet && consola.start(`Optimizing ${name} with ${config.optimizeModel}...`);
-			const { optimized, wasOptimized } = await optimizeDocs(readmeContent, name, config.currentAgent || null, config.optimizeModel);
-			finalContent = optimized;
-			if (!config.quiet && wasOptimized) consola.success(`Optimized: ${readmeContent.length} → ${optimized.length} chars`);
-			else if (!config.quiet && !wasOptimized) consola.warn(`Optimization skipped (no LLM available)`);
-		}
-		const { installed, paths } = installSkillForAgents(name, generateSkillMd({
-			name,
-			version: skillVersion,
-			description
-		}, finalContent), {
-			global: config.global,
-			agents: config.agents
-		});
-		if (!config.quiet) {
-			consola.success(`Installed skill: ${name}`);
-			consola.info(`  Agents: ${installed.map((a) => agents[a].displayName).join(", ")}`);
-			consola.info(`  Paths: ${paths.join(", ")}`);
-		}
-		return;
-	}
-	if (!config.quiet) consola.start(`Generating skill from ${resolvedUrl}`);
-	if (config.outputDir) {
-		const result = await generateSkill({
-			url: resolvedUrl,
-			outputDir: config.outputDir,
-			maxPages: config.maxPages,
-			chunkSize: config.chunkSize,
-			skipLlmsTxt: config.skipLlmsTxt,
-			model: config.model
-		}, config.quiet ? void 0 : ({ url: pageUrl, count, phase }) => {
-			const icon = phase === "fetch" ? "📄" : "🔍";
-			consola.info(`${icon} [${count}] ${pageUrl}`);
-		});
-		if (!config.quiet) {
-			consola.success(`Generated skill: ${result.siteName}`);
-			consola.info(`  SKILL.md: ${result.skillPath}`);
-			consola.info(`  References: ${result.referencesDir}`);
-			consola.info(`  Database: ${result.dbPath}`);
-			consola.info(`  Chunks: ${result.chunkCount}`);
-		}
-		return;
-	}
-	const result = await generateSkill({
-		url: resolvedUrl,
-		outputDir: ".skilld-temp",
-		maxPages: config.maxPages,
-		chunkSize: config.chunkSize,
-		skipLlmsTxt: config.skipLlmsTxt,
-		model: config.model
-	}, config.quiet ? void 0 : ({ url: pageUrl, count, phase }) => {
-		if (phase === "fetch" && count % 5 === 0) consola.info(`  [${count}] ${pageUrl}`);
-	});
-	const name = skillName || result.siteName;
-	const body = `# ${name}
-
-This skill provides searchable documentation for ${name}.
-
-## Search Database
-- Path: ${result.dbPath}
-- Chunks indexed: ${result.chunkCount}
-
-## References
-Individual documentation chunks are available in the references directory.
-`;
-	const { installed, paths } = installSkillForAgents(name, generateSkillMd({
-		name,
-		version: skillVersion,
-		description
-	}, body), {
-		global: config.global,
-		agents: config.agents
-	});
-	if (!config.quiet) {
-		consola.success(`Installed skill: ${name}`);
-		consola.info(`  Agents: ${installed.map((a) => agents[a].displayName).join(", ")}`);
-		consola.info(`  Paths: ${paths.join(", ")}`);
-		consola.info(`  Chunks: ${result.chunkCount}`);
 	}
-}
-runMain(main);
-export {};
+}));
+export { defaultFeatures as a, writeLock as i, selectModel as n, readConfig as o, selectSkillSections as r, registerProject as s, ensureGitignore as t };
 
 //# sourceMappingURL=cli.mjs.map