skilld 0.4.0 → 0.4.1

package/dist/cli.mjs

@@ -1,23 +1,23 @@
 #!/usr/bin/env node
 import { _ as detectInstalledAgents, a as optimizeDocs, b as targets, c as computeSkillDirName, f as unlinkSkillFromAgents, i as getModelName, n as getAvailableModels, o as generateSkillMd, r as getModelLabel, t as detectImportedPackages, u as linkSkillToAgents, v as detectTargetAgent, y as getAgentVersion } from "./_chunks/detect-imports.mjs";
 import { i as getCacheDir, o as getVersionKey, r as getPackageDbPath, t as CACHE_DIR } from "./_chunks/config.mjs";
-import { n as sanitizeMarkdown } from "./_chunks/sanitize2.mjs";
-import { a as getShippedSkills, c as linkCachedDir, d as linkShippedSkill, g as resolvePkgDir, i as getPkgKeyFiles, l as linkPkg, m as readCachedDocs, n as clearCache, o as hasShippedDocs, p as listReferenceFiles, r as ensureCacheDir, s as isCached, u as linkPkgNamed, v as writeToCache } from "./_chunks/storage.mjs";
+import { a as getShippedSkills, b as sanitizeMarkdown, c as linkCachedDir, d as linkShippedSkill, g as resolvePkgDir, i as getPkgKeyFiles, l as linkPkg, m as readCachedDocs, n as clearCache, o as hasShippedDocs, p as listReferenceFiles, r as ensureCacheDir, s as isCached, u as linkPkgNamed, v as writeToCache } from "./_chunks/storage.mjs";
 import "./cache/index.mjs";
 import { closePool, createIndex, openPool, searchPooled, searchSnippets } from "./retriv/index.mjs";
-import { C as fetchGitDocs, D as isShallowGitDocs, E as fetchReadmeContent, F as fetchGitHubIssues, I as formatIssueAsMarkdown, L as generateIssueIndex, M as fetchGitHubDiscussions, N as formatDiscussionAsMarkdown, P as generateDiscussionIndex, R as isGhAvailable, a as fetchNpmRegistryMeta, b as normalizeLlmsLinks, f as resolveLocalPackageDocs, g as downloadLlmsDocs, h as searchNpmPackages, i as fetchNpmPackage, j as resolveEntryFiles, l as readLocalDependencies, m as resolvePackageDocsWithAttempts, o as fetchPkgDist, p as resolvePackageDocs, r as fetchLatestVersion, t as fetchReleaseNotes, v as fetchLlmsTxt } from "./_chunks/releases.mjs";
+import { C as fetchGitDocs, D as isShallowGitDocs, E as fetchReadmeContent, G as fetchGitHubIssues, H as fetchGitHubDiscussions, J as isGhAvailable, K as formatIssueAsMarkdown, M as parseGitSkillInput, P as $fetch, U as formatDiscussionAsMarkdown, V as resolveEntryFiles, W as generateDiscussionIndex, a as fetchNpmRegistryMeta, b as normalizeLlmsLinks, f as resolveLocalPackageDocs, g as downloadLlmsDocs, h as searchNpmPackages, i as fetchNpmPackage, j as fetchGitSkills, l as readLocalDependencies, m as resolvePackageDocsWithAttempts, o as fetchPkgDist, p as resolvePackageDocs, q as generateIssueIndex, r as fetchLatestVersion, t as fetchReleaseNotes, v as fetchLlmsTxt, z as parseGitHubUrl } from "./_chunks/releases.mjs";
 import { n as yamlParseKV, r as yamlUnescape, t as yamlEscape } from "./_chunks/yaml.mjs";
-import { a as $fetch, d as parseGitHubUrl } from "./_chunks/git-skills.mjs";
 import "./sources/index.mjs";
 import "./agent/index.mjs";
+import { n as shutdownWorker } from "./_chunks/pool2.mjs";
 import { createRequire } from "node:module";
 import { homedir } from "node:os";
-import { join, relative, resolve } from "pathe";
+import { dirname, join, relative, resolve } from "pathe";
 import { appendFileSync, copyFileSync, existsSync, lstatSync, mkdirSync, readFileSync, readdirSync, realpathSync, rmSync, statSync, symlinkSync, unlinkSync, writeFileSync } from "node:fs";
