codex-skills-registry 0.1.0

package/README.md

@@ -0,0 +1,24 @@
+# codex-skills-registry
+
+Install Codex skills from `vadimcomanescu/codex-skills`.
+
+## Usage
+
+Install one or more skills (recommended):
+
+```bash
+npx codex-skills-registry@latest --skill=development/webapp-testing --yes
+```
+
+### Options
+
+- `--skill=<category>/<slug>`: Skill to install. Repeatable.
+- `--yes`: Skip prompts.
+- `--local`: Install into `<repo>/.codex/skills` instead of `$CODEX_HOME/skills`.
+- `--dest=<path>`: Explicit install root (overrides `--local`).
+- `--ref=<git-ref>`: Git ref (default: `main`).
+- `--owner=<owner>` / `--repo=<repo>`: Override GitHub repo (default: `vadimcomanescu/codex-skills`).
+
+## Install location
+
+By default this installs into `$CODEX_HOME/skills`. If `CODEX_HOME` is not set, it uses `~/.codex/skills`.

package/bin/cli.js

@@ -0,0 +1,249 @@
+#!/usr/bin/env node
+
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import * as readline from "node:readline";
+import { fileURLToPath } from "node:url";
+
+const DEFAULT_OWNER = "vadimcomanescu";
+const DEFAULT_REPO = "codex-skills";
+const DEFAULT_REF = "main";
+
+function formatVersion() {
+  try {
+    const __dirname = path.dirname(fileURLToPath(import.meta.url));
+    const pkgPath = path.join(__dirname, "..", "package.json");
+    const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
+    return pkg.version ? `v${pkg.version}` : "v0.0.0";
+  } catch {
+    return "v0.0.0";
+  }
+}
+
+function printHeader() {
+  const version = formatVersion();
+  const title = "🚀 Install Codex skills 🚀";
+  const width = Math.max(title.length, version.length) + 8;
+  const pad = (text) => {
+    const space = Math.max(0, Math.floor((width - text.length) / 2));
+    return `${" ".repeat(space)}${text}`;
+  };
+  process.stdout.write(`${pad(title)}\n`);
+  process.stdout.write(`${pad(version)}\n`);
+  process.stdout.write(`📖 Documentation: https://skillregistry.dev\n\n`);
+}
+
+function parseArgs(argv) {
+  const out = {
+    skills: [],
+    yes: false,
+    local: false,
+    dest: null,
+    ref: DEFAULT_REF,
+    owner: DEFAULT_OWNER,
+    repo: DEFAULT_REPO,
+    help: false,
+  };
+
+  for (const raw of argv) {
+    if (raw === "--help" || raw === "-h") out.help = true;
+    else if (raw === "--yes" || raw === "-y") out.yes = true;
+    else if (raw === "--local") out.local = true;
+    else if (raw.startsWith("--dest=")) out.dest = raw.slice("--dest=".length);
+    else if (raw.startsWith("--ref=")) out.ref = raw.slice("--ref=".length);
+    else if (raw.startsWith("--owner=")) out.owner = raw.slice("--owner=".length);
+    else if (raw.startsWith("--repo=")) out.repo = raw.slice("--repo=".length);
+    else if (raw.startsWith("--skill=")) out.skills.push(raw.slice("--skill=".length));
+  }
+
+  return out;
+}
+
+function printHelp() {
+  process.stdout.write(
+    [
+      "codex-skills-registry",
+      "",
+      "Usage:",
+      "  npx codex-skills-registry@latest --skill=<category>/<slug> [--skill=...] --yes",
+      "",
+      "Options:",
+      "  --skill=<category>/<slug>   Skill to install (repeatable).",
+      "  --yes, -y                   Skip prompts.",
+      "  --local                     Install into <repo>/.codex/skills.",
+      "  --dest=<path>               Install root (overrides --local).",
+      "  --ref=<git-ref>             Git ref (default: main).",
+      "  --owner=<owner>             GitHub owner (default: vadimcomanescu).",
+      "  --repo=<repo>               GitHub repo (default: codex-skills).",
+      "",
+      "Env:",
+      "  CODEX_HOME                  Overrides default install root (~/.codex).",
+      "  GITHUB_TOKEN                Optional GitHub token for higher rate limits.",
+      "",
+    ].join("\n"),
+  );
+}
+
+function getInstallRoot({ dest, local }) {
+  if (dest) return path.resolve(dest);
+  if (local) return path.join(process.cwd(), ".codex", "skills");
+  const codexHome = process.env.CODEX_HOME || path.join(os.homedir(), ".codex");
+  return path.join(codexHome, "skills");
+}
+
+function withAuthHeaders(headers = {}) {
+  const token = process.env.GITHUB_TOKEN;
+  if (!token) return headers;
+  return { ...headers, Authorization: `Bearer ${token}` };
+}
+
+async function fetchJson(url) {
+  const res = await fetch(url, {
+    headers: withAuthHeaders({ Accept: "application/vnd.github+json" }),
+  });
+  if (!res.ok) {
+    const text = await res.text().catch(() => "");
+    throw new Error(`GitHub request failed (${res.status}): ${text}`);
+  }
+  return res.json();
+}
+
+async function fetchBuffer(url) {
+  const res = await fetch(url, { headers: withAuthHeaders() });
+  if (!res.ok) {
+    const text = await res.text().catch(() => "");
+    throw new Error(`Download failed (${res.status}): ${text}`);
+  }
+  const ab = await res.arrayBuffer();
+  return Buffer.from(ab);
+}
+
+async function confirm(question) {
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.trim().toLowerCase() === "y" || answer.trim().toLowerCase() === "yes");
+    });
+  });
+}
+
+async function listRepoTree(owner, repo, ref) {
+  const url = `https://api.github.com/repos/${owner}/${repo}/git/trees/${ref}?recursive=1`;
+  const data = await fetchJson(url);
+  return Array.isArray(data.tree) ? data.tree : [];
+}
+
+function findSkillPrefix(tree, skillRef) {
+  const curatedPrefix = `skills/.curated/${skillRef}/`;
+  const experimentalPrefix = `skills/.experimental/${skillRef}/`;
+
+  const hasCurated = tree.some((item) => item.type === "blob" && item.path.startsWith(curatedPrefix));
+  if (hasCurated) return curatedPrefix;
+
+  const hasExperimental = tree.some((item) => item.type === "blob" && item.path.startsWith(experimentalPrefix));
+  if (hasExperimental) return experimentalPrefix;
+
+  return null;
+}
+
+async function installSkill({ owner, repo, ref, tree, skillRef, installRoot, yes }) {
+  process.stdout.write(`💡 Installing skill: ${skillRef}\n`);
+  const prefix = findSkillPrefix(tree, skillRef);
+  if (!prefix) {
+    throw new Error(`Could not find skill '${skillRef}' in ${owner}/${repo}@${ref}`);
+  }
+
+  const destDir = path.join(installRoot, skillRef);
+  if (!yes && fs.existsSync(destDir)) {
+    const ok = await confirm(`⚠️  ${destDir} already exists. Overwrite? (y/N) `);
+    if (!ok) return { installed: false };
+    fs.rmSync(destDir, { recursive: true, force: true });
+  }
+
+  fs.mkdirSync(destDir, { recursive: true });
+  process.stdout.write(`📥 Downloading skill from GitHub (${ref} branch)...\n`);
+
+  const files = tree
+    .filter((item) => item.type === "blob" && item.path.startsWith(prefix))
+    .map((item) => item.path)
+    .sort((a, b) => a.localeCompare(b));
+
+  const seenDirs = new Set();
+  for (const filePath of files) {
+    const relative = filePath.slice(prefix.length);
+    if (!relative) continue;
+
+    const dir = path.dirname(relative);
+    if (dir !== "." && !seenDirs.has(dir)) {
+      process.stdout.write(`📂 Downloading directory: ${dir}/\n`);
+      seenDirs.add(dir);
+    }
+
+    const rawUrl = `https://raw.githubusercontent.com/${owner}/${repo}/${ref}/${filePath}`;
+    const destPath = path.join(destDir, relative);
+    fs.mkdirSync(path.dirname(destPath), { recursive: true });
+    const buf = await fetchBuffer(rawUrl);
+    fs.writeFileSync(destPath, buf);
+    process.stdout.write(`✓ Downloaded: ${relative}\n`);
+  }
+
+  return { installed: true, files: files.length };
+}
+
+async function main() {
+  const args = parseArgs(process.argv.slice(2));
+  if (args.help) {
+    printHelp();
+    return;
+  }
+
+  if (args.skills.length === 0) {
+    printHelp();
+    process.exitCode = 1;
+    return;
+  }
+
+  printHeader();
+
+  const installRoot = getInstallRoot({ dest: args.dest, local: args.local });
+  if (!args.yes) {
+    process.stdout.write(`📍 Install root: ${installRoot}\n`);
+    process.stdout.write(`   (Tip: use --local to install into <repo>/.codex/skills)\n\n`);
+  }
+
+  const total = args.skills.length;
+  process.stdout.write(`🔧 Installing multiple components...\n`);
+  process.stdout.write(`📦 Installing ${total} components:\n`);
+  process.stdout.write(`   Agents: 0\n`);
+  process.stdout.write(`   Commands: 0\n`);
+  process.stdout.write(`   MCPs: 0\n`);
+  process.stdout.write(`   Settings: 0\n`);
+  process.stdout.write(`   Hooks: 0\n`);
+  process.stdout.write(`   Skills: ${total}\n`);
+
+  const tree = await listRepoTree(args.owner, args.repo, args.ref);
+
+  let installedCount = 0;
+  for (const skillRef of args.skills) {
+    process.stdout.write(`   Installing skill: ${skillRef}\n`);
+    const result = await installSkill({
+      owner: args.owner,
+      repo: args.repo,
+      ref: args.ref,
+      tree,
+      skillRef,
+      installRoot,
+      yes: args.yes,
+    });
+    if (result.installed) installedCount += 1;
+  }
+
+  process.stdout.write(`\n✅ Successfully installed ${installedCount} components!\n`);
+}
+
+main().catch((err) => {
+  process.stderr.write(`\n❌ ${err instanceof Error ? err.message : String(err)}\n`);
+  process.exitCode = 1;
+});

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "codex-skills-registry",
+  "version": "0.1.0",
+  "description": "Install Codex skills from GitHub into your local Codex setup.",
+  "private": false,
+  "type": "module",
+  "license": "MIT",
+  "homepage": "https://skillregistry.dev",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/vadimcomanescu/codex-tmpl.git",
+    "directory": "packages/codex-skills-registry"
+  },
+  "bugs": {
+    "url": "https://github.com/vadimcomanescu/codex-tmpl/issues"
+  },
+  "keywords": ["codex", "openai", "cli", "skills", "installer"],
+  "funding": {
+    "type": "individual",
+    "url": "https://buymeacoffee.com/vadim984"
+  },
+  "files": ["bin", "README.md", "package.json"],
+  "publishConfig": {
+    "access": "public"
+  },
+  "bin": {
+    "codex-skills-registry": "bin/cli.js"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}