skillhub 0.1.0

package/README.md

@@ -0,0 +1,121 @@
+# @skillhub/cli
+
+Command-line tool for installing and managing AI Agent skills from [SkillHub](https://skills.palebluedot.live).
+
+## Installation
+
+```bash
+# Install globally
+npm install -g @skillhub/cli
+
+# Or use directly with npx
+npx @skillhub/cli
+```
+
+## Usage
+
+### Search for skills
+
+```bash
+skillhub search pdf
+skillhub search "code review" --platform claude --limit 20
+```
+
+### Install a skill
+
+```bash
+skillhub install anthropics/skills/pdf
+skillhub install obra/superpowers/brainstorming --platform codex
+skillhub install anthropics/skills/docx --project  # Install in current project
+```
+
+### List installed skills
+
+```bash
+skillhub list
+skillhub list --platform claude
+```
+
+### Update skills
+
+```bash
+skillhub update anthropics/skills/pdf     # Update specific skill
+skillhub update --all                      # Update all installed skills
+```
+
+### Uninstall a skill
+
+```bash
+skillhub uninstall pdf
+skillhub uninstall brainstorming --platform codex
+```
+
+### Configuration
+
+```bash
+skillhub config --list                      # Show all config
+skillhub config --get defaultPlatform       # Get specific value
+skillhub config --set defaultPlatform=claude  # Set value
+```
+
+## Platform Support
+
+SkillHub CLI supports multiple AI agent platforms:
+
+| Platform | Flag | Install Path |
+|----------|------|--------------|
+| Claude | `--platform claude` | `~/.claude/skills/` |
+| OpenAI Codex | `--platform codex` | `~/.codex/skills/` |
+| GitHub Copilot | `--platform copilot` | `~/.github/skills/` |
+| Cursor | `--platform cursor` | `~/.cursor/skills/` |
+| Windsurf | `--platform windsurf` | `~/.windsurf/skills/` |
+
+Default platform: `claude`
+
+## Options
+
+### Global Options
+
+- `--platform <name>` - Target platform (claude, codex, copilot, cursor, windsurf)
+- `--project` - Install in current project instead of user directory
+- `--force` - Overwrite existing installation
+- `--help` - Show help information
+- `--version` - Show version number
+
+### Environment Variables
+
+- `SKILLHUB_API_URL` - Override API endpoint (default: https://skills.palebluedot.live/api)
+- `GITHUB_TOKEN` - GitHub token for API rate limits (optional)
+
+## Configuration File
+
+Configuration is stored in `~/.skillhub/config.json`:
+
+```json
+{
+  "defaultPlatform": "claude",
+  "apiUrl": "https://skills.palebluedot.live/api",
+  "githubToken": "ghp_..."
+}
+```
+
+## Examples
+
+```bash
+# Search and install a skill
+skillhub search "document processing"
+skillhub install anthropics/skills/pdf
+
+# Install skill for Codex
+skillhub install obra/superpowers/brainstorming --platform codex
+
+# Update all installed skills
+skillhub update --all
+
+# Check what's installed
+skillhub list
+```
+
+## License
+
+MIT

package/dist/chunk-YXEKBJKF.js

@@ -0,0 +1,88 @@
+// src/utils/paths.ts
+import * as os from "os";
+import * as path from "path";
+import fs from "fs-extra";
+var PLATFORM_PATHS = {
+  claude: {
+    user: ".claude/skills",
+    project: ".claude/skills"
+  },
+  codex: {
+    user: ".codex/skills",
+    project: ".codex/skills"
+  },
+  copilot: {
+    user: ".github/skills",
+    project: ".github/skills"
+  },
+  cursor: {
+    user: ".cursor/skills",
+    project: ".cursor/skills"
+  },
+  windsurf: {
+    user: ".windsurf/skills",
+    project: ".windsurf/skills"
+  }
+};
+function getSkillsPath(platform, project = false) {
+  const home = os.homedir();
+  const cwd = process.cwd();
+  const paths = PLATFORM_PATHS[platform];
+  if (project) {
+    return path.join(cwd, paths.project);
+  }
+  return path.join(home, paths.user);
+}
+function getSkillPath(platform, skillName, project = false) {
+  const basePath = getSkillsPath(platform, project);
+  return path.join(basePath, skillName);
+}
+async function ensureSkillsDir(platform, project = false) {
+  const skillsPath = getSkillsPath(platform, project);
+  await fs.ensureDir(skillsPath);
+  return skillsPath;
+}
+async function isSkillInstalled(platform, skillName, project = false) {
+  const skillPath = getSkillPath(platform, skillName, project);
+  return fs.pathExists(skillPath);
+}
+async function detectPlatform() {
+  const cwd = process.cwd();
+  for (const platform of Object.keys(PLATFORM_PATHS)) {
+    const configPath = path.join(cwd, `.${platform}`);
+    if (await fs.pathExists(configPath)) {
+      return platform;
+    }
+  }
+  if (await fs.pathExists(path.join(cwd, ".github"))) {
+    return "copilot";
+  }
+  return null;
+}
+function getConfigPath() {
+  const home = os.homedir();
+  return path.join(home, ".skillhub", "config.json");
+}
+async function loadConfig() {
+  const configPath = getConfigPath();
+  if (await fs.pathExists(configPath)) {
+    return fs.readJson(configPath);
+  }
+  return {};
+}
+async function saveConfig(config) {
+  const configPath = getConfigPath();
+  await fs.ensureDir(path.dirname(configPath));
+  await fs.writeJson(configPath, config, { spaces: 2 });
+}
+
+export {
+  getSkillsPath,
+  getSkillPath,
+  ensureSkillsDir,
+  isSkillInstalled,
+  detectPlatform,
+  getConfigPath,
+  loadConfig,
+  saveConfig
+};

package/dist/index.js

@@ -0,0 +1,571 @@
+#!/usr/bin/env node
+import {
+  ensureSkillsDir,
+  getConfigPath,
+  getSkillPath,
+  getSkillsPath,
+  isSkillInstalled,
+  loadConfig,
+  saveConfig
+} from "./chunk-YXEKBJKF.js";
+
+// src/index.ts
+import { Command } from "commander";
+import chalk5 from "chalk";
+
+// src/commands/install.ts
+import fs from "fs-extra";
+import * as path from "path";
+import chalk from "chalk";
+import ora from "ora";
+import { parseSkillMd } from "skillhub-core";
+
+// src/utils/api.ts
+var API_BASE_URL = process.env.SKILLHUB_API_URL || "https://skills.palebluedot.live/api";
+async function searchSkills(query, options = {}) {
+  const params = new URLSearchParams({
+    q: query,
+    limit: String(options.limit || 10),
+    page: String(options.page || 1)
+  });
+  if (options.platform) {
+    params.set("platform", options.platform);
+  }
+  const response = await fetch(`${API_BASE_URL}/skills?${params}`);
+  if (!response.ok) {
+    throw new Error(`API error: ${response.status}`);
+  }
+  return response.json();
+}
+async function getSkill(id) {
+  const response = await fetch(`${API_BASE_URL}/skills/${encodeURIComponent(id)}`);
+  if (response.status === 404) {
+    return null;
+  }
+  if (!response.ok) {
+    throw new Error(`API error: ${response.status}`);
+  }
+  return response.json();
+}
+async function trackInstall(skillId, platform, method = "cli") {
+  try {
+    await fetch(`${API_BASE_URL}/skills/${encodeURIComponent(skillId)}/install`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ platform, method })
+    });
+  } catch {
+  }
+}
+
+// src/utils/github.ts
+import { Octokit } from "@octokit/rest";
+var octokit = null;
+function getOctokit() {
+  if (!octokit) {
+    octokit = new Octokit({
+      auth: process.env.GITHUB_TOKEN,
+      userAgent: "SkillHub-CLI/1.0"
+    });
+  }
+  return octokit;
+}
+async function fetchSkillContent(owner, repo, skillPath, branch = "main") {
+  const client = getOctokit();
+  const skillMdPath = skillPath ? `${skillPath}/SKILL.md` : "SKILL.md";
+  const skillMdResponse = await client.repos.getContent({
+    owner,
+    repo,
+    path: skillMdPath,
+    ref: branch
+  });
+  if (!("content" in skillMdResponse.data)) {
+    throw new Error("SKILL.md not found");
+  }
+  const skillMd = Buffer.from(skillMdResponse.data.content, "base64").toString("utf-8");
+  const scripts = [];
+  try {
+    const scriptsPath = skillPath ? `${skillPath}/scripts` : "scripts";
+    const scriptsResponse = await client.repos.getContent({
+      owner,
+      repo,
+      path: scriptsPath,
+      ref: branch
+    });
+    if (Array.isArray(scriptsResponse.data)) {
+      for (const file of scriptsResponse.data) {
+        if (file.type === "file") {
+          const fileResponse = await client.repos.getContent({
+            owner,
+            repo,
+            path: file.path,
+            ref: branch
+          });
+          if ("content" in fileResponse.data) {
+            scripts.push({
+              name: file.name,
+              content: Buffer.from(fileResponse.data.content, "base64").toString("utf-8")
+            });
+          }
+        }
+      }
+    }
+  } catch {
+  }
+  const references = [];
+  try {
+    const refsPath = skillPath ? `${skillPath}/references` : "references";
+    const refsResponse = await client.repos.getContent({
+      owner,
+      repo,
+      path: refsPath,
+      ref: branch
+    });
+    if (Array.isArray(refsResponse.data)) {
+      for (const file of refsResponse.data) {
+        if (file.type === "file" && file.size && file.size < 1e5) {
+          const fileResponse = await client.repos.getContent({
+            owner,
+            repo,
+            path: file.path,
+            ref: branch
+          });
+          if ("content" in fileResponse.data) {
+            references.push({
+              name: file.name,
+              content: Buffer.from(fileResponse.data.content, "base64").toString("utf-8")
+            });
+          }
+        }
+      }
+    }
+  } catch {
+  }
+  return {
+    skillMd,
+    scripts,
+    references,
+    assets: []
+    // TODO: handle binary assets
+  };
+}
+async function getDefaultBranch(owner, repo) {
+  const client = getOctokit();
+  const response = await client.repos.get({ owner, repo });
+  return response.data.default_branch;
+}
+
+// src/commands/install.ts
+async function install(skillId, options) {
+  const spinner = ora("Fetching skill information...").start();
+  try {
+    const parts = skillId.split("/");
+    if (parts.length < 2) {
+      spinner.fail("Invalid skill ID format. Use: owner/repo or owner/repo/skill-name");
+      process.exit(1);
+    }
+    const [owner, repo, ...rest] = parts;
+    const skillPath = rest.join("/");
+    const skillInfo = await getSkill(skillId);
+    let skillName;
+    let branch = "main";
+    if (skillInfo) {
+      skillName = skillInfo.name;
+      spinner.text = `Found skill: ${chalk.cyan(skillName)}`;
+    } else {
+      spinner.text = "Skill not in registry, fetching from GitHub...";
+      branch = await getDefaultBranch(owner, repo);
+      skillName = skillPath || repo;
+    }
+    const installed = await isSkillInstalled(options.platform, skillName, options.project);
+    if (installed && !options.force) {
+      spinner.fail(
+        `Skill ${chalk.cyan(skillName)} is already installed. Use ${chalk.yellow("--force")} to overwrite.`
+      );
+      process.exit(1);
+    }
+    await ensureSkillsDir(options.platform, options.project);
+    spinner.text = "Downloading skill files...";
+    const content = await fetchSkillContent(owner, repo, skillPath, branch);
+    const parsed = parseSkillMd(content.skillMd);
+    if (!parsed.validation.isValid) {
+      spinner.warn("Skill has validation issues:");
+      for (const error of parsed.validation.errors) {
+        console.log(chalk.yellow(`  - ${error.message}`));
+      }
+    }
+    const actualName = parsed.metadata.name || skillName;
+    const installPath = getSkillPath(options.platform, actualName, options.project);
+    if (installed && options.force) {
+      await fs.remove(installPath);
+    }
+    spinner.text = "Installing skill...";
+    await fs.ensureDir(installPath);
+    await fs.writeFile(path.join(installPath, "SKILL.md"), content.skillMd);
+    await fs.writeJson(path.join(installPath, ".skillhub.json"), {
+      skillId,
+      installedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      platform: options.platform,
+      version: parsed.metadata.version || null
+    });
+    if (content.scripts.length > 0) {
+      const scriptsDir = path.join(installPath, "scripts");
+      await fs.ensureDir(scriptsDir);
+      for (const script of content.scripts) {
+        const scriptPath = path.join(scriptsDir, script.name);
+        await fs.writeFile(scriptPath, script.content);
+        await fs.chmod(scriptPath, "755");
+      }
+    }
+    if (content.references.length > 0) {
+      const refsDir = path.join(installPath, "references");
+      await fs.ensureDir(refsDir);
+      for (const ref of content.references) {
+        await fs.writeFile(path.join(refsDir, ref.name), ref.content);
+      }
+    }
+    await trackInstall(skillId, options.platform, "cli");
+    spinner.succeed(`Skill ${chalk.green(actualName)} installed successfully!`);
+    console.log();
+    console.log(chalk.dim(`Path: ${installPath}`));
+    console.log();
+    if (parsed.metadata.description) {
+      console.log(chalk.dim(parsed.metadata.description));
+      console.log();
+    }
+    console.log(chalk.yellow("Usage:"));
+    console.log(
+      `  This skill will be automatically activated when your ${getPlatformName(options.platform)} agent recognizes it's relevant.`
+    );
+    if (content.scripts.length > 0) {
+      console.log();
+      console.log(chalk.dim(`Scripts: ${content.scripts.map((s) => s.name).join(", ")}`));
+    }
+  } catch (error) {
+    spinner.fail("Installation failed");
+    console.error(chalk.red(error.message));
+    process.exit(1);
+  }
+}
+function getPlatformName(platform) {
+  const names = {
+    claude: "Claude",
+    codex: "OpenAI Codex",
+    copilot: "GitHub Copilot",
+    cursor: "Cursor",
+    windsurf: "Windsurf"
+  };
+  return names[platform];
+}
+
+// src/commands/search.ts
+import chalk2 from "chalk";
+import ora2 from "ora";
+async function search(query, options) {
+  const spinner = ora2("Searching skills...").start();
+  try {
+    const limit = parseInt(options.limit || "10");
+    const result = await searchSkills(query, {
+      platform: options.platform,
+      limit
+    });
+    spinner.stop();
+    if (result.skills.length === 0) {
+      console.log(chalk2.yellow("No skills found."));
+      console.log(chalk2.dim("Try a different search term or check the spelling."));
+      return;
+    }
+    console.log(chalk2.bold(`Found ${result.pagination.total} skills:
+`));
+    console.log(
+      chalk2.dim("\u2500".repeat(80))
+    );
+    for (const skill of result.skills) {
+      const verified = skill.isVerified ? chalk2.green("\u2713") : " ";
+      const security = getSecurityBadge(skill.securityScore);
+      console.log(
+        `${verified} ${chalk2.cyan(skill.name.padEnd(25))} ${security}  \u2B50 ${formatNumber(skill.githubStars).padStart(6)}  \u2B07 ${formatNumber(skill.downloadCount).padStart(6)}`
+      );
+      console.log(
+        `  ${chalk2.dim(skill.description.slice(0, 70))}${skill.description.length > 70 ? "..." : ""}`
+      );
+      console.log(
+        `  ${chalk2.dim("Platforms:")} ${skill.compatibility.platforms.join(", ")}`
+      );
+      console.log(chalk2.dim("\u2500".repeat(80)));
+    }
+    console.log();
+    console.log(chalk2.dim(`Install with: ${chalk2.white("npx skillhub install <skill-id>")}`));
+    if (result.pagination.total > result.skills.length) {
+      console.log(
+        chalk2.dim(`Showing ${result.skills.length} of ${result.pagination.total}. Use --limit to see more.`)
+      );
+    }
+  } catch (error) {
+    spinner.fail("Search failed");
+    console.error(chalk2.red(error.message));
+    process.exit(1);
+  }
+}
+function formatNumber(num) {
+  if (num >= 1e3) {
+    return (num / 1e3).toFixed(1) + "k";
+  }
+  return num.toString();
+}
+function getSecurityBadge(score) {
+  if (score >= 90) return chalk2.green("\u25CF\u25CF\u25CF\u25CF\u25CF");
+  if (score >= 70) return chalk2.yellow("\u25CF\u25CF\u25CF\u25CF\u25CB");
+  if (score >= 50) return chalk2.yellow("\u25CF\u25CF\u25CF\u25CB\u25CB");
+  if (score >= 30) return chalk2.red("\u25CF\u25CF\u25CB\u25CB\u25CB");
+  return chalk2.red("\u25CF\u25CB\u25CB\u25CB\u25CB");
+}
+
+// src/commands/list.ts
+import fs2 from "fs-extra";
+import * as path2 from "path";
+import chalk3 from "chalk";
+import { parseSkillMd as parseSkillMd2 } from "skillhub-core";
+var ALL_PLATFORMS = ["claude", "codex", "copilot", "cursor", "windsurf"];
+async function list(options) {
+  const platforms = options.platform ? [options.platform] : ALL_PLATFORMS;
+  let totalSkills = 0;
+  for (const platform of platforms) {
+    const skills = await getInstalledSkills(platform);
+    if (skills.length === 0) {
+      continue;
+    }
+    totalSkills += skills.length;
+    console.log(chalk3.bold(`
+${getPlatformName2(platform)} (${skills.length} skills):`));
+    console.log(chalk3.dim("\u2500".repeat(60)));
+    for (const skill of skills) {
+      const version = skill.version ? chalk3.dim(`v${skill.version}`) : "";
+      console.log(`  ${chalk3.cyan(skill.name.padEnd(25))} ${version}`);
+      if (skill.description) {
+        console.log(`  ${chalk3.dim(skill.description.slice(0, 55))}${skill.description.length > 55 ? "..." : ""}`);
+      }
+    }
+  }
+  if (totalSkills === 0) {
+    console.log(chalk3.yellow("\nNo skills installed."));
+    console.log(chalk3.dim("Search for skills with: npx skillhub search <query>"));
+    console.log(chalk3.dim("Install a skill with: npx skillhub install <skill-id>"));
+  } else {
+    console.log(chalk3.dim(`
+${totalSkills} total skill(s) installed.`));
+  }
+}
+async function getInstalledSkills(platform) {
+  const skillsPath = getSkillsPath(platform);
+  const skills = [];
+  if (!await fs2.pathExists(skillsPath)) {
+    return skills;
+  }
+  const entries = await fs2.readdir(skillsPath, { withFileTypes: true });
+  for (const entry of entries) {
+    if (!entry.isDirectory()) {
+      continue;
+    }
+    const skillPath = path2.join(skillsPath, entry.name);
+    const skillMdPath = path2.join(skillPath, "SKILL.md");
+    if (!await fs2.pathExists(skillMdPath)) {
+      continue;
+    }
+    try {
+      const content = await fs2.readFile(skillMdPath, "utf-8");
+      const parsed = parseSkillMd2(content);
+      skills.push({
+        name: parsed.metadata.name || entry.name,
+        description: parsed.metadata.description,
+        version: parsed.metadata.version,
+        path: skillPath
+      });
+    } catch {
+      skills.push({
+        name: entry.name,
+        path: skillPath
+      });
+    }
+  }
+  return skills.sort((a, b) => a.name.localeCompare(b.name));
+}
+function getPlatformName2(platform) {
+  const names = {
+    claude: "Claude",
+    codex: "OpenAI Codex",
+    copilot: "GitHub Copilot",
+    cursor: "Cursor",
+    windsurf: "Windsurf"
+  };
+  return names[platform];
+}
+
+// src/commands/config.ts
+import chalk4 from "chalk";
+async function config(options) {
+  const currentConfig = await loadConfig();
+  if (options.list || !options.set && !options.get) {
+    console.log(chalk4.bold("SkillHub CLI Configuration:\n"));
+    console.log(chalk4.dim(`Config file: ${getConfigPath()}
+`));
+    if (Object.keys(currentConfig).length === 0) {
+      console.log(chalk4.yellow("No configuration set."));
+      console.log(chalk4.dim("\nAvailable settings:"));
+      console.log(chalk4.dim("  defaultPlatform  - Default platform for installations (claude, codex, copilot)"));
+      console.log(chalk4.dim("  apiUrl           - SkillHub API URL"));
+      console.log(chalk4.dim("  githubToken      - GitHub personal access token for private repos"));
+      return;
+    }
+    for (const [key, value] of Object.entries(currentConfig)) {
+      const displayValue = key.toLowerCase().includes("token") ? maskSecret(String(value)) : String(value);
+      console.log(`  ${chalk4.cyan(key)}: ${displayValue}`);
+    }
+    return;
+  }
+  if (options.get) {
+    const value = currentConfig[options.get];
+    if (value === void 0) {
+      console.log(chalk4.yellow(`Config '${options.get}' is not set.`));
+      return;
+    }
+    const displayValue = options.get.toLowerCase().includes("token") ? maskSecret(String(value)) : String(value);
+    console.log(displayValue);
+    return;
+  }
+  if (options.set) {
+    const [key, ...valueParts] = options.set.split("=");
+    const value = valueParts.join("=");
+    if (!key || value === void 0) {
+      console.error(chalk4.red("Invalid format. Use: --set key=value"));
+      process.exit(1);
+    }
+    currentConfig[key] = value;
+    await saveConfig(currentConfig);
+    const displayValue = key.toLowerCase().includes("token") ? maskSecret(value) : value;
+    console.log(chalk4.green(`Set ${chalk4.cyan(key)} = ${displayValue}`));
+  }
+}
+function maskSecret(value) {
+  if (value.length <= 8) {
+    return "*".repeat(value.length);
+  }
+  return value.slice(0, 4) + "*".repeat(value.length - 8) + value.slice(-4);
+}
+
+// src/index.ts
+var VERSION = "0.1.0";
+var program = new Command();
+program.name("skillhub").description("CLI for managing AI Agent skills").version(VERSION);
+program.command("install <skill-id>").description("Install a skill from the registry").option("-p, --platform <platform>", "Target platform (claude, codex, copilot, cursor, windsurf)", "claude").option("--project", "Install in the current project instead of globally").option("-f, --force", "Overwrite existing skill").action(async (skillId, options) => {
+  await install(skillId, {
+    platform: options.platform,
+    project: options.project,
+    force: options.force
+  });
+});
+program.command("search <query>").description("Search for skills in the registry").option("-p, --platform <platform>", "Filter by platform").option("-l, --limit <number>", "Number of results", "10").action(async (query, options) => {
+  await search(query, options);
+});
+program.command("list").description("List installed skills").option("-p, --platform <platform>", "Filter by platform").action(async (options) => {
+  await list(options);
+});
+program.command("config").description("Manage CLI configuration").option("--set <key=value>", "Set a configuration value").option("--get <key>", "Get a configuration value").option("--list", "List all configuration values").action(async (options) => {
+  await config(options);
+});
+program.command("uninstall <skill-name>").description("Uninstall a skill").option("-p, --platform <platform>", "Target platform", "claude").option("--project", "Uninstall from project instead of globally").action(async (skillName, options) => {
+  const fs3 = await import("fs-extra");
+  const { getSkillPath: getSkillPath2, isSkillInstalled: isSkillInstalled2 } = await import("./paths-BVI5WSHE.js");
+  const installed = await isSkillInstalled2(options.platform, skillName, options.project);
+  if (!installed) {
+    console.log(chalk5.yellow(`Skill ${skillName} is not installed.`));
+    process.exit(1);
+  }
+  const skillPath = getSkillPath2(options.platform, skillName, options.project);
+  await fs3.default.remove(skillPath);
+  console.log(chalk5.green(`Skill ${skillName} uninstalled successfully.`));
+});
+program.command("update [skill-name]").description("Update installed skills").option("-p, --platform <platform>", "Target platform", "claude").option("--all", "Update all installed skills").action(async (skillName, options) => {
+  const fsExtra = await import("fs-extra");
+  const pathModule = await import("path");
+  const { getSkillsPath: getSkillsPath2, getSkillPath: getSkillPath2 } = await import("./paths-BVI5WSHE.js");
+  const ALL_PLATFORMS2 = ["claude", "codex", "copilot", "cursor", "windsurf"];
+  if (options.all) {
+    console.log(chalk5.cyan("\nUpdating all installed skills...\n"));
+    const platforms = options.platform ? [options.platform] : ALL_PLATFORMS2;
+    let updated = 0;
+    let failed = 0;
+    let skipped = 0;
+    for (const platform of platforms) {
+      const skillsPath = getSkillsPath2(platform);
+      if (!await fsExtra.default.pathExists(skillsPath)) {
+        continue;
+      }
+      const entries = await fsExtra.default.readdir(skillsPath, { withFileTypes: true });
+      for (const entry of entries) {
+        if (!entry.isDirectory()) continue;
+        const skillPath2 = pathModule.join(skillsPath, entry.name);
+        const metadataPath2 = pathModule.join(skillPath2, ".skillhub.json");
+        if (!await fsExtra.default.pathExists(metadataPath2)) {
+          console.log(chalk5.yellow(`  Skipping ${entry.name}: No metadata (reinstall with CLI to enable updates)`));
+          skipped++;
+          continue;
+        }
+        try {
+          const metadata = await fsExtra.default.readJson(metadataPath2);
+          const skillId = metadata.skillId;
+          if (!skillId) {
+            console.log(chalk5.yellow(`  Skipping ${entry.name}: No skill ID in metadata`));
+            skipped++;
+            continue;
+          }
+          console.log(chalk5.dim(`  Updating ${entry.name}...`));
+          await install(skillId, {
+            platform,
+            force: true
+          });
+          updated++;
+        } catch (error) {
+          console.log(chalk5.red(`  Failed to update ${entry.name}: ${error.message}`));
+          failed++;
+        }
+      }
+    }
+    console.log();
+    console.log(chalk5.green(`Updated: ${updated}`));
+    if (failed > 0) console.log(chalk5.red(`Failed: ${failed}`));
+    if (skipped > 0) console.log(chalk5.yellow(`Skipped: ${skipped}`));
+    return;
+  }
+  if (!skillName) {
+    console.log(chalk5.red("Please specify a skill name or use --all."));
+    process.exit(1);
+  }
+  const skillPath = getSkillPath2(options.platform, skillName);
+  const metadataPath = pathModule.join(skillPath, ".skillhub.json");
+  if (!await fsExtra.default.pathExists(metadataPath)) {
+    console.log(chalk5.yellow(`Skill ${skillName} was not installed via CLI.`));
+    console.log(chalk5.dim("To update, reinstall with: npx skillhub install <skill-id> --force"));
+    process.exit(1);
+  }
+  try {
+    const metadata = await fsExtra.default.readJson(metadataPath);
+    const skillId = metadata.skillId;
+    if (!skillId) {
+      console.log(chalk5.red("No skill ID found in metadata."));
+      process.exit(1);
+    }
+    console.log(chalk5.dim(`Updating ${skillName}...`));
+    await install(skillId, {
+      platform: options.platform,
+      force: true
+    });
+  } catch (error) {
+    console.log(chalk5.red(`Failed to update: ${error.message}`));
+    process.exit(1);
+  }
+});
+program.parse();
+if (!process.argv.slice(2).length) {
+  program.help();
+}

