@anytio/pspm 0.8.0 → 0.9.0

package/dist/index.js

@@ -74,7 +74,7 @@ var init_fetcher = __esm({
 });
 
 // src/sdk/generated/index.ts
-var getMeUrl, me, getDeleteSkillUrl, deleteSkill, getListSkillVersionsUrl, listSkillVersions, getGetSkillVersionUrl, getSkillVersion, getDeleteSkillVersionUrl, deleteSkillVersion, getPublishSkillUrl, publishSkill;
+var getMeUrl, me, getExplorePublicSkillsUrl, explorePublicSkills, getDeleteSkillUrl, deleteSkill, getListSkillVersionsUrl, listSkillVersions, getGetSkillVersionUrl, getSkillVersion, getDeleteSkillVersionUrl, deleteSkillVersion, getPublishSkillUrl, publishSkill;
 var init_generated = __esm({
   "src/sdk/generated/index.ts"() {
     init_fetcher();
@@ -90,6 +90,25 @@ var init_generated = __esm({
         }
       );
     };
+    getExplorePublicSkillsUrl = (params) => {
+      const normalizedParams = new URLSearchParams();
+      Object.entries(params || {}).forEach(([key, value]) => {
+        if (value !== void 0) {
+          normalizedParams.append(key, value === null ? "null" : value.toString());
+        }
+      });
+      const stringifiedParams = normalizedParams.toString();
+      return stringifiedParams.length > 0 ? `/api/skills/-/explore?${stringifiedParams}` : `/api/skills/-/explore`;
+    };
+    explorePublicSkills = async (params, options) => {
+      return customFetch(
+        getExplorePublicSkillsUrl(params),
+        {
+          ...options,
+          method: "GET"
+        }
+      );
+    };
     getDeleteSkillUrl = (username, name) => {
       return `/api/skills/@user/${username}/${name}`;
     };
@@ -368,22 +387,54 @@ var init_errors = __esm({
     };
   }
 });
+
+// src/config.ts
+var config_exports = {};
+__export(config_exports, {
+  clearCredentials: () => clearCredentials,
+  findProjectConfig: () => findProjectConfig,
+  getCacheDir: () => getCacheDir,
+  getConfigPath: () => getConfigPath,
+  getLegacyLockfilePath: () => getLegacyLockfilePath,
+  getLegacySkillsDir: () => getLegacySkillsDir,
+  getLockfilePath: () => getLockfilePath,
+  getPspmDir: () => getPspmDir,
+  getRegistryUrl: () => getRegistryUrl,
+  getSkillsDir: () => getSkillsDir,
+  getTokenForRegistry: () => getTokenForRegistry,
+  isGlobalMode: () => isGlobalMode,
+  isLoggedIn: () => isLoggedIn,
+  readUserConfig: () => readUserConfig,
+  requireApiKey: () => requireApiKey,
+  resolveConfig: () => resolveConfig,
+  setCredentials: () => setCredentials,
+  setGlobalMode: () => setGlobalMode,
+  writeUserConfig: () => writeUserConfig
+});
 function getConfigPath() {
   return join(homedir(), ".pspmrc");
 }
 function getLegacyConfigPath() {
   return join(homedir(), ".pspm", "config.json");
 }
