skilld 0.15.4 → 1.0.0

package/dist/_chunks/formatting.mjs

@@ -1,4 +1,552 @@
+import { n as yamlParseKV, r as yamlUnescape, t as yamlEscape } from "./yaml.mjs";
+import { i as parseFrontmatter } from "./markdown.mjs";
+import { a as semverGt, n as getSharedSkillsDir } from "./shared.mjs";
+import { s as readLocalDependencies } from "./sources.mjs";
+import { _ as targets, g as getAgentVersion, h as detectTargetAgent, m as detectInstalledAgents } from "./prompts.mjs";
+import { a as getModelName } from "./agent.mjs";
+import { homedir } from "node:os";
+import { join } from "pathe";
+import { existsSync, mkdirSync, readFileSync, readdirSync, unlinkSync, writeFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
 import * as p from "@clack/prompts";
+import { detectCurrentAgent } from "unagent/env";
+import { dirname as dirname$1, resolve as resolve$1 } from "node:path";
+const defaultFeatures = {
+	search: true,
+	issues: true,
+	discussions: true,
+	releases: true
+};
+const CONFIG_DIR = join(homedir(), ".skilld");
+const CONFIG_PATH = join(CONFIG_DIR, "config.yaml");
+function hasConfig() {
+	return existsSync(CONFIG_PATH);
+}
+/** Whether the first-run wizard has been completed (not just agent selection) */
+function hasCompletedWizard() {
+	if (!existsSync(CONFIG_PATH)) return false;
+	const config = readConfig();
+	return config.features !== void 0 || config.model !== void 0 || config.skipLlm !== void 0;
+}
+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(yamlUnescape(line.slice(4)));
+				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 kv = yamlParseKV(line);
+		if (!kv) continue;
+		const [key, value] = kv;
+		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,
+		mode: 448
+	});
+	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 += `  - ${yamlEscape(p)}\n`;
+	}
+	writeFileSync(CONFIG_PATH, yaml, { mode: 384 });
+}
+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 || [];
+}
+function findPackageJson() {
+	let dir = dirname$1(fileURLToPath(import.meta.url));
+	for (let i = 0; i < 5; i++) {
+		const candidate = resolve$1(dir, "package.json");
+		try {
+			const content = readFileSync(candidate, "utf8");
+			if (content) return content;
+		} catch {}
+		dir = resolve$1(dir, "..");
+	}
+	return "{\"version\":\"0.0.0\"}";
+}
+const version = JSON.parse(findPackageJson()).version;
+const sharedArgs = {
+	global: {
+		type: "boolean",
+		alias: "g",
+		description: "Install globally to ~/.skilld/skills",
+		default: false
+	},
+	agent: {
+		type: "enum",
+		options: Object.keys(targets),
+		alias: "a",
+		description: "Agent where skills are installed"
+	},
+	model: {
+		type: "string",
+		alias: "m",
+		description: "LLM model for skill generation",
+		valueHint: "id"
+	},
+	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
+	},
+	debug: {
+		type: "boolean",
+		description: "Save raw LLM output to logs/ for each section",
+		default: false
+	}
+};
+/** Check if the current environment supports interactive prompts */
+function isInteractive() {
+	if (detectCurrentAgent()) return false;
+	if (process.env.CI) return false;
+	if (!process.stdout.isTTY) return false;
+	return true;
+}
+/** Exit with error if interactive terminal is required but unavailable */
+function requireInteractive(command) {
+	if (!isInteractive()) {
+		console.error(`Error: \`skilld ${command}\` requires an interactive terminal`);
+		process.exit(1);
+	}
+}
+/** Resolve agent from flags/cwd/config. cwd is source of truth over config. */
+function resolveAgent(agentFlag) {
+	return agentFlag ?? detectTargetAgent() ?? readConfig().agent ?? null;
+}
+/** Prompt user to pick an agent when auto-detection fails */
+async function promptForAgent() {
+	const installed = detectInstalledAgents();
+	if (!isInteractive()) {
+		if (installed.length === 1) {
+			updateConfig({ agent: installed[0] });
+			return installed[0];
+		}
+		console.error("Error: could not auto-detect agent. Pass --agent <name> to specify.");
+		process.exit(1);
+	}
+	const options = (installed.length ? installed : Object.keys(targets)).map((id) => ({
+		label: targets[id].displayName,
+		value: id,
+		hint: targets[id].skillsDir
+	}));
+	const hint = installed.length ? `Detected ${installed.map((t) => targets[t].displayName).join(", ")} but couldn't determine which to use` : "No agents auto-detected";
+	p.log.warn(`Could not detect which coding agent to install skills for.\n  ${hint}`);
+	const choice = await p.select({
+		message: "Which coding agent should skills be installed for?",
+		options
+	});
+	if (p.isCancel(choice)) return null;
+	updateConfig({ agent: choice });
+	p.log.success(`Default agent set to ${targets[choice].displayName}`);
+	return choice;
+}
+/** Get installed LLM generators with working CLIs (verified via --version) */
+function getInstalledGenerators() {
+	return detectInstalledAgents().filter((id) => targets[id].cli).map((id) => {
+		const ver = getAgentVersion(id);
+		return ver ? {
+			name: targets[id].displayName,
+			version: ver
+		} : null;
+	}).filter((a) => a !== null);
+}
+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;
+}
+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 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 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 parsePackages(packages) {
+	if (!packages) return [];
+	return packages.split(",").map((s) => {
+		const trimmed = s.trim();
+		const atIdx = trimmed.lastIndexOf("@");
+		if (atIdx <= 0) return {
+			name: trimmed,
+			version: ""
+		};
+		return {
+			name: trimmed.slice(0, atIdx),
+			version: trimmed.slice(atIdx + 1)
+		};
+	}).filter((p) => p.name);
+}
+function serializePackages(pkgs) {
+	return pkgs.map((p) => `${p.name}@${p.version}`).join(", ");
+}
+const SKILL_FM_KEYS = [
+	"packageName",
+	"version",
+	"packages",
+	"repo",
+	"source",
+	"syncedAt",
+	"generator",
+	"path",
+	"ref",
+	"commit"
+];
+function parseSkillFrontmatter(skillPath) {
+	if (!existsSync(skillPath)) return null;
+	const fm = parseFrontmatter(readFileSync(skillPath, "utf-8"));
+	if (Object.keys(fm).length === 0) return null;
+	const info = {};
+	for (const key of SKILL_FM_KEYS) if (fm[key]) info[key] = fm[key];
+	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 kv = yamlParseKV(line);
+			if (kv) skills[currentSkill][kv[0]] = kv[1];
+		}
+	}
+	return { skills };
+}
+function serializeLock(lock) {
+	let yaml = "skills:\n";
+	for (const [name, skill] of Object.entries(lock.skills)) {
+		yaml += `  ${name}:\n`;
+		if (skill.packageName) yaml += `    packageName: ${yamlEscape(skill.packageName)}\n`;
+		if (skill.version) yaml += `    version: ${yamlEscape(skill.version)}\n`;
+		if (skill.packages) yaml += `    packages: ${yamlEscape(skill.packages)}\n`;
+		if (skill.repo) yaml += `    repo: ${yamlEscape(skill.repo)}\n`;
+		if (skill.source) yaml += `    source: ${yamlEscape(skill.source)}\n`;
+		if (skill.syncedAt) yaml += `    syncedAt: ${yamlEscape(skill.syncedAt)}\n`;
+		if (skill.generator) yaml += `    generator: ${yamlEscape(skill.generator)}\n`;
+		if (skill.path) yaml += `    path: ${yamlEscape(skill.path)}\n`;
+		if (skill.ref) yaml += `    ref: ${yamlEscape(skill.ref)}\n`;
+		if (skill.commit) yaml += `    commit: ${yamlEscape(skill.commit)}\n`;
+	}
+	return yaml;
+}
+function writeLock(skillsDir, skillName, info) {
+	const lockPath = join(skillsDir, "skilld-lock.yaml");
+	let lock = { skills: {} };
+	if (existsSync(lockPath)) lock = readLock(skillsDir) || { skills: {} };
+	const existing = lock.skills[skillName];
+	if (existing && info.packageName) {
+		const existingPkgs = parsePackages(existing.packages);
+		if (existing.packageName && !existingPkgs.some((p) => p.name === existing.packageName)) existingPkgs.unshift({
+			name: existing.packageName,
+			version: existing.version || ""
+		});
+		const idx = existingPkgs.findIndex((p) => p.name === info.packageName);
+		if (idx >= 0) existingPkgs[idx].version = info.version || "";
+		else existingPkgs.push({
+			name: info.packageName,
+			version: info.version || ""
+		});
+		info.packages = serializePackages(existingPkgs);
+		info.packageName = existingPkgs[0].name;
+		info.version = existingPkgs[0].version;
+		if (!info.repo && existing.repo) info.repo = existing.repo;
+		if (!info.source && existing.source) info.source = existing.source;
+		if (!info.generator && existing.generator) info.generator = existing.generator;
+	}
+	lock.skills[skillName] = info;
+	writeFileSync(lockPath, serializeLock(lock));
+}
+/**
+* Merge multiple lockfiles, preferring the most recently synced entry per skill.
+*/
+function mergeLocks(locks) {
+	const merged = {};
+	for (const lock of locks) for (const [name, info] of Object.entries(lock.skills)) {
+		const existing = merged[name];
+		if (!existing || info.syncedAt && (!existing.syncedAt || info.syncedAt > existing.syncedAt)) merged[name] = info;
+	}
+	return { skills: merged };
+}
+/**
+* Sync a lockfile to all other dirs that already have a skilld-lock.yaml.
+* Only updates existing lockfiles — does not create new ones.
+*/
+function syncLockfilesToDirs(sourceLock, dirs) {
+	for (const dir of dirs) {
+		const lockPath = join(dir, "skilld-lock.yaml");
+		if (!existsSync(lockPath)) continue;
+		const existing = readLock(dir);
+		if (!existing) continue;
+		writeFileSync(lockPath, serializeLock(mergeLocks([existing, sourceLock])));
+	}
+}
+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;
+	}
+	writeFileSync(lockPath, serializeLock(lock));
+}
+function* iterateSkills(opts = {}) {
+	const { scope = "all", cwd = process.cwd() } = opts;
+	const agentTypes = opts.agents ?? Object.keys(targets);
+	const sharedDir = getSharedSkillsDir(cwd);
+	let yieldedLocal = false;
+	if (sharedDir && (scope === "local" || scope === "all")) {
+		yieldedLocal = true;
+		const lock = readLock(sharedDir);
+		const entries = readdirSync(sharedDir).filter((f) => !f.startsWith(".") && f !== "skilld-lock.yaml");
+		const firstAgent = agentTypes[0] ?? Object.keys(targets)[0];
+		for (const name of entries) {
+			const dir = join(sharedDir, name);
+			if (lock?.skills[name]) yield {
+				name,
+				dir,
+				agent: firstAgent,
+				info: lock.skills[name],
+				scope: "local"
+			};
+			else {
+				const info = parseSkillFrontmatter(join(dir, ".skilld", "_SKILL.md"));
+				if (info?.generator === "skilld") yield {
+					name,
+					dir,
+					agent: firstAgent,
+					info,
+					scope: "local"
+				};
+			}
+		}
+	}
+	for (const agentType of agentTypes) {
+		const agent = targets[agentType];
+		if (!yieldedLocal && (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, ".skilld", "_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, ".skilld", "_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 semverGt(depVersion.replace(/^[\^~]/, ""), skill.info.version);
+}
+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);
+		for (const pkg of parsePackages(s.info?.packages)) skillByPkgName.set(pkg.name, 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}-skilld`) || 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 = targets[agent];
+	if (scope === "global") {
+		if (!agentConfig.globalSkillsDir) throw new Error(`Agent ${agent} does not support global skills`);
+		return agentConfig.globalSkillsDir;
+	}
+	return getSharedSkillsDir(cwd) || join(cwd, agentConfig.skillsDir);
+}
 function timeAgo(iso) {
 	if (!iso) return "";
 	const diff = Date.now() - new Date(iso).getTime();
@@ -81,6 +629,6 @@ function formatCompactSnippet(r, cols) {
 		preview: firstLine.length > maxPreview ? `${firstLine.slice(0, maxPreview - 1)}…` : firstLine
 	};
 }
-export { highlightTerms as a, timeAgo as c, formatSource as i, timedSpinner as l, formatDuration as n, normalizeScores as o, formatSnippet as r, scoreLabel as s, formatCompactSnippet as t };
+export { version as A, introLine as C, requireInteractive as D, relativeTime as E, readConfig as F, registerProject as I, unregisterProject as L, getRegisteredProjects as M, hasCompletedWizard as N, resolveAgent as O, hasConfig as P, updateConfig as R, getRepoHint as S, promptForAgent as T, removeLockEntry as _, highlightTerms as a, formatStatus as b, timeAgo as c, getSkillsDir as d, isOutdated as f, readLock as g, parsePackages as h, formatSource as i, defaultFeatures as j, sharedArgs as k, timedSpinner as l, mergeLocks as m, formatDuration as n, normalizeScores as o, iterateSkills as p, formatSnippet as r, scoreLabel as s, formatCompactSnippet as t, getProjectState as u, syncLockfilesToDirs as v, isInteractive as w, getInstalledGenerators as x, writeLock as y };
 
 //# sourceMappingURL=formatting.mjs.map