-import { execSync } from "node:child_process";
+import { execSync, spawn } from "node:child_process";
 import pLimit from "p-limit";
 import * as p from "@clack/prompts";
 import { defineCommand, runMain } from "citty";
+import logUpdate from "log-update";
 import { detectCurrentAgent } from "unagent/env";
 const LLM_CACHE_DIR = join(CACHE_DIR, "llm-cache");
 const LLM_CACHE_MAX_AGE = 10080 * 60 * 1e3;
@@ -871,6 +871,290 @@ async function indexResources(opts) {
 		}
 	});
 }
+const STATUS_ICONS = {
+	pending: "○",
+	resolving: "◐",
+	downloading: "◒",
+	embedding: "◓",
+	exploring: "◔",
+	thinking: "◔",
+	generating: "◑",
+	done: "✓",
+	error: "✗"
+};
+const STATUS_COLORS = {
+	pending: "\x1B[90m",
+	resolving: "\x1B[36m",
+	downloading: "\x1B[36m",
+	embedding: "\x1B[36m",
+	exploring: "\x1B[34m",
+	thinking: "\x1B[35m",
+	generating: "\x1B[33m",
+	done: "\x1B[32m",
+	error: "\x1B[31m"
+};
+async function syncPackagesParallel(config) {
+	const { packages, concurrency = 5 } = config;
+	const agent = targets[config.agent];
+	const states = /* @__PURE__ */ new Map();
+	const cwd = process.cwd();
+	for (const pkg of packages) states.set(pkg, {
+		name: pkg,
+		status: "pending",
+		message: "Waiting..."
+	});
+	function render() {
+		const maxNameLen = Math.max(...packages.map((p) => p.length), 20);
+		const lines = [...states.values()].map((s) => {
+			const icon = STATUS_ICONS[s.status];
+			const color = STATUS_COLORS[s.status];
+			const reset = "\x1B[0m";
+			const dim = "\x1B[90m";
+			const name = s.name.padEnd(maxNameLen);
+			const version = s.version ? `${dim}${s.version}${reset} ` : "";
+			const elapsed = (s.status === "done" || s.status === "error") && s.startedAt && s.completedAt ? ` ${dim}(${formatDuration(s.completedAt - s.startedAt)})${reset}` : "";
+			const preview = s.streamPreview ? ` ${dim}${s.streamPreview}${reset}` : "";
+			return `  ${color}${icon}${reset} ${name} ${version}${s.message}${elapsed}${preview}`;
+		});
+		const doneCount = [...states.values()].filter((s) => s.status === "done").length;
+		const errorCount = [...states.values()].filter((s) => s.status === "error").length;
+		logUpdate(`\x1B[1mSyncing ${packages.length} packages\x1B[0m (${doneCount} done${errorCount > 0 ? `, ${errorCount} failed` : ""})\n` + lines.join("\n"));
+	}
+	function update(pkg, status, message, version) {
+		const state = states.get(pkg);
+		if (!state.startedAt && status !== "pending") state.startedAt = performance.now();
+		if ((status === "done" || status === "error") && !state.completedAt) state.completedAt = performance.now();
+		state.status = status;
+		state.message = message;
+		state.streamPreview = void 0;
+		if (version) state.version = version;
+		render();
+	}
+	ensureCacheDir();
+	render();
+	const limit = pLimit(concurrency);
+	const skillData = /* @__PURE__ */ new Map();
+	const baseResults = await Promise.allSettled(packages.map((pkg) => limit(() => syncBaseSkill(pkg, config, cwd, update))));
+	logUpdate.done();
+	const successfulPkgs = [];
+	const shippedPkgs = [];
+	const errors = [];
+	for (let i = 0; i < baseResults.length; i++) {
+		const r = baseResults[i];
+		if (r.status === "fulfilled" && r.value !== "shipped") {
+			successfulPkgs.push(packages[i]);
+			skillData.set(packages[i], r.value);
+		} else if (r.status === "fulfilled" && r.value === "shipped") shippedPkgs.push(packages[i]);
+		else if (r.status === "rejected") {
+			const err = r.reason;
+			const reason = err instanceof Error ? `${err.message}\n${err.stack}` : String(err);
+			errors.push({
+				pkg: packages[i],
+				reason
+			});
+		}
+	}
+	const skillMsg = `Created ${successfulPkgs.length} base skills${shippedPkgs.length > 1 ? ` (Skipping ${shippedPkgs.length})` : ""}`;
+	p.log.success(skillMsg);
+	if (errors.length > 0) for (const { pkg, reason } of errors) p.log.error(`  ${pkg}: ${reason}`);
+	const globalConfig = readConfig();
+	if (successfulPkgs.length > 0 && !globalConfig.skipLlm && !(config.yes && !config.model)) {
+		const llmConfig = await selectLlmConfig(config.model);
+		if (llmConfig) {
+			p.log.step(getModelLabel(llmConfig.model));
+			for (const pkg of successfulPkgs) states.set(pkg, {
+				name: pkg,
+				status: "pending",
+				message: "Waiting..."
+			});
+			render();
+			const llmResults = await Promise.allSettled(successfulPkgs.map((pkg) => limit(() => enhanceWithLLM(pkg, skillData.get(pkg), {
+				...config,
+				model: llmConfig.model
+			}, cwd, update, llmConfig.sections, llmConfig.customPrompt))));
+			logUpdate.done();
+			const llmSucceeded = llmResults.filter((r) => r.status === "fulfilled").length;
+			p.log.success(`Enhanced ${llmSucceeded}/${successfulPkgs.length} skills with LLM`);
+		}
+	}
+	await ensureGitignore(getSharedSkillsDir(cwd) ? SHARED_SKILLS_DIR : agent.skillsDir, cwd, config.global);
+	await shutdownWorker();
+	p.outro(`Synced ${successfulPkgs.length}/${packages.length} packages`);
+}
+async function syncBaseSkill(packageName, config, cwd, update) {
+	const localVersion = (await readLocalDependencies(cwd).catch(() => [])).find((d) => d.name === packageName)?.version;
+	const { package: resolvedPkg, attempts } = await resolvePackageDocsWithAttempts(packageName, {
+		version: localVersion,
+		cwd,
+		onProgress: (step) => update(packageName, "resolving", RESOLVE_STEP_LABELS[step])
+	});
+	let resolved = resolvedPkg;
+	if (!resolved) {
+		update(packageName, "resolving", "Local package...");
+		resolved = await resolveLocalDep(packageName, cwd);
+	}
+	if (!resolved) {
+		const npmAttempt = attempts.find((a) => a.source === "npm");
+		let reason;
+		if (npmAttempt?.status === "not-found") {
+			const suggestions = await searchNpmPackages(packageName, 3);
+			const hint = suggestions.length > 0 ? ` (try: ${suggestions.map((s) => s.name).join(", ")})` : "";
+			reason = (npmAttempt.message || "Not on npm") + hint;
+		} else reason = attempts.filter((a) => a.status !== "success").map((a) => a.message || a.source).join("; ") || "No docs found";
+		update(packageName, "error", reason);
+		throw new Error(`Could not find docs for: ${packageName}`);
+	}
+	const version = localVersion || resolved.version || "latest";
+	const versionKey = getVersionKey(version);
+	if (!existsSync(join(cwd, "node_modules", packageName))) {
+		update(packageName, "downloading", "Downloading dist...", versionKey);
+		await fetchPkgDist(packageName, version);
+	}
+	const shippedResult = handleShippedSkills(packageName, version, cwd, config.agent, config.global);
+	if (shippedResult) {
+		const shared = !config.global && getSharedSkillsDir(cwd);
+		if (shared) for (const shipped of shippedResult.shipped) linkSkillToAgents(shipped.skillName, shared, cwd);
+		update(packageName, "done", "Published SKILL.md", versionKey);
+		return "shipped";
+	}
+	if (config.force) forceClearCache(packageName, version);
+	const useCache = isCached(packageName, version);
+	if (useCache) update(packageName, "downloading", "Using cache", versionKey);
+	else update(packageName, "downloading", config.force ? "Re-fetching docs..." : "Fetching docs...", versionKey);
+	const baseDir = resolveBaseDir(cwd, config.agent, config.global);
+	const skillDirName = computeSkillDirName(packageName, resolved.repoUrl);
+	const skillDir = join(baseDir, skillDirName);
+	mkdirSync(skillDir, { recursive: true });
+	const features = readConfig().features ?? defaultFeatures;
+	const resources = await fetchAndCacheResources({
+		packageName,
+		resolved,
+		version,
+		useCache,
+		features,
+		onProgress: (msg) => update(packageName, "downloading", msg, versionKey)
+	});
+	update(packageName, "downloading", "Linking references...", versionKey);
+	linkAllReferences(skillDir, packageName, cwd, version, resources.docsType);
+	update(packageName, "embedding", "Indexing docs", versionKey);
+	await indexResources({
+		packageName,
+		version,
+		cwd,
+		docsToIndex: resources.docsToIndex,
+		features,
+		onProgress: (msg) => update(packageName, "embedding", msg, versionKey)
+	});
+	const hasChangelog = detectChangelog(resolvePkgDir(packageName, cwd, version));
+	const relatedSkills = await findRelatedSkills(packageName, baseDir);
+	const shippedDocs = hasShippedDocs(packageName, cwd, version);
+	const pkgFiles = getPkgKeyFiles(packageName, cwd, version);
+	const repoSlug = resolved.repoUrl?.match(/github\.com\/([^/]+\/[^/]+?)(?:\.git)?(?:[/#]|$)/)?.[1];
+	linkPkgNamed(skillDir, packageName, cwd, version);
+	writeLock(baseDir, skillDirName, {
+		packageName,
+		version,
+		repo: repoSlug,
+		source: resources.docSource,
+		syncedAt: (/* @__PURE__ */ new Date()).toISOString().split("T")[0],
+		generator: "skilld"
+	});
+	const updatedLock = readLock(baseDir)?.skills[skillDirName];
+	const allPackages = parsePackages(updatedLock?.packages).map((p) => ({ name: p.name }));
+	const skillMd = generateSkillMd({
+		name: packageName,
+		version,
+		releasedAt: resolved.releasedAt,
+		description: resolved.description,
+		dependencies: resolved.dependencies,
+		distTags: resolved.distTags,
+		relatedSkills,
+		hasIssues: resources.hasIssues,
+		hasDiscussions: resources.hasDiscussions,
+		hasReleases: resources.hasReleases,
+		hasChangelog,
+		docsType: resources.docsType,
+		hasShippedDocs: shippedDocs,
+		pkgFiles,
+		dirName: skillDirName,
+		packages: allPackages.length > 1 ? allPackages : void 0,
+		repoUrl: resolved.repoUrl
+	});
+	writeFileSync(join(skillDir, "SKILL.md"), skillMd);
+	const shared = !config.global && getSharedSkillsDir(cwd);
+	if (shared) linkSkillToAgents(skillDirName, shared, cwd);
+	if (!config.global) registerProject(cwd);
+	update(packageName, "done", "Base skill created", versionKey);
+	return {
+		resolved,
+		version,
+		skillDirName,
+		docsType: resources.docsType,
+		hasIssues: resources.hasIssues,
+		hasDiscussions: resources.hasDiscussions,
+		hasReleases: resources.hasReleases,
+		hasChangelog,
+		shippedDocs,
+		pkgFiles,
+		relatedSkills,
+		packages: allPackages.length > 1 ? allPackages : void 0
+	};
+}
+async function enhanceWithLLM(packageName, data, config, cwd, update, sections, customPrompt) {
+	const versionKey = getVersionKey(data.version);
+	const skillDir = join(resolveBaseDir(cwd, config.agent, config.global), data.skillDirName);
+	const hasGithub = data.hasIssues || data.hasDiscussions;
+	const docFiles = listReferenceFiles(skillDir);
+	update(packageName, "generating", config.model, versionKey);
+	const { optimized, wasOptimized, error } = await optimizeDocs({
+		packageName,
+		skillDir,
+		model: config.model,
+		version: data.version,
+		hasGithub,
+		hasReleases: data.hasReleases,
+		hasChangelog: data.hasChangelog,
+		docFiles,
+		docsType: data.docsType,
+		hasShippedDocs: data.shippedDocs,
+		noCache: config.force,
+		debug: config.debug,
+		sections,
+		customPrompt,
+		onProgress: (progress) => {
+			const status = progress.type === "reasoning" ? "exploring" : "generating";
+			const sectionPrefix = progress.section ? `[${progress.section}] ` : "";
+			update(packageName, status, progress.chunk.startsWith("[") ? `${sectionPrefix}${progress.chunk}` : `${sectionPrefix}${config.model}`, versionKey);
+		}
+	});
+	if (error) {
+		update(packageName, "error", error, versionKey);
+		throw new Error(error);
+	}
+	if (wasOptimized) {
+		const skillMd = generateSkillMd({
+			name: packageName,
+			version: data.version,
+			releasedAt: data.resolved.releasedAt,
+			dependencies: data.resolved.dependencies,
+			distTags: data.resolved.distTags,
+			body: optimized,
+			relatedSkills: data.relatedSkills,
+			hasIssues: data.hasIssues,
+			hasDiscussions: data.hasDiscussions,
+			hasReleases: data.hasReleases,
+			hasChangelog: data.hasChangelog,
+			docsType: data.docsType,
+			hasShippedDocs: data.shippedDocs,
+			pkgFiles: data.pkgFiles,
+			dirName: data.skillDirName,
+			packages: data.packages,
+			repoUrl: data.resolved.repoUrl
+		});
+		writeFileSync(join(skillDir, "SKILL.md"), skillMd);
+	}
+	update(packageName, "done", "Skill optimized", versionKey);
+}
 function showResolveAttempts(attempts) {
 	if (attempts.length === 0) return;
 	p.log.message("\x1B[90mResolution attempts:\x1B[0m");
@@ -901,30 +1185,8 @@ async function ensureGitignore(skillsDir, cwd, isGlobal) {
 }
 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,
-				debug: opts.debug
-			});
-		}
-		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,
+		if (opts.packages.length > 1) return syncPackagesParallel({
+			packages: opts.packages,
 			global: opts.global,
 			agent: opts.agent,
 			model: opts.model,
@@ -932,7 +1194,23 @@ async function syncCommand(state, opts) {
 			force: opts.force,
 			debug: opts.debug
 		});
+		await syncSinglePackage(opts.packages[0], opts);
+		return;
+	}
+	const packages = await interactivePicker(state);
+	if (!packages || packages.length === 0) {
+		p.outro("No packages selected");
+		return;
 	}
+	if (packages.length > 1) return syncPackagesParallel({
+		packages,
+		global: opts.global,
+		agent: opts.agent,
+		model: opts.model,
+		yes: opts.yes,
+		force: opts.force,
+		debug: opts.debug
+	});
 	await syncSinglePackage(packages[0], opts);
 }
 async function interactivePicker(state) {
@@ -1299,7 +1577,6 @@ async function syncSinglePackage(packageName, config) {
 	if (shared) linkSkillToAgents(skillDirName, shared, cwd);
 	if (!config.global) registerProject(cwd);
 	await ensureGitignore(shared ? SHARED_SKILLS_DIR : targets[config.agent].skillsDir, cwd, config.global);
-	const { shutdownWorker } = await import("./_chunks/pool.mjs");
 	await shutdownWorker();
 	p.outro(`Synced ${packageName} to ${relative(cwd, skillDir)}`);
 }
@@ -1414,7 +1691,6 @@ async function installCommand(opts) {
 			continue;
 		}
 		if (info.source === "github" || info.source === "gitlab" || info.source === "local") {
-			const { fetchGitSkills } = await import("./_chunks/git-skills.mjs").then((n) => n.n);
 			const match = (await fetchGitSkills({
 				type: info.source,
 				...info.repo?.includes("/") ? {
@@ -1426,8 +1702,6 @@ async function installCommand(opts) {
 				...info.source === "local" ? { localPath: info.repo } : {}
 			})).skills.find((s) => s.name === name);
 			if (match) {
-				const { sanitizeMarkdown } = await import("./_chunks/sanitize2.mjs").then((n) => n.r);
-				const { dirname } = await import("pathe");
 				const skillDir = join(skillsDir, name);
 				mkdirSync(skillDir, { recursive: true });
 				writeFileSync(join(skillDir, "SKILL.md"), sanitizeMarkdown(match.content));
@@ -1642,7 +1916,6 @@ async function installCommand(opts) {
 	for (const [name, info] of Object.entries(lock.skills)) writeLock(skillsDir, name, info);
 	if (shared) for (const [name] of skills) linkSkillToAgents(name, shared, cwd);
 	else syncLockfilesToDirs(lock, allSkillsDirs.filter((d) => d !== skillsDir));
-	const { shutdownWorker } = await import("./_chunks/pool.mjs");
 	await shutdownWorker();
 	p.outro("Install complete");
 }
@@ -2716,6 +2989,61 @@ async function runWizard() {
 	});
 	p.outro("Thanks, you're all set! Change config anytime with `skilld config`.");
 }
+async function syncGitSkills(opts) {
+	const { source, agent, global: isGlobal, yes } = opts;
+	const cwd = process.cwd();
+	const agentConfig = targets[agent];
+	const baseDir = isGlobal ? join(CACHE_DIR, "skills") : join(cwd, agentConfig.skillsDir);
+	const label = source.type === "local" ? source.localPath : `${source.owner}/${source.repo}`;
+	const spin = timedSpinner();
+	spin.start(`Fetching skills from ${label}`);
+	const { skills, commitSha } = await fetchGitSkills(source, (msg) => spin.message(msg));
+	if (skills.length === 0) {
+		spin.stop(`No skills found in ${label}`);
+		return;
+	}
+	spin.stop(`Found ${skills.length} skill(s) in ${label}`);
+	let selected = skills;
+	if (source.skillPath) selected = skills;
+	else if (skills.length > 1 && !yes) {
+		const choices = await p.multiselect({
+			message: `Select skills to install from ${label}`,
+			options: skills.map((s) => ({
+				label: s.name,
+				value: s.name,
+				hint: s.description || s.path
+			})),
+			initialValues: skills.map((s) => s.name)
+		});
+		if (p.isCancel(choices)) return;
+		const selectedNames = new Set(choices);
+		selected = skills.filter((s) => selectedNames.has(s.name));
+	}
+	mkdirSync(baseDir, { recursive: true });
+	for (const skill of selected) {
+		const skillDir = join(baseDir, skill.name);
+		mkdirSync(skillDir, { recursive: true });
+		writeFileSync(join(skillDir, "SKILL.md"), sanitizeMarkdown(skill.content));
+		if (skill.files.length > 0) for (const f of skill.files) {
+			const filePath = join(skillDir, ".skilld", f.path);
+			mkdirSync(dirname(filePath), { recursive: true });
+			writeFileSync(filePath, f.content);
+		}
+		const sourceType = source.type === "local" ? "local" : source.type;
+		writeLock(baseDir, skill.name, {
+			source: sourceType,
+			repo: source.type === "local" ? source.localPath : `${source.owner}/${source.repo}`,
+			path: skill.path || void 0,
+			ref: source.ref || "main",
+			commit: commitSha,
+			syncedAt: (/* @__PURE__ */ new Date()).toISOString().split("T")[0],
+			generator: "external"
+		});
+	}
+	if (!isGlobal) registerProject(cwd);
+	const names = selected.map((s) => `\x1B[36m${s.name}\x1B[0m`).join(", ");
+	p.log.success(`Installed ${names}`);
+}
 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]);
 function getRepoHint(name, cwd) {
@@ -2959,8 +3287,6 @@ const addCommand = defineCommand({
 			if (!agent) return;
 		}
 		const rawInputs = [...new Set([args.package, ...args._ || []].map((s) => s.trim()).filter(Boolean))];
-		const { parseGitSkillInput } = await import("./_chunks/git-skills.mjs").then((n) => n.n);
-		const { syncGitSkills } = await import("./_chunks/sync-git.mjs");
 		const gitSources = [];
 		const npmTokens = [];
 		for (const input of rawInputs) {
@@ -3232,7 +3558,6 @@ runMain(defineCommand({
 		const cwd = process.cwd();
 		if (args.prepare) {
 			if (args.background) {
-				const { spawn } = await import("node:child_process");
 				spawn(process.execPath, [
 					process.argv[1],
 					"--prepare",
@@ -3579,6 +3904,6 @@ runMain(defineCommand({
 		}
 	}
 }));
-export { registerProject as S, writeLock as _, fetchAndCacheResources as a, defaultFeatures as b, handleShippedSkills as c, resolveBaseDir as d, resolveLocalDep as f, readLock as g, parsePackages as h, detectChangelog as i, indexResources as l, getSharedSkillsDir as m, selectLlmConfig as n, findRelatedSkills as o, SHARED_SKILLS_DIR as p, RESOLVE_STEP_LABELS as r, forceClearCache as s, ensureGitignore as t, linkAllReferences as u, formatDuration as v, readConfig as x, timedSpinner as y };
+export {};
 
 //# sourceMappingURL=cli.mjs.map