package/dist/paths-BVI5WSHE.js

@@ -0,0 +1,20 @@
+import {
+  detectPlatform,
+  ensureSkillsDir,
+  getConfigPath,
+  getSkillPath,
+  getSkillsPath,
+  isSkillInstalled,
+  loadConfig,
+  saveConfig
+} from "./chunk-YXEKBJKF.js";
+export {
+  detectPlatform,
+  ensureSkillsDir,
+  getConfigPath,
+  getSkillPath,
+  getSkillsPath,
+  isSkillInstalled,
+  loadConfig,
+  saveConfig
+};

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "skillhub",
+  "version": "0.1.0",
+  "description": "CLI tool for managing AI Agent skills - search, install, and update skills for Claude, Codex, Copilot, and more",
+  "author": "SkillHub Contributors",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/anthropics/skillhub.git",
+    "directory": "apps/cli"
+  },
+  "homepage": "https://skills.palebluedot.live",
+  "type": "module",
+  "bin": {
+    "skillhub": "./dist/index.js"
+  },
+  "files": ["dist"],
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --target node20 --clean",
+    "dev": "tsx src/index.ts",
+    "start": "node dist/index.js",
+    "lint": "eslint src/",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest",
+    "test:run": "vitest run"
+  },
+  "dependencies": {
+    "skillhub-core": "^0.1.0",
+    "@octokit/rest": "^20.0.2",
+    "chalk": "^5.3.0",
+    "commander": "^11.1.0",
+    "fs-extra": "^11.2.0",
+    "ora": "^8.0.1",
+    "prompts": "^2.4.2"
+  },
+  "devDependencies": {
+    "@types/fs-extra": "^11.0.4",
+    "@types/node": "^20.10.0",
+    "@types/prompts": "^2.4.9",
+    "tsup": "^8.0.1",
+    "tsx": "^4.7.0",
+    "typescript": "^5.3.0",
+    "vitest": "^1.2.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "keywords": ["ai", "agent", "skills", "cli", "claude", "codex", "copilot"]
+}