bip-skills 1.4.5 → 1.4.6

package/dist/cli.mjs

@@ -11,7 +11,7 @@ import "./_chunks/libs/esprima.mjs";
 import { t as xdgConfig } from "./_chunks/libs/xdg-basedir.mjs";
 import { execSync, spawn, spawnSync } from "child_process";
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
-import { basename, dirname, isAbsolute, join, normalize, relative, resolve, sep } from "path";
+import { basename, dirname, isAbsolute, join, normalize, posix, relative, resolve, sep } from "path";
 import { homedir, platform, tmpdir } from "os";
 import { createHash } from "crypto";
 import { fileURLToPath } from "url";
@@ -396,12 +396,9 @@ var GitCloneError = class extends Error {
 };
 async function cloneRepo(url, ref) {
 	const tempDir = await mkdtemp(join(tmpdir(), "skills-"));
-	const git = esm_default({
-		timeout: { block: CLONE_TIMEOUT_MS },
-		env: {
-			...process.env,
-			GIT_TERMINAL_PROMPT: "0"
-		}
+	const git = esm_default({ timeout: { block: CLONE_TIMEOUT_MS } }).env({
+		...process.env,
+		GIT_TERMINAL_PROMPT: "0"
 	});
 	const cloneOptions = ref ? [
 		"--depth",
@@ -1488,6 +1485,54 @@ var WellKnownProvider = class {
 	displayName = "Well-Known Skills";
 	WELL_KNOWN_PATH = ".well-known/skills";
 	INDEX_FILE = "index.json";
+	buildUrl(baseUrl, relativePath) {
+		const normalizedRelative = relativePath.replace(/^\/+/, "");
+		return new URL(normalizedRelative, `${baseUrl.replace(/\/?$/, "/")}`).toString();
+	}
+	getSkillRoot(entry) {
+		if (entry.entry) {
+			const normalizedEntry = posix.normalize(entry.entry).replace(/^\/+/, "");
+			const entryDir = posix.dirname(normalizedEntry);
+			return entryDir === "." ? "" : entryDir;
+		}
+		return entry.name;
+	}
+	resolveRepositoryUrl(index, resolvedBaseUrl, entry) {
+		if (!entry.repositoryId) return `${resolvedBaseUrl.replace(/\/$/, "")}/${this.WELL_KNOWN_PATH}/${this.INDEX_FILE}`;
+		return (index.repositories?.find((repo) => repo.id === entry.repositoryId))?.repository || `${resolvedBaseUrl.replace(/\/$/, "")}/${this.WELL_KNOWN_PATH}/${this.INDEX_FILE}`;
+	}
+	resolveInlineBaseUrl(repositoryUrl) {
+		if (!repositoryUrl.startsWith("http://") && !repositoryUrl.startsWith("https://")) return null;
+		try {
+			const parsed = new URL(repositoryUrl);
+			if (parsed.pathname.endsWith(`/${this.INDEX_FILE}`)) parsed.pathname = parsed.pathname.replace(new RegExp(`/${this.INDEX_FILE}$`), "");
+			else parsed.pathname = parsed.pathname.replace(/\/$/, "");
+			parsed.search = "";
+			parsed.hash = "";
+			return parsed.toString().replace(/\/$/, "");
+		} catch {
+			return null;
+		}
+	}
+	resolveInstallTarget(index, resolvedBaseUrl, entry) {
+		const repositoryUrl = this.resolveRepositoryUrl(index, resolvedBaseUrl, entry);
+		const skillRoot = this.getSkillRoot(entry);
+		const inlineBaseUrl = this.resolveInlineBaseUrl(repositoryUrl);
+		if (inlineBaseUrl) {
+			const skillMdRelativePath = entry.entry || posix.join(skillRoot, "SKILL.md");
+			return {
+				type: "inline",
+				repositoryUrl,
+				skillRoot,
+				skillMdUrl: this.buildUrl(inlineBaseUrl, skillMdRelativePath)
+			};
+		}
+		return {
+			type: "repository",
+			repositoryUrl,
+			subpath: skillRoot
+		};
+	}
 	match(url) {
 		if (!url.startsWith("http://") && !url.startsWith("https://")) return { matches: false };
 		try {
@@ -1530,14 +1575,17 @@ var WellKnownProvider = class {
 				debugLog(`[well-known] index response body: ${responseText}`);
 				const index = JSON.parse(responseText);
 				if (!index.skills || !Array.isArray(index.skills)) continue;
-				let allValid = true;
-				for (const entry of index.skills) if (!this.isValidSkillEntry(entry)) {
-					allValid = false;
-					break;
-				}
-				if (allValid) return {
-					index,
-					resolvedBaseUrl: resolvedBase
+				const totalSkillCount = index.skills.length;
+				const validSkills = index.skills.filter((entry) => this.isValidSkillEntry(entry));
+				const invalidSkillCount = totalSkillCount - validSkills.length;
+				return {
+					index: {
+						...index,
+						skills: validSkills
+					},
+					resolvedBaseUrl: resolvedBase,
+					totalSkillCount,
+					invalidSkillCount
 				};
 			} catch {
 				continue;
@@ -1561,6 +1609,12 @@ var WellKnownProvider = class {
 			if (file.startsWith("/") || file.startsWith("\\") || file.includes("..")) return false;
 		}
 		if (!e.files.some((f) => typeof f === "string" && f.toLowerCase() === "skill.md")) return false;
+		if (e.entry !== void 0) {
+			if (typeof e.entry !== "string") return false;
+			if (e.entry.startsWith("/") || e.entry.startsWith("\\") || e.entry.includes("..")) return false;
+			if (!e.entry.toLowerCase().endsWith("/skill.md") && e.entry.toLowerCase() !== "skill.md") return false;
+		}
+		if (e.repositoryId !== void 0 && typeof e.repositoryId !== "string") return false;
 		return true;
 	}
 	async fetchSkill(url, options = {}) {
@@ -1576,28 +1630,40 @@ var WellKnownProvider = class {
 			if (!skillName) return null;
 			const skillEntry = index.skills.find((s) => s.name === skillName);
 			if (!skillEntry) return null;
-			return this.fetchSkillByEntry(resolvedBaseUrl, skillEntry);
+			return this.fetchSkillByEntry(index, resolvedBaseUrl, skillEntry);
 		} catch {
 			return null;
 		}
 	}
-	async fetchSkillByEntry(baseUrl, entry) {
+	async fetchSkillByEntry(index, baseUrl, entry) {
 		try {
-			const skillBaseUrl = `${baseUrl.replace(/\/$/, "")}/${this.WELL_KNOWN_PATH}/${entry.name}`;
-			const skillMdUrl = `${skillBaseUrl}/SKILL.md`;
-			const response = await fetch(skillMdUrl);
+			const installTarget = this.resolveInstallTarget(index, baseUrl, entry);
+			const files = /* @__PURE__ */ new Map();
+			if (installTarget.type === "repository") return {
+				name: entry.name,
+				description: entry.description,
+				content: "",
+				installName: entry.name,
+				sourceUrl: installTarget.repositoryUrl,
+				files,
+				declaredFiles: [...entry.files],
+				indexEntry: entry,
+				installTarget
+			};
+			const response = await fetch(installTarget.skillMdUrl);
 			if (!response.ok) return null;
 			const content = await response.text();
 			const { data } = (0, import_gray_matter.default)(content);
 			if (!data.name || !data.description) return null;
-			const files = /* @__PURE__ */ new Map();
 			files.set("SKILL.md", content);
 			const filePromises = entry.files.filter((f) => f.toLowerCase() !== "skill.md").map(async (filePath) => {
 				try {
-					const fileUrl = `${skillBaseUrl}/${filePath}`;
+					const normalizedFilePath = filePath.replace(/^\/+/, "");
+					const fileRelativePath = installTarget.skillRoot ? posix.join(installTarget.skillRoot, normalizedFilePath) : normalizedFilePath;
+					const fileUrl = this.buildUrl(this.resolveInlineBaseUrl(installTarget.repositoryUrl) || baseUrl, fileRelativePath);
 					const fileResponse = await fetch(fileUrl);
 					if (fileResponse.ok) return {
-						path: filePath,
+						path: normalizedFilePath,
 						content: await fileResponse.text()
 					};
 				} catch {}
@@ -1610,24 +1676,51 @@ var WellKnownProvider = class {
 				description: data.description,
 				content,
 				installName: entry.name,
-				sourceUrl: skillMdUrl,
+				sourceUrl: installTarget.skillMdUrl,
 				metadata: data.metadata,
 				files,
-				indexEntry: entry
+				declaredFiles: [...entry.files],
+				indexEntry: entry,
+				installTarget
 			};
 		} catch {
 			return null;
 		}
 	}
 	async fetchAllSkills(url, options = {}) {
+		return (await this.fetchAllSkillsWithStatus(url, options)).skills;
+	}
+	async fetchAllSkillsWithStatus(url, options = {}) {
 		try {
 			const result = await this.fetchIndex(url, options);
-			if (!result) return [];
-			const { index, resolvedBaseUrl } = result;
-			const skillPromises = index.skills.map((entry) => this.fetchSkillByEntry(resolvedBaseUrl, entry));
-			return (await Promise.all(skillPromises)).filter((s) => s !== null);
+			if (!result) return {
+				skills: [],
+				status: "index-not-found",
+				totalSkillCount: 0,
+				invalidSkillCount: 0
+			};
+			const { index, resolvedBaseUrl, totalSkillCount, invalidSkillCount } = result;
+			if (index.skills.length === 0) return {
+				skills: [],
+				status: "no-valid-entries",
+				totalSkillCount,
+				invalidSkillCount
+			};
+			const skillPromises = index.skills.map((entry) => this.fetchSkillByEntry(index, resolvedBaseUrl, entry));
+			const skills = (await Promise.all(skillPromises)).filter((s) => s !== null);
+			return {
+				skills,
+				status: skills.length > 0 ? "ok" : "no-installable-skills",
+				totalSkillCount,
+				invalidSkillCount
+			};
 		} catch {
-			return [];
+			return {
+				skills: [],
+				status: "index-not-found",
+				totalSkillCount: 0,
+				invalidSkillCount: 0
+			};
 		}
 	}
 	toRawUrl(url) {
@@ -1833,7 +1926,7 @@ function createEmptyLocalLock() {
 		skills: {}
 	};
 }
-var version$1 = "1.4.5";
+var version$1 = "1.4.6";
 const isCancelled$1 = (value) => typeof value === "symbol";
 async function isSourcePrivate(source) {
 	const ownerRepo = parseOwnerRepo(source);
@@ -1843,6 +1936,40 @@ async function isSourcePrivate(source) {
 function initTelemetry(version) {
 	setVersion(version);
 }
+function getWellKnownFileCount(skill) {
+	return skill.declaredFiles.length > 0 ? skill.declaredFiles.length : skill.files.size;
+}
+function getWellKnownEmptyStateMessage(status, totalSkillCount, invalidSkillCount) {
+	switch (status) {
+		case "no-valid-entries": return totalSkillCount > 0 ? `Found a skills index, but all ${totalSkillCount} entr${totalSkillCount === 1 ? "y is" : "ies are"} invalid. Check that each entry has a top-level SKILL.md in files[].` : "Found a skills index, but it does not contain any valid skill entries.";
+		case "no-installable-skills":
+			if (invalidSkillCount > 0) return `Found a skills index, but no installable skills could be loaded. ${invalidSkillCount} invalid entr${invalidSkillCount === 1 ? "y was" : "ies were"} skipped.`;
+			return "Found a skills index, but no installable skills could be loaded from it.";
+		default: return "No skills found at this URL. Make sure the server has a /.well-known/skills/index.json file.";
+	}
+}
+async function prepareRepositoryBackedWellKnownSkill(skill) {
+	if (skill.installTarget.type !== "repository") throw new Error("Skill is not repository-backed");
+	const tempDir = await cloneRepo(skill.installTarget.repositoryUrl);
+	try {
+		const discovered = await discoverSkills(tempDir, skill.installTarget.subpath, {
+			includeInternal: true,
+			fullDepth: true
+		});
+		const matched = discovered.find((candidate) => candidate.name.toLowerCase() === skill.installName.toLowerCase()) || discovered[0];
+		if (!matched) throw new Error(`No skill found at ${skill.installTarget.repositoryUrl}${skill.installTarget.subpath ? ` (${skill.installTarget.subpath})` : ""}`);
+		return {
+			preparedSkill: {
+				...matched,
+				name: skill.installName
+			},
+			tempDir
+		};
+	} catch (error) {
+		await cleanupTempDir(tempDir).catch(() => {});
+		throw error;
+	}
+}
 function riskLabel(risk) {
 	switch (risk) {
 		case "critical": return import_picocolors.default.red(import_picocolors.default.bold("Critical Risk"));
@@ -2039,14 +2166,15 @@ async function handleWellKnownSkills(source, url, options, spinner, allowFallbac
 	const shouldReportToSun = isInternalSkillSourceUrl(url);
 	try {
 		spinner.start("Discovering skills from well-known endpoint...");
-		const skills = await wellKnownProvider.fetchAllSkills(url, { fallbackToRoot });
+		const discovery = await wellKnownProvider.fetchAllSkillsWithStatus(url, { fallbackToRoot });
+		const skills = discovery.skills;
 		if (skills.length === 0) {
 			if (allowFallback) {
 				spinner.stop(import_picocolors.default.yellow("Default well-known endpoint unavailable"));
 				return false;
 			}
-			spinner.stop(import_picocolors.default.red("No skills found"));
-			Se(import_picocolors.default.red("No skills found at this URL. Make sure the server has a /.well-known/skills/index.json file."));
+			spinner.stop(import_picocolors.default.red("No usable skills found"));
+			Se(import_picocolors.default.red(getWellKnownEmptyStateMessage(discovery.status, discovery.totalSkillCount, discovery.invalidSkillCount)));
 			process.exit(1);
 		}
 		spinner.stop(`Found ${import_picocolors.default.green(skills.length)} skill${skills.length > 1 ? "s" : ""}`);
@@ -2054,6 +2182,7 @@ async function handleWellKnownSkills(source, url, options, spinner, allowFallbac
 			M.info(`Skill: ${import_picocolors.default.cyan(skill.installName)}`);
 			M.message(import_picocolors.default.dim(skill.description));
 			if (skill.files.size > 1) M.message(import_picocolors.default.dim(`  Files: ${Array.from(skill.files.keys()).join(", ")}`));
+			else if (skill.declaredFiles.length > 1) M.message(import_picocolors.default.dim(`  Files: ${skill.declaredFiles.join(", ")}`));
 		}
 		if (options.list) {
 			console.log();
@@ -2061,7 +2190,8 @@ async function handleWellKnownSkills(source, url, options, spinner, allowFallbac
 			for (const skill of skills) {
 				M.message(`  ${import_picocolors.default.cyan(skill.installName)}`);
 				M.message(`    ${import_picocolors.default.dim(skill.description)}`);
-				if (skill.files.size > 1) M.message(`    ${import_picocolors.default.dim(`Files: ${skill.files.size}`)}`);
+				const fileCount = getWellKnownFileCount(skill);
+				if (fileCount > 1) M.message(`    ${import_picocolors.default.dim(`Files: ${fileCount}`)}`);
 			}
 			console.log();
 			Se("Run without --list to install");
@@ -2213,7 +2343,8 @@ async function handleWellKnownSkills(source, url, options, spinner, allowFallbac
 			const shortCanonical = shortenPath$2(getCanonicalPath(skill.installName, { global: installGlobally }), cwd);
 			summaryLines.push(`${import_picocolors.default.cyan(shortCanonical)}`);
 			summaryLines.push(...buildAgentSummaryLines(targetAgents, installMode));
-			if (skill.files.size > 1) summaryLines.push(`  ${import_picocolors.default.dim("files:")} ${skill.files.size}`);
+			const fileCount = getWellKnownFileCount(skill);
+			if (fileCount > 1) summaryLines.push(`  ${import_picocolors.default.dim("files:")} ${fileCount}`);
 			const skillOverwrites = overwriteStatus.get(skill.installName);
 			const overwriteAgents = targetAgents.filter((a) => skillOverwrites?.get(a)).map((a) => agents[a].displayName);
 			if (overwriteAgents.length > 0) summaryLines.push(`  ${import_picocolors.default.yellow("overwrites:")} ${formatList$1(overwriteAgents)}`);
@@ -2227,19 +2358,55 @@ async function handleWellKnownSkills(source, url, options, spinner, allowFallbac
 				process.exit(0);
 			}
 		}
+		const preparedRepositorySkills = /* @__PURE__ */ new Map();
+		const repositoryPrepFailures = /* @__PURE__ */ new Map();
+		const repositoryTempDirs = [];
+		const repositoryBackedSkills = selectedSkills.filter((skill) => skill.installTarget.type === "repository");
+		if (repositoryBackedSkills.length > 0) {
+			spinner.start("Preparing repository-backed skills...");
+			for (const skill of repositoryBackedSkills) try {
+				const prepared = await prepareRepositoryBackedWellKnownSkill(skill);
+				preparedRepositorySkills.set(skill.installName, prepared.preparedSkill);
+				repositoryTempDirs.push(prepared.tempDir);
+			} catch (error) {
+				repositoryPrepFailures.set(skill.installName, error instanceof Error ? error.message : "Unknown error");
+			}
+			spinner.stop("Repository-backed skills prepared");
+		}
 		spinner.start("Installing skills...");
 		const results = [];
 		for (const skill of selectedSkills) for (const agent of targetAgents) {
-			const result = await installWellKnownSkillForAgent(skill, agent, {
+			let installOutcome;
+			const prepError = repositoryPrepFailures.get(skill.installName);
+			if (prepError) installOutcome = {
+				success: false,
+				path: "",
+				mode: installMode,
+				error: prepError
+			};
+			else if (skill.installTarget.type === "repository") {
+				const preparedSkill = preparedRepositorySkills.get(skill.installName);
+				if (!preparedSkill) installOutcome = {
+					success: false,
+					path: "",
+					mode: installMode,
+					error: "Repository-backed skill was not prepared"
+				};
+				else installOutcome = await installSkillForAgent(preparedSkill, agent, {
+					global: installGlobally,
+					mode: installMode
+				});
+			} else installOutcome = await installWellKnownSkillForAgent(skill, agent, {
 				global: installGlobally,
 				mode: installMode
 			});
 			results.push({
 				skill: skill.installName,
 				agent: agents[agent].displayName,
-				...result
+				...installOutcome
 			});
 		}
+		await Promise.all(repositoryTempDirs.map((dir) => cleanupTempDir(dir).catch(() => {})));
 		spinner.stop("Installation complete");
 		console.log();
 		const successful = results.filter((r) => r.success);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bip-skills",
-  "version": "1.4.5",
+  "version": "1.4.6",
   "description": "The open agent skills ecosystem",
   "type": "module",
   "bin": {