+function setGlobalMode(global) {
+  _globalMode = global;
+}
+function isGlobalMode() {
+  return _globalMode;
+}
 function getPspmDir() {
+  if (_globalMode) return join(homedir(), ".pspm");
   return join(process.cwd(), ".pspm");
 }
 function getSkillsDir() {
-  return join(process.cwd(), ".pspm", "skills");
+  return join(getPspmDir(), "skills");
 }
 function getCacheDir() {
-  return join(process.cwd(), ".pspm", "cache");
+  return join(getPspmDir(), "cache");
 }
 function getLockfilePath() {
+  if (_globalMode) return join(homedir(), ".pspm", "pspm-lock.json");
   return join(process.cwd(), "pspm-lock.json");
 }
 function getLegacyLockfilePath() {
@@ -637,11 +688,12 @@ async function getRegistryUrl() {
   const resolved = await resolveConfig();
   return resolved.registryUrl;
 }
-var DEFAULT_REGISTRY_URL;
+var DEFAULT_REGISTRY_URL, _globalMode;
 var init_config = __esm({
   "src/config.ts"() {
     init_errors();
     DEFAULT_REGISTRY_URL = "https://registry.pspm.dev";
+    _globalMode = false;
   }
 });
 async function loadIgnorePatterns(cwd = process.cwd()) {
@@ -1130,11 +1182,57 @@ function getGitHubSkillName(spec) {
 function isGitHubSpecifier(specifier) {
   return specifier.startsWith("github:");
 }
-var SPECIFIER_PATTERN, GITHUB_SPECIFIER_PATTERN;
+function isGitHubUrl(input) {
+  return /^https?:\/\/github\.com\/[^/]+\/[^/]+/.test(input);
+}
+function parseGitHubUrl(input) {
+  const treeMatch = input.match(GITHUB_URL_TREE_PATTERN);
+  if (treeMatch) {
+    const [, owner, repo, ref, path] = treeMatch;
+    if (!owner || !repo || !ref) return null;
+    return {
+      owner,
+      repo,
+      ref,
+      path: path || void 0
+    };
+  }
+  const repoMatch = input.match(GITHUB_URL_PATTERN);
+  if (repoMatch) {
+    const [, owner, repo] = repoMatch;
+    if (!owner || !repo) return null;
+    return { owner, repo };
+  }
+  return null;
+}
+function isGitHubShorthand(input) {
+  if (input.includes(":") || input.startsWith(".") || input.startsWith("/") || input.startsWith("@")) {
+    return false;
+  }
+  return GITHUB_SHORTHAND_PATTERN.test(input);
+}
+function parseGitHubShorthand(input) {
+  if (input.includes(":") || input.startsWith(".") || input.startsWith("/") || input.startsWith("@")) {
+    return null;
+  }
+  const match = input.match(GITHUB_SHORTHAND_PATTERN);
+  if (!match) return null;
+  const [, owner, repo, path] = match;
+  if (!owner || !repo) return null;
+  return {
+    owner,
+    repo,
+    path: path || void 0
+  };
+}
+var SPECIFIER_PATTERN, GITHUB_SPECIFIER_PATTERN, GITHUB_URL_TREE_PATTERN, GITHUB_URL_PATTERN, GITHUB_SHORTHAND_PATTERN;
 var init_specifier = __esm({
   "src/lib/specifier.ts"() {
     SPECIFIER_PATTERN = /^@user\/([a-zA-Z0-9_-]+)\/([a-z][a-z0-9_-]*)(?:@(.+))?$/;
     GITHUB_SPECIFIER_PATTERN = /^github:([a-zA-Z0-9_-]+)\/([a-zA-Z0-9_.-]+)(\/[^@]+)?(?:@(.+))?$/;
+    GITHUB_URL_TREE_PATTERN = /^https?:\/\/github\.com\/([^/]+)\/([^/]+)\/tree\/([^/]+)(?:\/(.+))?$/;
+    GITHUB_URL_PATTERN = /^https?:\/\/github\.com\/([^/]+)\/([^/]+?)(?:\.git)?\/?$/;
+    GITHUB_SHORTHAND_PATTERN = /^([a-zA-Z0-9_-]+)\/([a-zA-Z0-9_.-]+)(?:\/(.+))?$/;
   }
 });
 
@@ -1150,12 +1248,15 @@ var init_lib = __esm({
     init_version();
   }
 });
-function resolveAgentConfig(name, overrides) {
-  if (overrides?.[name]) {
+function resolveAgentConfig(name, overrides, global) {
+  if (!global && overrides?.[name]) {
     return overrides[name];
   }
-  if (name in DEFAULT_AGENT_CONFIGS) {
-    return DEFAULT_AGENT_CONFIGS[name];
+  if (name in AGENT_INFO) {
+    const info = AGENT_INFO[name];
+    return {
+      skillsDir: global ? info.globalSkillsDir : info.skillsDir
+    };
   }
   return null;
 }
@@ -1193,47 +1294,221 @@ var AGENT_INFO, DEFAULT_AGENT_CONFIGS, ALL_AGENTS;
 var init_agents = __esm({
   "src/agents.ts"() {
     AGENT_INFO = {
+      adal: {
+        displayName: "AdaL",
+        skillsDir: ".adal/skills",
+        globalSkillsDir: ".adal/skills"
+      },
+      amp: {
+        displayName: "Amp",
+        skillsDir: ".agents/skills",
+        globalSkillsDir: ".config/agents/skills"
+      },
+      antigravity: {
+        displayName: "Antigravity",
+        skillsDir: ".agent/skills",
+        globalSkillsDir: ".gemini/antigravity/skills"
+      },
+      augment: {
+        displayName: "Augment",
+        skillsDir: ".augment/skills",
+        globalSkillsDir: ".augment/skills"
+      },
       "claude-code": {
         displayName: "Claude Code",
-        skillsDir: ".claude/skills"
+        skillsDir: ".claude/skills",
+        globalSkillsDir: ".claude/skills"
+      },
+      cline: {
+        displayName: "Cline",
+        skillsDir: ".agents/skills",
+        globalSkillsDir: ".agents/skills"
+      },
+      codebuddy: {
+        displayName: "CodeBuddy",
+        skillsDir: ".codebuddy/skills",
+        globalSkillsDir: ".codebuddy/skills"
       },
       codex: {
         displayName: "Codex",
-        skillsDir: ".codex/skills"
+        skillsDir: ".agents/skills",
+        globalSkillsDir: ".codex/skills"
+      },
+      "command-code": {
+        displayName: "Command Code",
+        skillsDir: ".commandcode/skills",
+        globalSkillsDir: ".commandcode/skills"
+      },
+      continue: {
+        displayName: "Continue",
+        skillsDir: ".continue/skills",
+        globalSkillsDir: ".continue/skills"
+      },
+      cortex: {
+        displayName: "Cortex Code",
+        skillsDir: ".cortex/skills",
+        globalSkillsDir: ".snowflake/cortex/skills"
+      },
+      crush: {
+        displayName: "Crush",
+        skillsDir: ".crush/skills",
+        globalSkillsDir: ".config/crush/skills"
       },
       cursor: {
         displayName: "Cursor",
-        skillsDir: ".cursor/skills"
+        skillsDir: ".agents/skills",
+        globalSkillsDir: ".cursor/skills"
+      },
+      droid: {
+        displayName: "Droid",
+        skillsDir: ".factory/skills",
+        globalSkillsDir: ".factory/skills"
       },
-      gemini: {
+      "gemini-cli": {
         displayName: "Gemini CLI",
-        skillsDir: ".gemini/skills"
+        skillsDir: ".agents/skills",
+        globalSkillsDir: ".gemini/skills"
+      },
+      "github-copilot": {
+        displayName: "GitHub Copilot",
+        skillsDir: ".agents/skills",
+        globalSkillsDir: ".copilot/skills"
+      },
+      goose: {
+        displayName: "Goose",
+        skillsDir: ".goose/skills",
+        globalSkillsDir: ".config/goose/skills"
       },
-      kiro: {
+      "iflow-cli": {
+        displayName: "iFlow CLI",
+        skillsDir: ".iflow/skills",
+        globalSkillsDir: ".iflow/skills"
+      },
+      junie: {
+        displayName: "Junie",
+        skillsDir: ".junie/skills",
+        globalSkillsDir: ".junie/skills"
+      },
+      kilo: {
+        displayName: "Kilo Code",
+        skillsDir: ".kilocode/skills",
+        globalSkillsDir: ".kilocode/skills"
+      },
+      "kimi-cli": {
+        displayName: "Kimi Code CLI",
+        skillsDir: ".agents/skills",
+        globalSkillsDir: ".config/agents/skills"
+      },
+      "kiro-cli": {
         displayName: "Kiro CLI",
-        skillsDir: ".kiro/skills"
+        skillsDir: ".kiro/skills",
+        globalSkillsDir: ".kiro/skills"
+      },
+      kode: {
+        displayName: "Kode",
+        skillsDir: ".kode/skills",
+        globalSkillsDir: ".kode/skills"
+      },
+      mcpjam: {
+        displayName: "MCPJam",
+        skillsDir: ".mcpjam/skills",
+        globalSkillsDir: ".mcpjam/skills"
+      },
+      "mistral-vibe": {
+        displayName: "Mistral Vibe",
+        skillsDir: ".vibe/skills",
+        globalSkillsDir: ".vibe/skills"
+      },
+      mux: {
+        displayName: "Mux",
+        skillsDir: ".mux/skills",
+        globalSkillsDir: ".mux/skills"
+      },
+      neovate: {
+        displayName: "Neovate",
+        skillsDir: ".neovate/skills",
+        globalSkillsDir: ".neovate/skills"
+      },
+      openclaw: {
+        displayName: "OpenClaw",
+        skillsDir: "skills",
+        globalSkillsDir: ".openclaw/skills"
       },
       opencode: {
         displayName: "OpenCode",
-        skillsDir: ".opencode/skills"
+        skillsDir: ".agents/skills",
+        globalSkillsDir: ".config/opencode/skills"
+      },
+      openhands: {
+        displayName: "OpenHands",
+        skillsDir: ".openhands/skills",
+        globalSkillsDir: ".openhands/skills"
+      },
+      pi: {
+        displayName: "Pi",
+        skillsDir: ".pi/skills",
+        globalSkillsDir: ".pi/agent/skills"
+      },
+      pochi: {
+        displayName: "Pochi",
+        skillsDir: ".pochi/skills",
+        globalSkillsDir: ".pochi/skills"
+      },
+      qoder: {
+        displayName: "Qoder",
+        skillsDir: ".qoder/skills",
+        globalSkillsDir: ".qoder/skills"
+      },
+      "qwen-code": {
+        displayName: "Qwen Code",
+        skillsDir: ".qwen/skills",
+        globalSkillsDir: ".qwen/skills"
+      },
+      replit: {
+        displayName: "Replit",
+        skillsDir: ".agents/skills",
+        globalSkillsDir: ".config/agents/skills"
+      },
+      roo: {
+        displayName: "Roo Code",
+        skillsDir: ".roo/skills",
+        globalSkillsDir: ".roo/skills"
+      },
+      trae: {
+        displayName: "Trae",
+        skillsDir: ".trae/skills",
+        globalSkillsDir: ".trae/skills"
+      },
+      "trae-cn": {
+        displayName: "Trae CN",
+        skillsDir: ".trae/skills",
+        globalSkillsDir: ".trae-cn/skills"
+      },
+      universal: {
+        displayName: "Universal",
+        skillsDir: ".agents/skills",
+        globalSkillsDir: ".config/agents/skills"
+      },
+      windsurf: {
+        displayName: "Windsurf",
+        skillsDir: ".windsurf/skills",
+        globalSkillsDir: ".codeium/windsurf/skills"
+      },
+      zencoder: {
+        displayName: "Zencoder",
+        skillsDir: ".zencoder/skills",
+        globalSkillsDir: ".zencoder/skills"
       }
     };
-    DEFAULT_AGENT_CONFIGS = {
-      "claude-code": { skillsDir: AGENT_INFO["claude-code"].skillsDir },
-      codex: { skillsDir: AGENT_INFO.codex.skillsDir },
-      cursor: { skillsDir: AGENT_INFO.cursor.skillsDir },
-      gemini: { skillsDir: AGENT_INFO.gemini.skillsDir },
-      kiro: { skillsDir: AGENT_INFO.kiro.skillsDir },
-      opencode: { skillsDir: AGENT_INFO.opencode.skillsDir }
-    };
-    ALL_AGENTS = [
-      "claude-code",
-      "codex",
-      "cursor",
-      "gemini",
-      "kiro",
-      "opencode"
-    ];
+    DEFAULT_AGENT_CONFIGS = Object.fromEntries(
+      Object.entries(AGENT_INFO).map(([key, info]) => [
+        key,
+        { skillsDir: info.skillsDir }
+      ])
+    );
+    ALL_AGENTS = Object.keys(
+      AGENT_INFO
+    ).sort();
   }
 });
 function getGitHubHeaders() {
@@ -1331,13 +1606,13 @@ async function extractGitHubPackage(spec, buffer, skillsDir) {
     const sourcePath = join(tempDir, extractedDir);
     const copySource = spec.path ? join(sourcePath, spec.path) : sourcePath;
     if (spec.path) {
-      const pathExists = await lstat(copySource).catch(() => null);
-      if (!pathExists) {
+      const pathExists2 = await lstat(copySource).catch(() => null);
+      if (!pathExists2) {
         const rootEntries = await readdir(sourcePath);
         const dirs = [];
         for (const entry of rootEntries) {
-          const stat8 = await lstat(join(sourcePath, entry)).catch(() => null);
-          if (stat8?.isDirectory() && !entry.startsWith(".")) {
+          const stat9 = await lstat(join(sourcePath, entry)).catch(() => null);
+          if (stat9?.isDirectory() && !entry.startsWith(".")) {
             dirs.push(entry);
           }
         }
@@ -1485,6 +1760,9 @@ async function writeLockfile(lockfile) {
   if (lockfile.localPackages && Object.keys(lockfile.localPackages).length > 0) {
     normalized.localPackages = lockfile.localPackages;
   }
+  if (lockfile.wellKnownPackages && Object.keys(lockfile.wellKnownPackages).length > 0) {
+    normalized.wellKnownPackages = lockfile.wellKnownPackages;
+  }
   await writeFile(lockfilePath, `${JSON.stringify(normalized, null, 2)}
 `);
 }
@@ -1589,6 +1867,29 @@ async function addLocalToLockfile(specifier, entry) {
   lockfile.localPackages[specifier] = entry;
   await writeLockfile(lockfile);
 }
+async function addWellKnownToLockfile(specifier, entry) {
+  let lockfile = await readLockfile();
+  if (!lockfile) {
+    lockfile = await createEmptyLockfile();
+  }
+  if (!lockfile.wellKnownPackages) {
+    lockfile.wellKnownPackages = {};
+  }
+  lockfile.wellKnownPackages[specifier] = entry;
+  await writeLockfile(lockfile);
+}
+async function listLockfileWellKnownPackages() {
+  const lockfile = await readLockfile();
+  if (!lockfile?.wellKnownPackages) {
+    return [];
+  }
+  return Object.entries(lockfile.wellKnownPackages).map(
+    ([specifier, entry]) => ({
+      specifier,
+      entry
+    })
+  );
+}
 var init_lockfile2 = __esm({
   "src/lockfile.ts"() {
     init_config();
@@ -1596,6 +1897,9 @@ var init_lockfile2 = __esm({
   }
 });
 function getManifestPath() {
+  if (isGlobalMode()) {
+    return join(homedir(), ".pspm", "pspm.json");
+  }
   return join(process.cwd(), "pspm.json");
 }
 async function readManifest() {
@@ -1674,8 +1978,23 @@ async function addLocalDependency(specifier, version3 = "*") {
   manifest.localDependencies[specifier] = version3;
   await writeManifest(manifest);
 }
+async function addWellKnownDependency(baseUrl, skillNames) {
+  const manifest = await ensureManifest();
+  if (!manifest.wellKnownDependencies) {
+    manifest.wellKnownDependencies = {};
+  }
+  const existing = manifest.wellKnownDependencies[baseUrl];
+  if (Array.isArray(existing)) {
+    const merged = [.../* @__PURE__ */ new Set([...existing, ...skillNames])];
+    manifest.wellKnownDependencies[baseUrl] = merged;
+  } else {
+    manifest.wellKnownDependencies[baseUrl] = skillNames;
+  }
+  await writeManifest(manifest);
+}
 var init_manifest2 = __esm({
   "src/manifest.ts"() {
+    init_config();
   }
 });
 async function createAgentSymlinks(skills, options) {
@@ -1684,7 +2003,7 @@ async function createAgentSymlinks(skills, options) {
     return;
   }
   for (const agentName of agents) {
-    const config2 = resolveAgentConfig(agentName, agentConfigs);
+    const config2 = resolveAgentConfig(agentName, agentConfigs, options.global);
     if (!config2) {
       console.warn(`Warning: Unknown agent "${agentName}", skipping symlinks`);
       continue;
@@ -1756,6 +2075,9 @@ function getGitHubSkillPath(owner, repo, path) {
 function getLocalSkillPath(skillName) {
   return `.pspm/skills/_local/${skillName}`;
 }
+function getWellKnownSkillPath(hostname, skillName) {
+  return `.pspm/skills/_wellknown/${hostname}/${skillName}`;
+}
 async function getLinkedAgents(skillName, agents, projectRoot, agentConfigs) {
   const linkedAgents = [];
   for (const agentName of agents) {
@@ -1777,6 +2099,182 @@ var init_symlinks = __esm({
     init_agents();
   }
 });
+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;
+  }
+}
+function getWellKnownHostname(url) {
+  try {
+    const parsed = new URL(url);
+    return parsed.hostname.replace(/^www\./, "");
+  } catch {
+    return url;
+  }
+}
+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;
+}
+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);
+}
+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;
+}
+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}`);
+      }
+      const content = await response.text();
+      return { filePath, content };
+    })
+  );
+  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
+  };
+}
+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 };
+}
+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: dirname7 } = await import('path');
+    await mkdir(dirname7(fullPath), { recursive: true });
+    await writeFile(fullPath, content, "utf-8");
+  }
+  return `.pspm/skills/_wellknown/${hostname}/${skill.name}`;
+}
+function calculateWellKnownIntegrity(skill) {
+  const sortedEntries = [...skill.files.entries()].sort(
+    ([a], [b]) => a.localeCompare(b)
+  );
+  const combined = sortedEntries.map(([path, content]) => `${path}:${content}`).join("\n");
+  return calculateIntegrity(Buffer.from(combined, "utf-8"));
+}
+function getWellKnownDisplayName(hostname, skillName) {
+  return `${hostname}/${skillName} (well-known)`;
+}
+var WELL_KNOWN_PATH, INDEX_FILE, SKILL_NAME_PATTERN, EXCLUDED_HOSTS;
+var init_wellknown = __esm({
+  "src/wellknown.ts"() {
+    init_lib();
+    WELL_KNOWN_PATH = ".well-known/skills";
+    INDEX_FILE = "index.json";
+    SKILL_NAME_PATTERN = /^[a-z0-9]([a-z0-9-]{0,62}[a-z0-9])?$/;
+    EXCLUDED_HOSTS = [
+      "github.com",
+      "gitlab.com",
+      "raw.githubusercontent.com"
+    ];
+  }
+});
 
 // src/commands/add.ts
 var add_exports = {};
@@ -1799,6 +2297,10 @@ function normalizeToFileSpecifier(path) {
   return `file:${path}`;
 }
 async function add(specifiers, options) {
+  if (options.global) {
+    setGlobalMode(true);
+    console.log("Installing globally to ~/.pspm/\n");
+  }
   console.log("Resolving packages...\n");
   const resolvedPackages = [];
   const validationErrors = [];
@@ -1807,9 +2309,12 @@ async function add(specifiers, options) {
       if (isLocalSpecifier2(specifier)) {
         const resolved = await validateLocalPackage(specifier);
         resolvedPackages.push(resolved);
-      } else if (isGitHubSpecifier(specifier)) {
+      } else if (isGitHubSpecifier(specifier) || isGitHubUrl(specifier) || isGitHubShorthand(specifier)) {
         const resolved = await validateGitHubPackage(specifier);
         resolvedPackages.push(resolved);
+      } else if (isWellKnownSpecifier(specifier)) {
+        const resolved = await validateWellKnownPackage(specifier);
+        resolvedPackages.push(resolved);
       } else {
         const resolved = await validateRegistryPackage(specifier);
         resolvedPackages.push(resolved);
@@ -1842,6 +2347,9 @@ async function add(specifiers, options) {
   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 = {};
@@ -1944,6 +2452,24 @@ async function add(specifiers, options) {
         error: message
       });
       console.error(`Failed to install ${resolved.specifier}: ${message}
+`);
+    }
+  }
+  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}
 `);
     }
   }
@@ -1957,6 +2483,9 @@ Summary: ${succeeded} added, ${failed} failed`);
     }
   }
 }
+function getSymlinkRoot() {
+  return isGlobalMode() ? homedir() : process.cwd();
+}
 async function installFromNode(node, options) {
   const match = node.name.match(/^@user\/([^/]+)\/([^/]+)$/);
   if (!match) {
@@ -1986,16 +2515,16 @@ async function installFromNode(node, options) {
   const skillsDir = getSkillsDir();
   const destDir = join(skillsDir, username, name);
   await mkdir(destDir, { recursive: true });
-  const { writeFile: writeFile10 } = await import('fs/promises');
+  const { writeFile: writeFile11 } = await import('fs/promises');
   const tempFile = join(destDir, ".temp.tgz");
-  await writeFile10(tempFile, tarballBuffer);
+  await writeFile11(tempFile, tarballBuffer);
   const { exec: exec2 } = await import('child_process');
   const { promisify: promisify2 } = await import('util');
   const execAsync = promisify2(exec2);
   try {
     await rm(destDir, { recursive: true, force: true });
     await mkdir(destDir, { recursive: true });
-    await writeFile10(tempFile, tarballBuffer);
+    await writeFile11(tempFile, tarballBuffer);
     await execAsync(
       `tar -xzf "${tempFile}" -C "${destDir}" --strip-components=1`
     );
@@ -2029,8 +2558,9 @@ async function installFromNode(node, options) {
     };
     await createAgentSymlinks([skillInfo], {
       agents,
-      projectRoot: process.cwd(),
-      agentConfigs: skillManifest?.agents
+      projectRoot: getSymlinkRoot(),
+      agentConfigs: skillManifest?.agents,
+      global: isGlobalMode()
     });
   }
   console.log(`Installed ${node.name}@${node.version}`);
@@ -2104,11 +2634,26 @@ async function validateRegistryPackage(specifier) {
     }
   };
 }
+function parseAnyGitHubFormat(specifier) {
+  if (isGitHubSpecifier(specifier)) {
+    return parseGitHubSpecifier(specifier);
+  }
+  if (isGitHubUrl(specifier)) {
+    return parseGitHubUrl(specifier);
+  }
+  if (isGitHubShorthand(specifier)) {
+    return parseGitHubShorthand(specifier);
+  }
+  return null;
+}
 async function validateGitHubPackage(specifier) {
-  const parsed = parseGitHubSpecifier(specifier);
+  const parsed = parseAnyGitHubFormat(specifier);
   if (!parsed) {
     throw new Error(
-      `Invalid GitHub specifier "${specifier}". Use format: github:{owner}/{repo}[/{path}][@{ref}]`
+      `Invalid GitHub specifier "${specifier}". Supported formats:
+  github:owner/repo[/path][@ref]
+  https://github.com/owner/repo[/tree/branch/path]
+  owner/repo[/path]`
     );
   }
   const ref = parsed.ref || "HEAD";
@@ -2159,8 +2704,9 @@ async function installGitHubPackage(resolved, options) {
     };
     await createAgentSymlinks([skillInfo], {
       agents,
-      projectRoot: process.cwd(),
-      agentConfigs: manifest?.agents
+      projectRoot: getSymlinkRoot(),
+      agentConfigs: manifest?.agents,
+      global: isGlobalMode()
     });
   }
   console.log(
@@ -2246,13 +2792,72 @@ async function installLocalPackage(resolved, options) {
     };
     await createAgentSymlinks([skillInfo], {
       agents,
-      projectRoot: process.cwd(),
-      agentConfigs: manifest?.agents
+      projectRoot: getSymlinkRoot(),
+      agentConfigs: manifest?.agents,
+      global: isGlobalMode()
     });
   }
   console.log(`Installed ${specifier} (local)`);
   console.log(`Location: ${symlinkPath} -> ${resolvedPath}`);
 }
+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}
+  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
+  };
+}
+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);
+    const lockfileKey = `${specifier}#${skill.name}`;
+    const entry = {
+      version: "well-known",
+      resolved: skill.sourceUrl,
+      integrity,
+      hostname,
+      name: skill.name,
+      files: [...skill.files.keys()]
+    };
+    await addWellKnownToLockfile(lockfileKey, entry);
+    await addWellKnownDependency(specifier, [skill.name]);
+    const agents = options.resolvedAgents;
+    if (agents[0] !== "none") {
+      const manifest = await readManifest();
+      const skillInfo = {
+        name: skill.name,
+        sourcePath: getWellKnownSkillPath(hostname, skill.name)
+      };
+      await createAgentSymlinks([skillInfo], {
+        agents,
+        projectRoot: process.cwd(),
+        agentConfigs: manifest?.agents
+      });
+    }
+    console.log(`Installed ${getWellKnownDisplayName(hostname, skill.name)}`);
+    console.log(`Location: ${destPath}`);
+  }
+}
 var init_add = __esm({
   "src/commands/add.ts"() {
     init_agents();
@@ -2264,6 +2869,7 @@ var init_add = __esm({
     init_lockfile2();
     init_manifest2();
     init_symlinks();
+    init_wellknown();
   }
 });
 
@@ -2332,18 +2938,18 @@ async function access(specifier, options) {
       packageUsername = parsed.username;
     } else {
       const { readFile: readFile10 } = await import('fs/promises');
-      const { join: join16 } = await import('path');
+      const { join: join18 } = await import('path');
       let manifest = null;
       try {
         const content = await readFile10(
-          join16(process.cwd(), "pspm.json"),
+          join18(process.cwd(), "pspm.json"),
           "utf-8"
         );
         manifest = JSON.parse(content);
       } catch {
         try {
           const content = await readFile10(
-            join16(process.cwd(), "package.json"),
+            join18(process.cwd(), "package.json"),
             "utf-8"
           );
           manifest = JSON.parse(content);
@@ -2402,6 +3008,209 @@ async function access(specifier, options) {
 
 // src/commands/index.ts
 init_add();
+
+// src/commands/audit.ts
+init_config();
+init_lib();
+init_lockfile2();
+async function audit(options) {
+  try {
+    const lockfile = await readLockfile();
+    if (!lockfile) {
+      if (options.json) {
+        console.log(
+          JSON.stringify({
+            ok: false,
+            issues: [
+              {
+                name: "-",
+                source: "-",
+                severity: "error",
+                type: "no-lockfile",
+                message: "No lockfile found. Run 'pspm install' first."
+              }
+            ]
+          })
+        );
+      } else {
+        console.error("No lockfile found. Run 'pspm install' to create one.");
+      }
+      process.exit(1);
+    }
+    const issues = [];
+    const skillsDir = getSkillsDir();
+    const projectRoot = process.cwd();
+    if (!options.json) {
+      console.log("Auditing installed skills...\n");
+    }
+    const registrySkills = await listLockfileSkills();
+    for (const { name: fullName, entry } of registrySkills) {
+      const match = fullName.match(/^@user\/([^/]+)\/([^/]+)$/);
+      if (!match) continue;
+      const [, username, skillName] = match;
+      const destDir = join(projectRoot, skillsDir, username, skillName);
+      const exists = await pathExists(destDir);
+      if (!exists) {
+        issues.push({
+          name: fullName,
+          source: "registry",
+          severity: "error",
+          type: "missing",
+          message: `Not installed on disk. Run 'pspm install' to restore.`
+        });
+        continue;
+      }
+      if (entry.deprecated) {
+        issues.push({
+          name: fullName,
+          source: "registry",
+          severity: "warning",
+          type: "deprecated",
+          message: `Deprecated: ${entry.deprecated}`
+        });
+      }
+      const skillMdExists = await pathExists(join(destDir, "SKILL.md"));
+      if (!skillMdExists) {
+        issues.push({
+          name: fullName,
+          source: "registry",
+          severity: "warning",
+          type: "integrity",
+          message: "Missing SKILL.md in installed directory. Package may be corrupted."
+        });
+      }
+    }
+    const githubSkills = await listLockfileGitHubPackages();
+    for (const { specifier } of githubSkills) {
+      const parsed = parseGitHubSpecifier(specifier);
+      if (!parsed) continue;
+      const destDir = parsed.path ? join(
+        projectRoot,
+        skillsDir,
+        "_github",
+        parsed.owner,
+        parsed.repo,
+        parsed.path
+      ) : join(projectRoot, skillsDir, "_github", parsed.owner, parsed.repo);
+      const exists = await pathExists(destDir);
+      if (!exists) {
+        issues.push({
+          name: specifier,
+          source: "github",
+          severity: "error",
+          type: "missing",
+          message: `Not installed on disk. Run 'pspm install' to restore.`
+        });
+        continue;
+      }
+      const skillMdExists = await pathExists(join(destDir, "SKILL.md"));
+      if (!skillMdExists) {
+        issues.push({
+          name: specifier,
+          source: "github",
+          severity: "warning",
+          type: "integrity",
+          message: "Missing SKILL.md in installed directory. Package may be corrupted."
+        });
+      }
+    }
+    const wellKnownSkills = await listLockfileWellKnownPackages();
+    for (const { specifier, entry } of wellKnownSkills) {
+      const wkEntry = entry;
+      const destDir = join(
+        projectRoot,
+        skillsDir,
+        "_wellknown",
+        wkEntry.hostname,
+        wkEntry.name
+      );
+      const exists = await pathExists(destDir);
+      if (!exists) {
+        issues.push({
+          name: specifier,
+          source: "well-known",
+          severity: "error",
+          type: "missing",
+          message: `Not installed on disk. Run 'pspm install' to restore.`
+        });
+        continue;
+      }
+      const skillMdExists = await pathExists(join(destDir, "SKILL.md"));
+      if (!skillMdExists) {
+        issues.push({
+          name: specifier,
+          source: "well-known",
+          severity: "warning",
+          type: "integrity",
+          message: "Missing SKILL.md in installed directory. Package may be corrupted."
+        });
+      }
+    }
+    const errorCount = issues.filter((i) => i.severity === "error").length;
+    const warningCount = issues.filter((i) => i.severity === "warning").length;
+    if (options.json) {
+      console.log(
+        JSON.stringify(
+          {
+            ok: errorCount === 0,
+            totalPackages: registrySkills.length + githubSkills.length + wellKnownSkills.length,
+            issues
+          },
+          null,
+          2
+        )
+      );
+      if (errorCount > 0) process.exit(1);
+      return;
+    }
+    if (issues.length === 0) {
+      const totalPackages2 = registrySkills.length + githubSkills.length + wellKnownSkills.length;
+      console.log(`Audited ${totalPackages2} package(s). No issues found.`);
+      return;
+    }
+    const errors = issues.filter((i) => i.severity === "error");
+    const warnings = issues.filter((i) => i.severity === "warning");
+    if (errors.length > 0) {
+      console.log("Errors:");
+      for (const issue of errors) {
+        console.log(
+          `  [${issue.type.toUpperCase()}] ${issue.name} (${issue.source})`
+        );
+        console.log(`    ${issue.message}`);
+      }
+      console.log();
+    }
+    if (warnings.length > 0) {
+      console.log("Warnings:");
+      for (const issue of warnings) {
+        console.log(
+          `  [${issue.type.toUpperCase()}] ${issue.name} (${issue.source})`
+        );
+        console.log(`    ${issue.message}`);
+      }
+      console.log();
+    }
+    const totalPackages = registrySkills.length + githubSkills.length + wellKnownSkills.length;
+    console.log(
+      `Audited ${totalPackages} package(s): ${errorCount} error(s), ${warningCount} warning(s).`
+    );
+    if (errorCount > 0) {
+      process.exit(1);
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    console.error(`Error: ${message}`);
+    process.exit(1);
+  }
+}
+async function pathExists(path) {
+  try {
+    await stat(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
 async function configInit(options) {
   try {
     const configPath = join(process.cwd(), ".pspmrc");
@@ -2799,12 +3608,17 @@ async function writeToCache(cacheDir, integrity, data) {
   }
 }
 async function install(specifiers, options) {
+  if (options.global) {
+    const { setGlobalMode: setGlobalMode2 } = await Promise.resolve().then(() => (init_config(), config_exports));
+    setGlobalMode2(true);
+  }
   if (specifiers.length > 0) {
     const { add: add2 } = await Promise.resolve().then(() => (init_add(), add_exports));
     await add2(specifiers, {
       save: true,
       agent: options.agent,
-      yes: options.yes
+      yes: options.yes,
+      global: options.global
     });
     return;
   }
@@ -3152,12 +3966,16 @@ Installing ${githubCount} GitHub skill(s)...
       }
     }
     if (installedSkills.length > 0 && agents[0] !== "none") {
-      console.log(`
-Creating symlinks for agent(s): ${agents.join(", ")}...`);
+      const globalMode = isGlobalMode();
+      console.log(
+        `
+Creating symlinks for agent(s): ${agents.join(", ")}${globalMode ? " (global)" : ""}...`
+      );
       await createAgentSymlinks(installedSkills, {
         agents,
-        projectRoot: process.cwd(),
-        agentConfigs
+        projectRoot: globalMode ? homedir() : process.cwd(),
+        agentConfigs,
+        global: globalMode
       });
       console.log("  Symlinks created.");
     }
@@ -3183,6 +4001,10 @@ init_manifest2();
 init_symlinks();
 async function link(options) {
   try {
+    if (options.global) {
+      const { setGlobalMode: setGlobalMode2 } = await Promise.resolve().then(() => (init_config(), config_exports));
+      setGlobalMode2(true);
+    }
     const manifest = await readManifest();
     const agentConfigs = manifest?.agents;
     let agents;
@@ -3235,10 +4057,12 @@ async function link(options) {
     console.log(
       `Creating symlinks for ${skills.length} skill(s) to agent(s): ${agents.join(", ")}...`
     );
+    const globalMode = options.global ?? false;
     await createAgentSymlinks(skills, {
       agents,
-      projectRoot: process.cwd(),
-      agentConfigs
+      projectRoot: globalMode ? (await import('os')).homedir() : process.cwd(),
+      agentConfigs,
+      global: globalMode
     });
     console.log("Symlinks created successfully.");
     console.log("\nLinked skills:");
@@ -3260,8 +4084,13 @@ init_manifest2();
 init_symlinks();
 async function list(options) {
   try {
+    if (options.global) {
+      const { setGlobalMode: setGlobalMode2 } = await Promise.resolve().then(() => (init_config(), config_exports));
+      setGlobalMode2(true);
+    }
     const registrySkills = await listLockfileSkills();
     const githubSkills = await listLockfileGitHubPackages();
+    const wellKnownSkills = await listLockfileWellKnownPackages();
     const manifest = await readManifest();
     const agentConfigs = manifest?.agents;
     const availableAgents = getAvailableAgents(agentConfigs);
@@ -3330,6 +4159,34 @@ async function list(options) {
         gitCommit: ghEntry.gitCommit
       });
     }
+    for (const { specifier, entry } of wellKnownSkills) {
+      const wkEntry = entry;
+      const skillName = wkEntry.name;
+      const sourcePath = getWellKnownSkillPath(wkEntry.hostname, skillName);
+      const absolutePath = join(projectRoot, sourcePath);
+      let status = "installed";
+      try {
+        await access$1(absolutePath);
+      } catch {
+        status = "missing";
+      }
+      const linkedAgents = await getLinkedAgents(
+        skillName,
+        availableAgents,
+        projectRoot,
+        agentConfigs
+      );
+      skills.push({
+        name: skillName,
+        fullName: specifier,
+        version: "well-known",
+        source: "well-known",
+        sourcePath,
+        status,
+        linkedAgents,
+        hostname: wkEntry.hostname
+      });
+    }
     if (skills.length === 0) {
       console.log("No skills installed.");
       return;
@@ -3342,6 +4199,8 @@ async function list(options) {
     for (const skill of skills) {
       if (skill.source === "registry") {
         console.log(`  ${skill.fullName}@${skill.version} (registry)`);
+      } else if (skill.source === "well-known") {
+        console.log(`  ${skill.name} (well-known: ${skill.hostname})`);
       } else {
         const refInfo = skill.gitRef ? `${skill.gitRef}@${skill.gitCommit?.slice(0, 7)}` : skill.version;
         console.log(`  ${skill.fullName} (${refInfo})`);
@@ -3360,9 +4219,13 @@ async function list(options) {
     }
     const registryCount = skills.filter((s) => s.source === "registry").length;
     const githubCount = skills.filter((s) => s.source === "github").length;
+    const wellKnownCount = skills.filter(
+      (s) => s.source === "well-known"
+    ).length;
     const parts = [];
     if (registryCount > 0) parts.push(`${registryCount} registry`);
     if (githubCount > 0) parts.push(`${githubCount} github`);
+    if (wellKnownCount > 0) parts.push(`${wellKnownCount} well-known`);
     console.log(`
 Total: ${skills.length} skill(s) (${parts.join(", ")})`);
   } catch (error) {
@@ -4334,6 +5197,88 @@ async function removeByShortName(shortName, agents, agentConfigs) {
   process.exit(1);
 }
 
+// src/commands/search.ts
+init_api_client();
+init_config();
+init_generated();
+async function search(query, options) {
+  try {
+    const config2 = await resolveConfig();
+    const apiKey = getTokenForRegistry(config2, config2.registryUrl);
+    configure2({ registryUrl: config2.registryUrl, apiKey });
+    const limit = options.limit ?? 20;
+    const sort = options.sort ?? "downloads";
+    if (!options.json) {
+      if (query) {
+        console.log(`Searching for "${query}"...
+`);
+      } else {
+        console.log("Browsing skills...\n");
+      }
+    }
+    const response = await explorePublicSkills({
+      search: query,
+      sort,
+      limit,
+      page: 1
+    });
+    if (response.status !== 200) {
+      console.error("Error: Failed to search skills");
+      process.exit(1);
+    }
+    const { skills, total } = response.data;
+    if (skills.length === 0) {
+      if (query) {
+        console.log(`No skills found matching "${query}".`);
+      } else {
+        console.log("No skills published yet.");
+      }
+      return;
+    }
+    if (options.json) {
+      console.log(JSON.stringify(skills, null, 2));
+      return;
+    }
+    for (const skill of skills) {
+      const name = `@user/${skill.username}/${skill.name}`;
+      const desc = skill.description ? ` - ${skill.description.slice(0, 80)}${skill.description.length > 80 ? "..." : ""}` : "";
+      const downloads = skill.totalDownloads > 0 ? ` (${formatDownloads(skill.totalDownloads)} downloads)` : "";
+      console.log(`  ${name}${downloads}`);
+      if (desc) {
+        console.log(`    ${desc.trim()}`);
+      }
+    }
+    const showing = Math.min(skills.length, limit);
+    if (total > showing) {
+      console.log(`
+Showing ${showing} of ${total} results.`);
+    } else {
+      console.log(`
+${total} skill(s) found.`);
+    }
+    if (skills.length > 0) {
+      const first = skills[0];
+      console.log(
+        `
+Install with: pspm add @user/${first.username}/${first.name}`
+      );
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    console.error(`Error: ${message}`);
+    process.exit(1);
+  }
+}
+function formatDownloads(count) {
+  if (count >= 1e6) {
+    return `${(count / 1e6).toFixed(1)}M`;
+  }
+  if (count >= 1e3) {
+    return `${(count / 1e3).toFixed(1)}k`;
+  }
+  return String(count);
+}
+
 // src/commands/unpublish.ts
 init_api_client();
 init_config();
@@ -4745,45 +5690,64 @@ program.command("migrate").description(
   await migrate({ dryRun: options.dryRun });
 });
 program.command("add <specifiers...>").description(
-  "Add one or more skills (e.g., @user/bsheng/vite_slides@^2.0.0 or github:owner/repo/path@ref)"
+  "Add skills from registry, GitHub, local paths, or well-known URLs"
 ).option("--save", "Save to lockfile (default)").option(
   "--agent <agents>",
   'Comma-separated agents for symlinks (default: all agents, use "none" to skip)'
-).option("-y, --yes", "Skip agent selection prompt and use defaults").action(async (specifiers, options) => {
+).option("-g, --global", "Install to user home directory instead of project").option("-y, --yes", "Skip agent selection prompt and use defaults").action(async (specifiers, options) => {
   await add(specifiers, {
     save: options.save ?? true,
     agent: options.agent,
-    yes: options.yes
+    yes: options.yes,
+    global: options.global
   });
 });
 program.command("remove <name>").alias("rm").description("Remove an installed skill").action(async (name) => {
   await remove(name);
 });
-program.command("list").alias("ls").description("List installed skills").option("--json", "Output as JSON").action(async (options) => {
-  await list({ json: options.json });
+program.command("list").alias("ls").description("List installed skills").option("--json", "Output as JSON").option("-g, --global", "List globally installed skills").action(async (options) => {
+  await list({ json: options.json, global: options.global });
 });
 program.command("install [specifiers...]").alias("i").description(
   "Install skills from lockfile, or add and install specific packages"
 ).option("--frozen-lockfile", "Fail if lockfile is missing or outdated").option("--dir <path>", "Install skills to a specific directory").option(
   "--agent <agents>",
   'Comma-separated agents for symlinks (default: all agents, use "none" to skip)'
-).option("-y, --yes", "Skip agent selection prompt and use defaults").action(async (specifiers, options) => {
+).option("-g, --global", "Install to user home directory instead of project").option("-y, --yes", "Skip agent selection prompt and use defaults").action(async (specifiers, options) => {
   await install(specifiers, {
     frozenLockfile: options.frozenLockfile,
     dir: options.dir,
     agent: options.agent,
-    yes: options.yes
+    yes: options.yes,
+    global: options.global
   });
 });
 program.command("link").description("Recreate agent symlinks without reinstalling").option(
   "--agent <agents>",
   'Comma-separated agents for symlinks (default: all agents, use "none" to skip)'
-).option("-y, --yes", "Skip agent selection prompt and use defaults").action(async (options) => {
-  await link({ agent: options.agent, yes: options.yes });
+).option("-g, --global", "Recreate global agent symlinks").option("-y, --yes", "Skip agent selection prompt and use defaults").action(async (options) => {
+  await link({
+    agent: options.agent,
+    yes: options.yes,
+    global: options.global
+  });
 });
 program.command("update").description("Update all skills to latest compatible versions").option("--dry-run", "Show what would be updated without making changes").action(async (options) => {
   await update({ dryRun: options.dryRun });
 });
+program.command("search [query]").alias("find").description("Search and discover skills from the registry").option(
+  "-s, --sort <sort>",
+  "Sort by: downloads, recent, name (default: downloads)"
+).option("-l, --limit <n>", "Maximum results (default: 20)", Number.parseInt).option("--json", "Output as JSON").action(async (query, options) => {
+  await search(query, {
+    sort: options.sort,
+    limit: options.limit,
+    json: options.json
+  });
+});
+program.command("audit").description("Verify integrity of installed skills and check for issues").option("--json", "Output as JSON").action(async (options) => {
+  await audit({ json: options.json });
+});
 program.command("outdated [packages...]").description("Check for outdated skills").option("--json", "Output as JSON").option("--all", "Include up-to-date packages").action(async (packages, options) => {
   await outdated(packages, { json: options.json, all: options.all });
 });