@anytio/pspm 0.12.0 → 0.14.0

package/dist/add-CcgUlOLa.js

@@ -0,0 +1,755 @@
+import { a as getGithubSkillVersion, g as listSkillVersions, m as getSkillVersion, n as configure, o as listGithubSkillVersions } from "./api-client-DBXUpGoX.js";
+import { T as extractApiErrorMessage, f as resolveConfig, l as getSkillsDir, p as setGlobalMode, u as isGlobalMode, y as getTokenForRegistry } from "./config-BQy_Rjip.js";
+import { C as downloadGitHubPackage, D as addGitHubDependency, E as addDependency, G as isGitHubSpecifier, H as generateRegistryIdentifier, J as parseGitHubShorthand, K as isGitHubUrl, N as readManifest, O as addLocalDependency, Q as resolveRecursive, R as parseAgentArg, T as getGitHubDisplayName, U as getGitHubSkillName, V as formatGitHubSpecifier, W as isGitHubShorthand, X as parseGitHubUrl, Y as parseGitHubSpecifier, Z as parseRegistrySpecifier, a as getRegistrySkillPath, c as addGitHubToLockfile, d as addToLockfileWithDeps, et as resolveVersion, f as addWellKnownToLockfile, i as getLocalSkillPath, k as addWellKnownDependency, l as addLocalToLockfile, n as getGitHubSkillPath, nt as printResolutionErrors, o as getWellKnownSkillPath, ot as calculateIntegrity, q as isRegistrySpecifier, t as createAgentSymlinks, w as extractGitHubPackage, z as promptForAgents } from "./symlinks-BTw8X0GG.js";
+import { basename, dirname, join, relative, resolve } from "node:path";
+import { mkdir, rm, stat, symlink, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+//#region src/wellknown.ts
+/**
+* Well-Known Skills Discovery (RFC 8615)
+*
+* Fetches skills from any HTTPS domain that serves a
+* /.well-known/skills/index.json endpoint.
+*/
+const WELL_KNOWN_PATH = ".well-known/skills";
+const INDEX_FILE = "index.json";
+const SKILL_NAME_PATTERN = /^[a-z0-9]([a-z0-9-]{0,62}[a-z0-9])?$/;
+/** Hosts that should NOT be treated as well-known (they have dedicated providers) */
+const EXCLUDED_HOSTS = [
+	"github.com",
+	"gitlab.com",
+	"raw.githubusercontent.com"
+];
+/**
+* Check if a string looks like a well-known skills URL.
+* Must be HTTP(S) and not a known git host.
+*/
+function isWellKnownSpecifier(input) {
+	if (!input.startsWith("http://") && !input.startsWith("https://")) return false;
+	try {
+		const parsed = new URL(input);
+		if (EXCLUDED_HOSTS.includes(parsed.hostname)) return false;
+		if (input.endsWith(".git")) return false;
+		return true;
+	} catch {
+		return false;
+	}
+}
+/**
+* Extract hostname from a well-known URL (strips www. prefix).
+*/
+function getWellKnownHostname(url) {
+	try {
+		return new URL(url).hostname.replace(/^www\./, "");
+	} catch {
+		return url;
+	}
+}
+/**
+* Validate a single skill entry from the index.
+*/
+function isValidSkillEntry(entry) {
+	if (!entry || typeof entry !== "object") return false;
+	const e = entry;
+	if (typeof e.name !== "string" || e.name.length === 0) return false;
+	if (typeof e.description !== "string" || e.description.length === 0) return false;
+	if (!SKILL_NAME_PATTERN.test(e.name)) return false;
+	if (!Array.isArray(e.files) || e.files.length === 0) return false;
+	let hasSkillMd = false;
+	for (const file of e.files) {
+		if (typeof file !== "string") return false;
+		if (file.startsWith("/") || file.startsWith("\\")) return false;
+		if (file.includes("..")) return false;
+		if (file.toLowerCase() === "skill.md") hasSkillMd = true;
+	}
+	if (!hasSkillMd) return false;
+	return true;
+}
+/**
+* Validate a well-known index structure.
+*/
+function isValidIndex(data) {
+	if (!data || typeof data !== "object") return false;
+	const d = data;
+	if (!Array.isArray(d.skills)) return false;
+	return d.skills.every(isValidSkillEntry);
+}
+/**
+* Fetch the well-known index from a URL.
+*
+* Tries path-relative first, then root:
+* 1. {baseUrl}/.well-known/skills/index.json
+* 2. {protocol}://{host}/.well-known/skills/index.json
+*/
+async function fetchWellKnownIndex(baseUrl) {
+	const parsed = new URL(baseUrl);
+	const pathRelativeUrl = `${baseUrl.replace(/\/$/, "")}/${WELL_KNOWN_PATH}/${INDEX_FILE}`;
+	const pathRelativeBase = `${baseUrl.replace(/\/$/, "")}/${WELL_KNOWN_PATH}`;
+	try {
+		const response = await fetch(pathRelativeUrl, { signal: AbortSignal.timeout(1e4) });
+		if (response.ok) {
+			const data = await response.json();
+			if (isValidIndex(data)) return {
+				index: data,
+				resolvedBaseUrl: pathRelativeBase
+			};
+		}
+	} catch {}
+	const rootUrl = `${parsed.protocol}//${parsed.host}/${WELL_KNOWN_PATH}/${INDEX_FILE}`;
+	const rootBase = `${parsed.protocol}//${parsed.host}/${WELL_KNOWN_PATH}`;
+	if (rootUrl !== pathRelativeUrl) try {
+		const response = await fetch(rootUrl, { signal: AbortSignal.timeout(1e4) });
+		if (response.ok) {
+			const data = await response.json();
+			if (isValidIndex(data)) return {
+				index: data,
+				resolvedBaseUrl: rootBase
+			};
+		}
+	} catch {}
+	return null;
+}
+/**
+* Fetch a single skill's files from a well-known endpoint.
+*/
+async function fetchSkillFiles(baseUrl, entry) {
+	const skillBaseUrl = `${baseUrl}/${entry.name}`;
+	const files = /* @__PURE__ */ new Map();
+	let skillMdContent = "";
+	const results = await Promise.allSettled(entry.files.map(async (filePath) => {
+		const fileUrl = `${skillBaseUrl}/${filePath}`;
+		const response = await fetch(fileUrl, { signal: AbortSignal.timeout(1e4) });
+		if (!response.ok) throw new Error(`Failed to fetch ${fileUrl}: ${response.status}`);
+		return {
+			filePath,
+			content: await response.text()
+		};
+	}));
+	for (const result of results) if (result.status === "fulfilled") {
+		files.set(result.value.filePath, result.value.content);
+		if (result.value.filePath.toLowerCase() === "skill.md") skillMdContent = result.value.content;
+	}
+	if (!skillMdContent) return null;
+	return {
+		name: entry.name,
+		description: entry.description,
+		content: skillMdContent,
+		files,
+		sourceUrl: `${skillBaseUrl}/SKILL.md`,
+		indexEntry: entry
+	};
+}
+/**
+* Fetch all skills from a well-known endpoint.
+*/
+async function fetchWellKnownSkills(url) {
+	const result = await fetchWellKnownIndex(url);
+	if (!result) return null;
+	const { index, resolvedBaseUrl } = result;
+	const hostname = getWellKnownHostname(url);
+	const skillResults = await Promise.allSettled(index.skills.map((entry) => fetchSkillFiles(resolvedBaseUrl, entry)));
+	const skills = [];
+	for (const r of skillResults) if (r.status === "fulfilled" && r.value) skills.push(r.value);
+	if (skills.length === 0) return null;
+	return {
+		skills,
+		resolvedBaseUrl,
+		hostname
+	};
+}
+/**
+* Extract a well-known skill to the .pspm/skills/_wellknown/ directory.
+*
+* @param skill - The fetched skill
+* @param hostname - Source hostname (for directory namespacing)
+* @param skillsDir - Base skills directory (.pspm/skills)
+* @returns Path to extracted skill (relative to project root)
+*/
+async function extractWellKnownSkill(skill, hostname, skillsDir) {
+	const destPath = join(skillsDir, "_wellknown", hostname, skill.name);
+	await rm(destPath, {
+		recursive: true,
+		force: true
+	});
+	await mkdir(destPath, { recursive: true });
+	for (const [filePath, content] of skill.files) {
+		const fullPath = join(destPath, filePath);
+		if (!fullPath.startsWith(destPath)) continue;
+		const { dirname } = await import("node:path");
+		await mkdir(dirname(fullPath), { recursive: true });
+		await writeFile(fullPath, content, "utf-8");
+	}
+	return `.pspm/skills/_wellknown/${hostname}/${skill.name}`;
+}
+/**
+* Calculate integrity hash for a well-known skill (hash of all file contents).
+*/
+function calculateWellKnownIntegrity(skill) {
+	const combined = [...skill.files.entries()].sort(([a], [b]) => a.localeCompare(b)).map(([path, content]) => `${path}:${content}`).join("\n");
+	return calculateIntegrity(Buffer.from(combined, "utf-8"));
+}
+/**
+* Get display name for a well-known skill.
+*/
+function getWellKnownDisplayName(hostname, skillName) {
+	return `${hostname}/${skillName} (well-known)`;
+}
+//#endregion
+//#region src/commands/add-helpers.ts
+/**
+* Check if a specifier is a local file reference.
+*/
+function isLocalSpecifier(specifier) {
+	return specifier.startsWith("file:") || specifier.startsWith("./") || specifier.startsWith("../");
+}
+/**
+* Parse a local specifier and return the path.
+*/
+function parseLocalPath(specifier) {
+	if (specifier.startsWith("file:")) return specifier.slice(5);
+	return specifier;
+}
+/**
+* Normalize a path to a file: specifier.
+*/
+function normalizeToFileSpecifier(path) {
+	if (path.startsWith("file:")) return path;
+	return `file:${path}`;
+}
+/**
+* Get the root directory for symlink creation.
+* Global: home directory. Project: current working directory.
+*/
+function getSymlinkRoot() {
+	return isGlobalMode() ? homedir() : process.cwd();
+}
+/**
+* Parse any GitHub input format into a GitHubSpecifier.
+*
+* Accepts:
+* - github:owner/repo[/path][@ref]  (canonical prefix format)
+* - https://github.com/owner/repo   (full URL)
+* - https://github.com/owner/repo/tree/branch/path  (tree URL)
+* - owner/repo[/path]               (shorthand)
+*/
+function parseAnyGitHubFormat(specifier) {
+	if (isGitHubSpecifier(specifier)) return parseGitHubSpecifier(specifier);
+	if (isGitHubUrl(specifier)) return parseGitHubUrl(specifier);
+	if (isGitHubShorthand(specifier)) return parseGitHubShorthand(specifier);
+	return null;
+}
+//#endregion
+//#region src/commands/add-github.ts
+/**
+* Validate and download a GitHub package.
+*/
+async function validateGitHubPackage(specifier) {
+	const parsed = parseAnyGitHubFormat(specifier);
+	if (!parsed) throw new Error(`Invalid GitHub specifier "${specifier}". Supported formats:\n  github:owner/repo[/path][@ref]\n  https://github.com/owner/repo[/tree/branch/path]\n  owner/repo[/path]`);
+	const ref = parsed.ref || "HEAD";
+	console.log(`Resolving ${getGitHubDisplayName(parsed)}...`);
+	const result = await downloadGitHubPackage(parsed);
+	console.log(`Resolved ${specifier} (${ref}@${result.commit.slice(0, 7)})`);
+	return {
+		type: "github",
+		specifier,
+		parsed,
+		ref,
+		downloadResult: result
+	};
+}
+/**
+* Install a pre-validated GitHub package.
+*/
+async function installGitHubPackage(resolved, options) {
+	const { specifier, parsed, ref, downloadResult } = resolved;
+	console.log(`Installing ${specifier} (${ref}@${downloadResult.commit.slice(0, 7)})...`);
+	const skillsDir = getSkillsDir();
+	const destPath = await extractGitHubPackage(parsed, downloadResult.buffer, skillsDir);
+	const lockfileSpecifier = formatGitHubSpecifier({
+		owner: parsed.owner,
+		repo: parsed.repo,
+		path: parsed.path
+	});
+	await addGitHubToLockfile(lockfileSpecifier, {
+		version: downloadResult.commit.slice(0, 7),
+		resolved: `https://github.com/${parsed.owner}/${parsed.repo}`,
+		integrity: downloadResult.integrity,
+		gitCommit: downloadResult.commit,
+		gitRef: ref
+	});
+	await addGitHubDependency(lockfileSpecifier, ref);
+	const agents = options.resolvedAgents;
+	if (agents[0] !== "none") {
+		const manifest = await readManifest();
+		await createAgentSymlinks([{
+			name: getGitHubSkillName(parsed),
+			sourcePath: getGitHubSkillPath(parsed.owner, parsed.repo, parsed.path)
+		}], {
+			agents,
+			projectRoot: getSymlinkRoot(),
+			agentConfigs: manifest?.agents,
+			global: isGlobalMode()
+		});
+	}
+	console.log(`Installed ${specifier} (${ref}@${downloadResult.commit.slice(0, 7)})`);
+	console.log(`Location: ${destPath}`);
+}
+//#endregion
+//#region src/commands/add-local.ts
+/**
+* Validate a local package path exists and contains a valid skill.
+*/
+async function validateLocalPackage(specifier) {
+	const path = parseLocalPath(specifier);
+	const resolvedPath = resolve(process.cwd(), path);
+	const normalizedSpecifier = normalizeToFileSpecifier(path);
+	console.log(`Resolving ${specifier}...`);
+	try {
+		if (!(await stat(resolvedPath)).isDirectory()) throw new Error(`Path is not a directory: ${resolvedPath}`);
+	} catch (error) {
+		if (error.code === "ENOENT") throw new Error(`Directory not found: ${resolvedPath}\n  Check that the path exists and is accessible.`);
+		throw error;
+	}
+	let hasSkillMd = false;
+	let hasPspmJson = false;
+	try {
+		await stat(join(resolvedPath, "SKILL.md"));
+		hasSkillMd = true;
+	} catch {}
+	try {
+		await stat(join(resolvedPath, "pspm.json"));
+		hasPspmJson = true;
+	} catch {}
+	if (!hasSkillMd && !hasPspmJson) throw new Error(`Not a valid skill directory: ${resolvedPath}\n  Missing both SKILL.md and pspm.json. At least one is required.`);
+	const name = basename(resolvedPath);
+	console.log(`Resolved ${specifier} -> ${resolvedPath}`);
+	return {
+		type: "local",
+		specifier,
+		normalizedSpecifier,
+		path,
+		resolvedPath,
+		name
+	};
+}
+/**
+* Install a local package by creating a symlink.
+*/
+async function installLocalPackage(resolved, options) {
+	const { specifier, normalizedSpecifier, path, resolvedPath, name } = resolved;
+	console.log(`Installing ${specifier}...`);
+	const localSkillsDir = join(getSkillsDir(), "_local");
+	await mkdir(localSkillsDir, { recursive: true });
+	const symlinkPath = join(localSkillsDir, name);
+	const relativeTarget = relative(dirname(symlinkPath), resolvedPath);
+	try {
+		await rm(symlinkPath, { force: true });
+	} catch {}
+	await symlink(relativeTarget, symlinkPath);
+	await addLocalToLockfile(normalizedSpecifier, {
+		version: "local",
+		path,
+		resolvedPath,
+		name
+	});
+	await addLocalDependency(normalizedSpecifier);
+	const agents = options.resolvedAgents;
+	if (agents[0] !== "none") {
+		const manifest = await readManifest();
+		await createAgentSymlinks([{
+			name,
+			sourcePath: getLocalSkillPath(name)
+		}], {
+			agents,
+			projectRoot: getSymlinkRoot(),
+			agentConfigs: manifest?.agents,
+			global: isGlobalMode()
+		});
+	}
+	console.log(`Installed ${specifier} (local)`);
+	console.log(`Location: ${symlinkPath} -> ${resolvedPath}`);
+}
+//#endregion
+//#region src/commands/add-registry.ts
+/**
+* Validate and resolve a registry package (without downloading).
+*/
+async function validateRegistryPackage(specifier) {
+	const config = await resolveConfig();
+	const registryUrl = config.registryUrl;
+	const apiKey = getTokenForRegistry(config, registryUrl);
+	const parsed = parseRegistrySpecifier(specifier);
+	if (!parsed) throw new Error(`Invalid skill specifier "${specifier}". Use format: @user/{username}/{name}[@{version}] or @org/{orgname}/{name}[@{version}]`);
+	const { namespace, owner, name, subname, versionRange } = parsed;
+	const fullName = generateRegistryIdentifier({
+		namespace,
+		owner,
+		name,
+		subname
+	});
+	configure({
+		registryUrl,
+		apiKey
+	});
+	console.log(`Resolving ${specifier}...`);
+	const versionStrings = (await fetchRegistryVersions(namespace, owner, name, subname, fullName, apiKey)).map((v) => v.version);
+	const resolvedVersion = resolveVersion(versionRange || "*", versionStrings);
+	if (!resolvedVersion) throw new Error(`No version matching "${versionRange || "latest"}" found for ${fullName}. Available versions: ${versionStrings.join(", ")}`);
+	const { downloadUrl, checksum } = await fetchRegistryVersionInfo(namespace, owner, name, subname, resolvedVersion, fullName);
+	console.log(`Resolved ${fullName}@${resolvedVersion}`);
+	return {
+		type: "registry",
+		specifier,
+		namespace,
+		owner,
+		name,
+		subname,
+		versionRange,
+		resolvedVersion,
+		versionInfo: {
+			downloadUrl,
+			checksum
+		}
+	};
+}
+async function fetchRegistryVersions(namespace, owner, name, subname, fullName, apiKey) {
+	if (namespace === "github" && subname) {
+		const versionsResponse = await listGithubSkillVersions(owner, name, subname);
+		if (versionsResponse.status !== 200 || !versionsResponse.data) {
+			if (versionsResponse.status === 401) throw new Error(apiKey ? `Access denied to ${fullName}. You may not have permission to access this private package.` : `Package ${fullName} requires authentication. Please run 'pspm login' to authenticate`);
+			throw new Error(versionsResponse.error || `Skill ${fullName} not found`);
+		}
+		return versionsResponse.data;
+	}
+	const versionsResponse = await listSkillVersions(owner, name);
+	if (versionsResponse.status !== 200) {
+		if (versionsResponse.status === 401) {
+			if (!apiKey) throw new Error(`Package ${fullName} requires authentication. Please run 'pspm login' to authenticate`);
+			throw new Error(`Access denied to ${fullName}. You may not have permission to access this private package.`);
+		}
+		const errorMessage = extractApiErrorMessage(versionsResponse, `Skill ${fullName} not found`);
+		throw new Error(errorMessage);
+	}
+	if (versionsResponse.data.length === 0) throw new Error(`Skill ${fullName} not found`);
+	return versionsResponse.data;
+}
+async function fetchRegistryVersionInfo(namespace, owner, name, subname, resolvedVersion, fullName) {
+	if (namespace === "github" && subname) {
+		const versionResponse = await getGithubSkillVersion(owner, name, subname, resolvedVersion);
+		if (versionResponse.status !== 200 || !versionResponse.data) throw new Error(`Version ${resolvedVersion} not found for ${fullName}`);
+		return {
+			downloadUrl: versionResponse.data.downloadUrl,
+			checksum: versionResponse.data.checksum
+		};
+	}
+	const versionResponse = await getSkillVersion(owner, name, resolvedVersion);
+	if (versionResponse.status !== 200 || !versionResponse.data) {
+		const errorMessage = extractApiErrorMessage(versionResponse, `Version ${resolvedVersion} not found`);
+		throw new Error(errorMessage);
+	}
+	return {
+		downloadUrl: versionResponse.data.downloadUrl,
+		checksum: versionResponse.data.checksum
+	};
+}
+/**
+* Install a package from a DependencyNode (resolved from resolver).
+*/
+async function installFromNode(node, options) {
+	const parsed = parseRegistrySpecifier(node.name);
+	if (!parsed) throw new Error(`Invalid package name: ${node.name}`);
+	const { namespace, owner, name, subname } = parsed;
+	console.log(`Installing ${node.name}@${node.version}...`);
+	const config = await resolveConfig();
+	const tarballBuffer = await downloadNodeTarball(node, getTokenForRegistry(config, config.registryUrl));
+	const integrity = calculateIntegrity(tarballBuffer);
+	if (integrity !== node.integrity) throw new Error("Checksum verification failed");
+	const skillsDir = getSkillsDir();
+	const effectiveSkillName = subname ?? name;
+	const destDir = resolveRegistryDestDir(namespace, owner, name, subname, effectiveSkillName, skillsDir);
+	await extractRegistryTarball(destDir, tarballBuffer);
+	const resolvedDeps = {};
+	for (const [depName, range] of Object.entries(node.dependencies)) resolvedDeps[depName] = range;
+	await addToLockfileWithDeps(node.name, {
+		version: node.version,
+		resolved: node.downloadUrl,
+		integrity,
+		deprecated: node.deprecated
+	}, Object.keys(resolvedDeps).length > 0 ? resolvedDeps : void 0);
+	if (options.isDirect) {
+		const dependencyRange = node.versionRange || `^${node.version}`;
+		await addDependency(node.name, dependencyRange);
+	}
+	const agents = options.resolvedAgents;
+	if (agents[0] !== "none") {
+		const skillManifest = await readManifest();
+		await createAgentSymlinks([{
+			name: effectiveSkillName,
+			sourcePath: getRegistrySkillPath(namespace, owner, namespace === "github" && subname ? `${name}/${subname}` : name)
+		}], {
+			agents,
+			projectRoot: getSymlinkRoot(),
+			agentConfigs: skillManifest?.agents,
+			global: isGlobalMode()
+		});
+	}
+	console.log(`Installed ${node.name}@${node.version}`);
+	console.log(`Location: ${destDir}`);
+}
+async function downloadNodeTarball(node, apiKey) {
+	const isPresignedUrl = node.downloadUrl.includes(".r2.cloudflarestorage.com") || node.downloadUrl.includes("X-Amz-Signature");
+	const downloadHeaders = {};
+	if (!isPresignedUrl && apiKey) downloadHeaders.Authorization = `Bearer ${apiKey}`;
+	const tarballResponse = await fetch(node.downloadUrl, {
+		headers: downloadHeaders,
+		redirect: "follow"
+	});
+	if (!tarballResponse.ok) throw new Error(`Failed to download tarball (${tarballResponse.status})`);
+	return Buffer.from(await tarballResponse.arrayBuffer());
+}
+function resolveRegistryDestDir(namespace, owner, name, subname, effectiveSkillName, skillsDir) {
+	if (namespace === "org") return join(skillsDir, "_org", owner, effectiveSkillName);
+	if (namespace === "github" && subname) return join(skillsDir, "_github-registry", owner, name, subname);
+	return join(skillsDir, owner, effectiveSkillName);
+}
+async function extractRegistryTarball(destDir, tarballBuffer) {
+	await rm(destDir, {
+		recursive: true,
+		force: true
+	});
+	await mkdir(destDir, { recursive: true });
+	const { writeFile } = await import("node:fs/promises");
+	const tempFile = join(destDir, ".temp.tgz");
+	await writeFile(tempFile, tarballBuffer);
+	const { exec } = await import("node:child_process");
+	const { promisify } = await import("node:util");
+	const execAsync = promisify(exec);
+	try {
+		await execAsync(`tar -xzf "${tempFile}" -C "${destDir}" --strip-components=1`);
+	} finally {
+		await rm(tempFile, { force: true });
+	}
+}
+//#endregion
+//#region src/commands/add-wellknown.ts
+/**
+* Validate and fetch skills from a well-known endpoint.
+*/
+async function validateWellKnownPackage(specifier) {
+	const hostname = getWellKnownHostname(specifier);
+	console.log(`Discovering skills from ${hostname}...`);
+	const result = await fetchWellKnownSkills(specifier);
+	if (!result) throw new Error(`No well-known skills found at ${specifier}\n  Expected: ${specifier}/.well-known/skills/index.json`);
+	console.log(`Found ${result.skills.length} skill(s) from ${hostname}: ${result.skills.map((s) => s.name).join(", ")}`);
+	return {
+		type: "wellknown",
+		specifier,
+		hostname: result.hostname,
+		skills: result.skills,
+		resolvedBaseUrl: result.resolvedBaseUrl
+	};
+}
+/**
+* Install pre-validated well-known skills.
+*/
+async function installWellKnownPackage(resolved, options) {
+	const { specifier, hostname, skills } = resolved;
+	const skillsDir = getSkillsDir();
+	for (const skill of skills) {
+		console.log(`Installing ${getWellKnownDisplayName(hostname, skill.name)}...`);
+		const destPath = await extractWellKnownSkill(skill, hostname, skillsDir);
+		const integrity = calculateWellKnownIntegrity(skill);
+		await addWellKnownToLockfile(`${specifier}#${skill.name}`, {
+			version: "well-known",
+			resolved: skill.sourceUrl,
+			integrity,
+			hostname,
+			name: skill.name,
+			files: [...skill.files.keys()]
+		});
+		await addWellKnownDependency(specifier, [skill.name]);
+		const agents = options.resolvedAgents;
+		if (agents[0] !== "none") {
+			const manifest = await readManifest();
+			await createAgentSymlinks([{
+				name: skill.name,
+				sourcePath: getWellKnownSkillPath(hostname, skill.name)
+			}], {
+				agents,
+				projectRoot: process.cwd(),
+				agentConfigs: manifest?.agents
+			});
+		}
+		console.log(`Installed ${getWellKnownDisplayName(hostname, skill.name)}`);
+		console.log(`Location: ${destPath}`);
+	}
+}
+//#endregion
+//#region src/commands/add.ts
+async function add(specifiers, options) {
+	if (options.global) {
+		setGlobalMode(true);
+		console.log("Installing globally to ~/.pspm/\n");
+	}
+	console.log("Resolving packages...\n");
+	const { resolvedPackages, validationErrors } = await validateAllPackages(specifiers);
+	if (resolvedPackages.length === 0) {
+		console.error("No packages could be resolved.");
+		process.exit(1);
+	}
+	if (validationErrors.length > 0) console.log(`Resolved ${resolvedPackages.length} of ${specifiers.length} packages.\n`);
+	const config = await resolveConfig();
+	const apiKey = getTokenForRegistry(config, config.registryUrl);
+	const registryPackages = resolvedPackages.filter((p) => p.type === "registry");
+	const githubPackages = resolvedPackages.filter((p) => p.type === "github");
+	const localPackages = resolvedPackages.filter((p) => p.type === "local");
+	const wellKnownPackages = resolvedPackages.filter((p) => p.type === "wellknown");
+	let resolutionResult = null;
+	if (registryPackages.length > 0) {
+		const rootDeps = {};
+		for (const pkg of registryPackages) {
+			const fullName = generateRegistryIdentifier({
+				namespace: pkg.namespace,
+				owner: pkg.owner,
+				name: pkg.name,
+				subname: pkg.subname
+			});
+			rootDeps[fullName] = pkg.versionRange || `^${pkg.resolvedVersion}`;
+		}
+		console.log("Resolving dependencies...");
+		resolutionResult = await resolveRecursive(rootDeps, {
+			maxDepth: 5,
+			registryUrl: config.registryUrl,
+			apiKey
+		});
+		if (!resolutionResult.success) {
+			printResolutionErrors(resolutionResult.graph.errors, resolutionResult.graph.conflicts);
+			process.exit(1);
+		}
+		const transitiveDeps = resolutionResult.installOrder.filter((name) => !rootDeps[name]);
+		if (transitiveDeps.length > 0) console.log(`Resolved ${transitiveDeps.length} transitive dependencies.\n`);
+		else console.log();
+	}
+	const agents = await resolveAgents(options);
+	const results = [];
+	if (resolutionResult) for (const name of resolutionResult.installOrder) {
+		const node = resolutionResult.graph.nodes.get(name);
+		if (!node) continue;
+		try {
+			await installFromNode(node, {
+				...options,
+				resolvedAgents: agents,
+				isDirect: node.isDirect
+			});
+			results.push({
+				specifier: name,
+				success: true
+			});
+		} catch (error) {
+			const message = error instanceof Error ? error.message : "Unknown error";
+			results.push({
+				specifier: name,
+				success: false,
+				error: message
+			});
+			console.error(`Failed to install ${name}: ${message}\n`);
+		}
+	}
+	for (const resolved of githubPackages) try {
+		await installGitHubPackage(resolved, {
+			...options,
+			resolvedAgents: agents
+		});
+		results.push({
+			specifier: resolved.specifier,
+			success: true
+		});
+	} catch (error) {
+		const message = error instanceof Error ? error.message : "Unknown error";
+		results.push({
+			specifier: resolved.specifier,
+			success: false,
+			error: message
+		});
+		console.error(`Failed to install ${resolved.specifier}: ${message}\n`);
+	}
+	for (const resolved of localPackages) try {
+		await installLocalPackage(resolved, {
+			...options,
+			resolvedAgents: agents
+		});
+		results.push({
+			specifier: resolved.specifier,
+			success: true
+		});
+	} catch (error) {
+		const message = error instanceof Error ? error.message : "Unknown error";
+		results.push({
+			specifier: resolved.specifier,
+			success: false,
+			error: message
+		});
+		console.error(`Failed to install ${resolved.specifier}: ${message}\n`);
+	}
+	for (const resolved of wellKnownPackages) try {
+		await installWellKnownPackage(resolved, {
+			...options,
+			resolvedAgents: agents
+		});
+		results.push({
+			specifier: resolved.specifier,
+			success: true
+		});
+	} catch (error) {
+		const message = error instanceof Error ? error.message : "Unknown error";
+		results.push({
+			specifier: resolved.specifier,
+			success: false,
+			error: message
+		});
+		console.error(`Failed to install ${resolved.specifier}: ${message}\n`);
+	}
+	if (specifiers.length > 1) {
+		const succeeded = results.filter((r) => r.success).length;
+		const failed = results.filter((r) => !r.success).length + validationErrors.length;
+		console.log(`\nSummary: ${succeeded} added, ${failed} failed`);
+		if (failed > 0) process.exit(1);
+	}
+}
+async function validateAllPackages(specifiers) {
+	const resolvedPackages = [];
+	const validationErrors = [];
+	for (const specifier of specifiers) try {
+		if (isLocalSpecifier(specifier)) resolvedPackages.push(await validateLocalPackage(specifier));
+		else if (isGitHubSpecifier(specifier) || isGitHubUrl(specifier) || isGitHubShorthand(specifier)) resolvedPackages.push(await validateGitHubPackage(specifier));
+		else if (isWellKnownSpecifier(specifier)) resolvedPackages.push(await validateWellKnownPackage(specifier));
+		else if (isRegistrySpecifier(specifier)) resolvedPackages.push(await validateRegistryPackage(specifier));
+		else throw new Error(`Unknown specifier format "${specifier}". Supported formats:\n  @user/{username}/{name}[@version]  (registry)\n  @org/{orgname}/{name}[@version]    (organization)\n  github:owner/repo[/path][@ref]     (github)\n  file:./path/to/skill               (local)\n  owner/repo                         (github shorthand)`);
+	} catch (error) {
+		const message = error instanceof Error ? error.message : "Unknown error";
+		validationErrors.push({
+			specifier,
+			error: message
+		});
+		console.error(`Failed to resolve ${specifier}: ${message}\n`);
+	}
+	return {
+		resolvedPackages,
+		validationErrors
+	};
+}
+async function resolveAgents(options) {
+	const manifest = await readManifest();
+	if (options.agent) return parseAgentArg(options.agent);
+	if (manifest) return parseAgentArg(void 0);
+	if (options.yes) return parseAgentArg(void 0);
+	console.log("No pspm.json found. Let's set up your project.\n");
+	const agents = await promptForAgents();
+	console.log();
+	return agents;
+}
+//#endregion
+export { add as t };
+
+//# sourceMappingURL=add-CcgUlOLa.js.map