@bud-fe/skills 0.0.1 → 0.0.3

package/README.md

@@ -1,19 +1,28 @@
 # skills-x
 
-The CLI for the open agent skills, commands ecosystem.
+Forked from [vercel-labs/skills](https://github.com/vercel-labs/skills).
+
+## Changes based on upstream
+
+### ADDED
 
-Forked from [vercel-labs/skills](https://github.com/vercel-labs/skills), **recent spec changes**:
+- `add-c` 命令：支持按名称从默认源的 `commands/` 目录安装 slash command 文件
 
-- `skills add` now supports implicit default-registry source resolution when flags are provided without a source (for example `--list` and `--all`).
-- `skills add` maps simple identifiers (for example `code-review`) to the curated default registry, while explicit sources (`owner/repo`, URLs, local paths) keep their existing behavior.
-- `skills add-c` installs command markdown files from the default registry `commands/` directory by command name.
-- `skills find` is provider-scoped:
-  - default mode searches the curated registry
-  - `-g` / `--global` searches [skills.sh](https://skills.sh)
-  - the CLI does not silently fall back to another provider if the selected provider fails
+### MODIFIED
+
+- `add` 命令
+  - 支持在未提供源但携带标志（如 `--list` 和 `--all`）时，自动解析至默认源
+  - 将简单标识符（如 `code-review`）映射到默认源，而显式源（`owner/repo`、URL、本地路径）保持原有行为
+- `find` 命令
+  - 无参数时默认从默认源搜索
+  - `-g` / `--global` 搜索 [skills.sh](https://skills.sh)（即原逻辑）
+- `check` 和 `update`
+  - 支持非 GitHub 源（如 GitLab、通用 Git），采用基于内容的内容哈希（SHA-256）进行更新检测
 
 ---
 
+The CLI for the open agent skills, commands ecosystem.
+
 <!-- agent-list:start -->
 
 Supports **OpenCode**, **Claude Code**, **Codex**, **Cursor**, and [37 more](#available-agents).

package/dist/cli.mjs

@@ -19,7 +19,7 @@ import { access, cp, lstat, mkdir, mkdtemp, readFile, readdir, readlink, realpat
 import * as readline from "readline";
 import { Writable } from "stream";
 var import_picocolors = /* @__PURE__ */ __toESM(require_picocolors(), 1);
-var version$1 = "0.0.1";
+var version$1 = "0.0.3";
 const home = homedir();
 const configHome = xdgConfig ?? join(home, ".config");
 const codexHome = process.env.CODEX_HOME?.trim() || join(home, ".codex");
@@ -104,6 +104,8 @@ const agents = {
 		displayName: "Codex",
 		skillsDir: ".agents/skills",
 		globalSkillsDir: join(codexHome, "skills"),
+		commandsDir: ".codex/prompts",
+		globalCommandsDir: join(codexHome, "prompts"),
 		detectInstalled: async () => {
 			return existsSync(codexHome) || existsSync("/etc/codex");
 		}
@@ -2322,6 +2324,33 @@ async function selectAgentsInteractive(options) {
 	return selected;
 }
 setVersion(version$1);
+async function resolveGlobalLockHashData(params, deps = {
+	fetchGitHubHash: fetchSkillFolderHash,
+	computeFolderHash: computeSkillFolderHash
+}) {
+	if (params.sourceType === "github") {
+		let skillFolderHash = "";
+		if (params.normalizedSource && params.skillPathValue) try {
+			const hash = await deps.fetchGitHubHash(params.normalizedSource, params.skillPathValue);
+			if (hash) skillFolderHash = hash;
+		} catch {}
+		return {
+			skillFolderHash,
+			hashMethod: "github-tree-sha"
+		};
+	}
+	if (params.sourceType === "git" || params.sourceType === "gitlab") {
+		let skillFolderHash = "";
+		if (params.installDir) try {
+			skillFolderHash = await deps.computeFolderHash(params.installDir);
+		} catch {}
+		return {
+			skillFolderHash,
+			hashMethod: "content-sha256"
+		};
+	}
+	return { skillFolderHash: "" };
+}
 async function handleRemoteSkill(source, url, options, spinner) {
 	const provider = findProvider(url);
 	if (!provider) {
@@ -2494,7 +2523,9 @@ async function handleRemoteSkill(source, url, options, spinner) {
 	});
 	if (successful.length > 0 && installGlobally) try {
 		let skillFolderHash = "";
+		let hashMethod;
 		if (remoteSkill.providerId === "github") {
+			hashMethod = "github-tree-sha";
 			const hash = await fetchSkillFolderHash(remoteSkill.sourceIdentifier, url);
 			if (hash) skillFolderHash = hash;
 		}
@@ -2502,7 +2533,8 @@ async function handleRemoteSkill(source, url, options, spinner) {
 			source: remoteSkill.sourceIdentifier,
 			sourceType: remoteSkill.providerId,
 			sourceUrl: url,
-			skillFolderHash
+			skillFolderHash,
+			hashMethod
 		});
 	} catch {}
 	if (successful.length > 0 && !installGlobally) try {
@@ -3329,18 +3361,22 @@ async function runAdd(args, options = {}) {
 			for (const skill of selectedSkills) {
 				const skillDisplayName = getSkillDisplayName(skill);
 				if (successfulSkillNames.has(skillDisplayName)) try {
-					let skillFolderHash = "";
 					const skillPathValue = skillFiles[skill.name];
-					if (parsed.type === "github" && skillPathValue) {
-						const hash = await fetchSkillFolderHash(normalizedSource, skillPathValue);
-						if (hash) skillFolderHash = hash;
-					}
+					const matchingResult = successful.find((r) => r.skill === skillDisplayName);
+					const installDir = matchingResult?.canonicalPath || matchingResult?.path;
+					const { skillFolderHash, hashMethod } = await resolveGlobalLockHashData({
+						sourceType: parsed.type,
+						normalizedSource,
+						skillPathValue,
+						installDir
+					});
 					await addSkillToLock(skill.name, {
 						source: normalizedSource,
 						sourceType: parsed.type,
 						sourceUrl: parsed.url,
 						skillPath: skillPathValue,
-						skillFolderHash
+						skillFolderHash,
+						hashMethod
 					});
 				} catch {}
 			}
@@ -3642,13 +3678,13 @@ async function runAddCommand(args, options = {}) {
 			const modeChoice = await ve({
 				message: "Installation method",
 				options: [{
-					value: "symlink",
-					label: "Symlink (Recommended)",
-					hint: "Single source of truth, easy updates"
-				}, {
 					value: "copy",
 					label: "Copy to all agents",
 					hint: "Independent copies for each agent"
+				}, {
+					value: "symlink",
+					label: "Symlink (Cline, Kilo Code not supported)",
+					hint: "Single source of truth, easy updates"
 				}]
 			});
 			if (pD(modeChoice)) {
@@ -4826,6 +4862,142 @@ function parseRemoveOptions(args) {
 		options
 	};
 }
+const DEFAULT_DEPS = {
+	fetchGitHubHash: fetchSkillFolderHash,
+	cloneRepo,
+	cleanupTempDir,
+	computeFolderHash: computeSkillFolderHash,
+	pathExists: existsSync
+};
+function normalizeSkillFolderPath(skillPath) {
+	let folderPath = skillPath.replace(/\\/g, "/");
+	if (folderPath.endsWith("/SKILL.md")) folderPath = folderPath.slice(0, -9);
+	else if (folderPath.endsWith("SKILL.md")) folderPath = folderPath.slice(0, -8);
+	if (folderPath.endsWith("/")) folderPath = folderPath.slice(0, -1);
+	return folderPath;
+}
+function resolveHashMethod(entry) {
+	if (entry.hashMethod === "github-tree-sha" || entry.hashMethod === "content-sha256") return entry.hashMethod;
+	if (entry.sourceType === "github") return "github-tree-sha";
+	if ((entry.sourceType === "git" || entry.sourceType === "gitlab") && !!entry.skillFolderHash) return "content-sha256";
+	return null;
+}
+async function detectSkillUpdates(lock, options = {}) {
+	const deps = {
+		...DEFAULT_DEPS,
+		...options.deps || {}
+	};
+	const githubSkillsBySource = /* @__PURE__ */ new Map();
+	const contentSkillsBySourceUrl = /* @__PURE__ */ new Map();
+	let skippedMissingMetadata = 0;
+	for (const [name, entry] of Object.entries(lock.skills)) {
+		const hashMethod = resolveHashMethod(entry);
+		if (!hashMethod || !entry.skillPath || !entry.skillFolderHash) {
+			skippedMissingMetadata++;
+			continue;
+		}
+		if (hashMethod === "github-tree-sha") {
+			const bucket = githubSkillsBySource.get(entry.source) || [];
+			bucket.push({
+				name,
+				entry
+			});
+			githubSkillsBySource.set(entry.source, bucket);
+			continue;
+		}
+		if (!entry.sourceUrl) {
+			skippedMissingMetadata++;
+			continue;
+		}
+		const bucket = contentSkillsBySourceUrl.get(entry.sourceUrl) || [];
+		bucket.push({
+			name,
+			entry
+		});
+		contentSkillsBySourceUrl.set(entry.sourceUrl, bucket);
+	}
+	const updates = [];
+	const errors = [];
+	let checkedCount = 0;
+	for (const [source, skills] of githubSkillsBySource) for (const { name, entry } of skills) {
+		checkedCount++;
+		try {
+			const latestHash = await deps.fetchGitHubHash(source, entry.skillPath, options.githubToken);
+			if (!latestHash) {
+				errors.push({
+					name,
+					source,
+					error: "Could not fetch from GitHub"
+				});
+				continue;
+			}
+			if (latestHash !== entry.skillFolderHash) updates.push({
+				name,
+				source,
+				entry
+			});
+		} catch (err) {
+			errors.push({
+				name,
+				source,
+				error: err instanceof Error ? err.message : "Unknown error"
+			});
+		}
+	}
+	for (const [sourceUrl, skills] of contentSkillsBySourceUrl) {
+		let tempDir = null;
+		try {
+			tempDir = await deps.cloneRepo(sourceUrl);
+		} catch (err) {
+			const message = err instanceof Error ? err.message : "Failed to clone source repository";
+			for (const { name, entry } of skills) {
+				checkedCount++;
+				errors.push({
+					name,
+					source: entry.source,
+					error: message
+				});
+			}
+			continue;
+		}
+		try {
+			for (const { name, entry } of skills) {
+				checkedCount++;
+				try {
+					const folderPath = normalizeSkillFolderPath(entry.skillPath);
+					const targetDir = folderPath ? join(tempDir, folderPath) : tempDir;
+					if (!deps.pathExists(targetDir)) {
+						errors.push({
+							name,
+							source: entry.source,
+							error: `Skill path not found: ${folderPath}`
+						});
+						continue;
+					}
+					if (await deps.computeFolderHash(targetDir) !== entry.skillFolderHash) updates.push({
+						name,
+						source: entry.source,
+						entry
+					});
+				} catch (err) {
+					errors.push({
+						name,
+						source: entry.source,
+						error: err instanceof Error ? err.message : "Unknown error"
+					});
+				}
+			}
+		} finally {
+			await deps.cleanupTempDir(tempDir).catch(() => {});
+		}
+	}
+	return {
+		checkedCount,
+		skippedMissingMetadata,
+		updates,
+		errors
+	};
+}
 const __dirname = dirname(fileURLToPath(import.meta.url));
 function getVersion() {
 	try {
@@ -5080,58 +5252,21 @@ async function runCheck(args = []) {
 	console.log(`${TEXT}Checking for skill updates...${RESET}`);
 	console.log();
 	const lock = readSkillLock();
-	const skillNames = Object.keys(lock.skills);
-	if (skillNames.length === 0) {
+	if (Object.keys(lock.skills).length === 0) {
 		console.log(`${DIM}No skills tracked in lock file.${RESET}`);
 		console.log(`${DIM}Install skills with${RESET} ${TEXT}npx skills add <package>${RESET}`);
 		return;
 	}
-	const token = getGitHubToken();
-	const skillsBySource = /* @__PURE__ */ new Map();
-	let skippedCount = 0;
-	for (const skillName of skillNames) {
-		const entry = lock.skills[skillName];
-		if (!entry) continue;
-		if (entry.sourceType !== "github" || !entry.skillFolderHash || !entry.skillPath) {
-			skippedCount++;
-			continue;
-		}
-		const existing = skillsBySource.get(entry.source) || [];
-		existing.push({
-			name: skillName,
-			entry
-		});
-		skillsBySource.set(entry.source, existing);
-	}
-	const totalSkills = skillNames.length - skippedCount;
+	const result = await detectSkillUpdates(lock, { githubToken: getGitHubToken() });
+	const totalSkills = result.checkedCount;
 	if (totalSkills === 0) {
-		console.log(`${DIM}No GitHub skills to check.${RESET}`);
+		console.log(`${DIM}No skills with update metadata to check.${RESET}`);
+		if (result.skippedMissingMetadata > 0) console.log(`${DIM}${result.skippedMissingMetadata} skill(s) are missing hash metadata (run${RESET} ${TEXT}npx skills add <source> -g${RESET} ${DIM}to reinstall and track updates).${RESET}`);
 		return;
 	}
 	console.log(`${DIM}Checking ${totalSkills} skill(s) for updates...${RESET}`);
-	const updates = [];
-	const errors = [];
-	for (const [source, skills] of skillsBySource) for (const { name, entry } of skills) try {
-		const latestHash = await fetchSkillFolderHash(source, entry.skillPath, token);
-		if (!latestHash) {
-			errors.push({
-				name,
-				source,
-				error: "Could not fetch from GitHub"
-			});
-			continue;
-		}
-		if (latestHash !== entry.skillFolderHash) updates.push({
-			name,
-			source
-		});
-	} catch (err) {
-		errors.push({
-			name,
-			source,
-			error: err instanceof Error ? err.message : "Unknown error"
-		});
-	}
+	const updates = result.updates;
+	const errors = result.errors;
 	console.log();
 	if (updates.length === 0) console.log(`${TEXT}✓ All skills are up to date${RESET}`);
 	else {
@@ -5148,6 +5283,10 @@ async function runCheck(args = []) {
 		console.log();
 		console.log(`${DIM}Could not check ${errors.length} skill(s) (may need reinstall)${RESET}`);
 	}
+	if (result.skippedMissingMetadata > 0) {
+		console.log();
+		console.log(`${DIM}Skipped ${result.skippedMissingMetadata} skill(s) missing hash metadata (reinstall to enable update tracking).${RESET}`);
+	}
 	track({
 		event: "check",
 		skillCount: String(totalSkills),
@@ -5159,31 +5298,16 @@ async function runUpdate() {
 	console.log(`${TEXT}Checking for skill updates...${RESET}`);
 	console.log();
 	const lock = readSkillLock();
-	const skillNames = Object.keys(lock.skills);
-	if (skillNames.length === 0) {
+	if (Object.keys(lock.skills).length === 0) {
 		console.log(`${DIM}No skills tracked in lock file.${RESET}`);
 		console.log(`${DIM}Install skills with${RESET} ${TEXT}npx skills add <package>${RESET}`);
 		return;
 	}
-	const token = getGitHubToken();
-	const updates = [];
-	let checkedCount = 0;
-	for (const skillName of skillNames) {
-		const entry = lock.skills[skillName];
-		if (!entry) continue;
-		if (entry.sourceType !== "github" || !entry.skillFolderHash || !entry.skillPath) continue;
-		checkedCount++;
-		try {
-			const latestHash = await fetchSkillFolderHash(entry.source, entry.skillPath, token);
-			if (latestHash && latestHash !== entry.skillFolderHash) updates.push({
-				name: skillName,
-				source: entry.source,
-				entry
-			});
-		} catch {}
-	}
-	if (checkedCount === 0) {
-		console.log(`${DIM}No skills to check.${RESET}`);
+	const result = await detectSkillUpdates(lock, { githubToken: getGitHubToken() });
+	const updates = result.updates;
+	if (result.checkedCount === 0) {
+		console.log(`${DIM}No skills with update metadata to check.${RESET}`);
+		if (result.skippedMissingMetadata > 0) console.log(`${DIM}${result.skippedMissingMetadata} skill(s) are missing hash metadata (reinstall to enable update tracking).${RESET}`);
 		return;
 	}
 	if (updates.length === 0) {
@@ -5198,22 +5322,21 @@ async function runUpdate() {
 	for (const update of updates) {
 		console.log(`${TEXT}Updating ${update.name}...${RESET}`);
 		let installUrl = update.entry.sourceUrl;
-		if (update.entry.skillPath) {
+		const addArgs = [
+			"-y",
+			"skills",
+			"add"
+		];
+		if (update.entry.sourceType === "github" && update.entry.skillPath) {
 			let skillFolder = update.entry.skillPath;
 			if (skillFolder.endsWith("/SKILL.md")) skillFolder = skillFolder.slice(0, -9);
 			else if (skillFolder.endsWith("SKILL.md")) skillFolder = skillFolder.slice(0, -8);
 			if (skillFolder.endsWith("/")) skillFolder = skillFolder.slice(0, -1);
 			installUrl = update.entry.sourceUrl.replace(/\.git$/, "").replace(/\/$/, "");
 			installUrl = `${installUrl}/tree/main/${skillFolder}`;
-		}
-		if (spawnSync("npx", [
-			"-y",
-			"skills",
-			"add",
-			installUrl,
-			"-g",
-			"-y"
-		], { stdio: [
+			addArgs.push(installUrl, "-g", "-y");
+		} else addArgs.push(installUrl, "--skill", update.name, "-g", "-y");
+		if (spawnSync("npx", addArgs, { stdio: [
 			"inherit",
 			"pipe",
 			"pipe"
@@ -5228,6 +5351,7 @@ async function runUpdate() {
 	console.log();
 	if (successCount > 0) console.log(`${TEXT}✓ Updated ${successCount} skill(s)${RESET}`);
 	if (failCount > 0) console.log(`${DIM}Failed to update ${failCount} skill(s)${RESET}`);
+	if (result.skippedMissingMetadata > 0) console.log(`${DIM}Skipped ${result.skippedMissingMetadata} skill(s) missing hash metadata (reinstall to enable update tracking).${RESET}`);
 	track({
 		event: "update",
 		skillCount: String(updates.length),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bud-fe/skills",
-  "version": "0.0.1",
+  "version": "0.0.3",
   "description": "The open agent skills ecosystem",
   "type": "module",
   "bin": {