fetch-skill 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Shane Holloman
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,208 @@
+# fetch-skill
+
+Install agent skills onto your coding agents from any git repository.
+
+<!-- agent-list:start -->
+Supports **Opencode**, **Claude Code**, **Codex**, **Cursor**, and [11 more](#available-agents).
+<!-- agent-list:end -->
+
+## Quick Start
+
+```bash
+npx fetch-skill shaneholloman/agent-skills
+```
+
+## What are Agent Skills?
+
+Agent skills are reusable instruction sets that extend your coding agent's capabilities. They're defined in `SKILL.md` files with YAML frontmatter containing a `name` and `description`.
+
+Skills let agents perform specialized tasks like:
+
+- Generating release notes from git history
+- Creating PRs following your team's conventions
+- Integrating with external tools (Linear, Notion, etc.)
+
+## Usage
+
+### Source Formats
+
+The `<source>` argument accepts multiple formats:
+
+```bash
+# GitHub shorthand
+npx fetch-skill shaneholloman/agent-skills
+
+# Full GitHub URL
+npx fetch-skill https://github.com/shaneholloman/agent-skills
+
+# Direct path to a skill in a repo
+npx fetch-skill https://github.com/shaneholloman/agent-skills/tree/main/skills/frontend-design
+
+# GitLab URL
+npx fetch-skill https://gitlab.com/org/repo
+
+# Any git URL
+npx fetch-skill git@github.com:shaneholloman/agent-skills.git
+```
+
+### Options
+
+| Option                    | Description                                                                                                                                        |
+| ------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `-g, --global`            | Install to user directory instead of project                                                                                                       |
+| `-a, --agent <agents...>` | <!-- agent-names:start -->Target specific agents (e.g., `claude-code`, `codex`). See [Available Agents](#available-agents)<!-- agent-names:end --> |
+| `-s, --skill <skills...>` | Install specific skills by name                                                                                                                    |
+| `-l, --list`              | List available skills without installing                                                                                                           |
+| `-y, --yes`               | Skip all confirmation prompts                                                                                                                      |
+| `-V, --version`           | Show version number                                                                                                                                |
+| `-h, --help`              | Show help                                                                                                                                          |
+
+### Examples
+
+```bash
+# List skills in a repository
+npx fetch-skill shaneholloman/agent-skills --list
+
+# Install multiple specific skills
+npx fetch-skill shaneholloman/agent-skills --skill frontend-design --skill skill-creator
+
+# Install to specific agents
+npx fetch-skill shaneholloman/agent-skills -a claude-code -a opencode
+
+# Non-interactive installation (CI/CD friendly)
+npx fetch-skill shaneholloman/agent-skills --skill frontend-design -g -a claude-code -y
+
+# Install all skills from a repo
+npx fetch-skill shaneholloman/agent-skills -y -g
+```
+
+## Available Agents
+
+Skills can be installed to any of these supported agents. Use `-g, --global` to install to the global path instead of project-level.
+
+<!-- available-agents:start -->
+| Agent          | Project Path        | Global Path                     |
+| -------------- | ------------------- | ------------------------------- |
+| OpenCode       | `.opencode/skill/`  | `~/.config/opencode/skill/`     |
+| Claude Code    | `.claude/skills/`   | `~/.claude/skills/`             |
+| Codex          | `.codex/skills/`    | `~/.codex/skills/`              |
+| Cursor         | `.cursor/skills/`   | `~/.cursor/skills/`             |
+| Amp            | `.agents/skills/`   | `~/.config/agents/skills/`      |
+| Kilo Code      | `.kilocode/skills/` | `~/.kilocode/skills/`           |
+| Roo Code       | `.roo/skills/`      | `~/.roo/skills/`                |
+| Goose          | `.goose/skills/`    | `~/.config/goose/skills/`       |
+| Gemini CLI     | `.gemini/skills/`   | `~/.gemini/skills/`             |
+| Antigravity    | `.agent/skills/`    | `~/.gemini/antigravity/skills/` |
+| GitHub Copilot | `.github/skills/`   | `~/.copilot/skills/`            |
+| Clawdbot       | `skills/`           | `~/.clawdbot/skills/`           |
+| Droid          | `.factory/skills/`  | `~/.factory/skills/`            |
+| Gemini CLI     | `.gemini/skills/`   | `~/.gemini/skills/`             |
+| Windsurf       | `.windsurf/skills/` | `~/.codeium/windsurf/skills/`   |
+<!-- available-agents:end -->
+
+## Agent Detection
+
+The CLI automatically detects which coding agents you have installed by checking for their configuration directories. If none are detected, you'll be prompted to select which agents to install to.
+
+## Creating Skills
+
+Skills are directories containing a `SKILL.md` file with YAML frontmatter:
+
+```markdown
+---
+name: my-skill
+description: What this skill does and when to use it
+---
+
+# My Skill
+
+Instructions for the agent to follow when this skill is activated.
+
+## When to Use
+
+Describe the scenarios where this skill should be used.
+
+## Steps
+
+1. First, do this
+2. Then, do that
+```
+
+### Required Fields
+
+- `name`: Unique identifier (lowercase, hyphens allowed)
+- `description`: Brief explanation of what the skill does
+
+### Skill Discovery
+
+The CLI searches for skills in these locations within a repository:
+
+<!-- skill-discovery:start -->
+- Root directory (if it contains `SKILL.md`)
+- `skills/`
+- `skills/.curated/`
+- `skills/.experimental/`
+- `skills/.system/`
+- `.opencode/skill/`
+- `.claude/skills/`
+- `.codex/skills/`
+- `.cursor/skills/`
+- `.agents/skills/`
+- `.kilocode/skills/`
+- `.roo/skills/`
+- `.goose/skills/`
+- `.gemini/skills/`
+- `.agent/skills/`
+- `.github/skills/`
+- `./skills/`
+- `.factory/skills/`
+- `.windsurf/skills/`
+<!-- skill-discovery:end -->
+
+If no skills are found in standard locations, a recursive search is performed.
+
+## Compatibility
+
+Skills are generally compatible across agents since they follow a shared [Agent Skills specification](https://agentskills.io). However, some features may be agent-specific:
+
+| Feature         | OpenCode | Claude Code | Codex | Cursor | Antigravity | Roo Code | Github Copilot | Amp | Clawdbot |
+| --------------- | -------- | ----------- | ----- | ------ | ----------- | -------- | -------------- | --- | -------- |
+| Basic skills    | Yes      | Yes         | Yes   | Yes    | Yes         | Yes      | Yes            | Yes | Yes      |
+| `allowed-tools` | Yes      | Yes         | Yes   | Yes    | Yes         | Yes      | Yes            | Yes | Yes      |
+| `context: fork` | No       | Yes         | No    | No     | No          | No       | No             | No  | No       |
+| Hooks           | No       | Yes         | No    | No     | No          | No       | No             | No  | No       |
+
+## Troubleshooting
+
+### "No skills found"
+
+Ensure the repository contains valid `SKILL.md` files with both `name` and `description` in the frontmatter.
+
+### Skill not loading in agent
+
+- Verify the skill was installed to the correct path
+- Check the agent's documentation for skill loading requirements
+- Ensure the `SKILL.md` frontmatter is valid YAML
+
+### Permission errors
+
+Ensure you have write access to the target directory.
+
+## Related Links
+
+- [Vercel Agent Skills Repository](https://github.com/shaneholloman/agent-skills)
+- [Agent Skills Specification](https://agentskills.io)
+- [OpenCode Skills Documentation](https://opencode.ai/docs/skills)
+- [Claude Code Skills Documentation](https://code.claude.com/docs/en/skills)
+- [Codex Skills Documentation](https://developers.openai.com/codex/skills)
+- [Cursor Skills Documentation](https://cursor.com/docs/context/skills)
+- [Gemini CLI Skills Documentation](https://geminicli.com/docs/cli/skills/)
+- [Amp Skills Documentation](https://ampcode.com/manual#agent-skills)
+- [Antigravity Skills Documentation](https://antigravity.google/docs/skills)
+- [GitHub Copilot Agent Skills](https://docs.github.com/en/copilot/concepts/agents/about-agent-skills)
+- [Roo Code Skills Documentation](https://docs.roocode.com/features/skills)
+- [Clawdbot Skills Documentation](https://docs.clawd.bot/tools/skills)
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/index.js

@@ -0,0 +1,787 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import * as p from "@clack/prompts";
+import chalk from "chalk";
+import { program } from "commander";
+
+// package.json
+var package_default = {
+  name: "fetch-skill",
+  version: "1.0.0",
+  description: "Install agent skills onto coding agents (OpenCode, Claude Code, Codex, Cursor)",
+  type: "module",
+  bin: {
+    "fetch-skill": "dist/index.js"
+  },
+  files: [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  scripts: {
+    build: "tsup src/index.ts --format esm --dts --clean",
+    dev: "tsx src/index.ts",
+    lint: "biome lint --write .",
+    format: "biome format --write .",
+    check: "biome check --write .",
+    prepublishOnly: "npm run build",
+    "update-readme": "tsx scripts/update-readme.ts"
+  },
+  keywords: [
+    "cli",
+    "skills",
+    "opencode",
+    "claude-code",
+    "codex",
+    "cursor",
+    "amp",
+    "antigravity",
+    "roo-code",
+    "ai-agents"
+  ],
+  repository: {
+    type: "git",
+    url: "git+https://github.com/shaneholloman/fetch-skill.git"
+  },
+  homepage: "https://github.com/shaneholloman/fetch-skill#readme",
+  bugs: {
+    url: "https://github.com/shaneholloman/fetch-skill/issues"
+  },
+  author: "Shane Holloman",
+  license: "MIT",
+  dependencies: {
+    "@clack/prompts": "^0.11.0",
+    chalk: "^5.6.2",
+    commander: "^14.0.2",
+    "gray-matter": "^4.0.3",
+    "simple-git": "^3.30.0"
+  },
+  devDependencies: {
+    "@biomejs/biome": "^2.3.11",
+    "@types/node": "^25.0.9",
+    tsup: "^8.5.1",
+    tsx: "^4.21.0",
+    typescript: "^5.9.3"
+  },
+  engines: {
+    node: ">=22"
+  }
+};
+
+// src/agents.ts
+import { existsSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+var home = homedir();
+var agents = {
+  opencode: {
+    name: "opencode",
+    displayName: "OpenCode",
+    skillsDir: ".opencode/skill",
+    globalSkillsDir: join(home, ".config/opencode/skill"),
+    detectInstalled: async () => {
+      return existsSync(join(home, ".config/opencode")) || existsSync(join(home, ".claude/skills"));
+    }
+  },
+  "claude-code": {
+    name: "claude-code",
+    displayName: "Claude Code",
+    skillsDir: ".claude/skills",
+    globalSkillsDir: join(home, ".claude/skills"),
+    detectInstalled: async () => {
+      return existsSync(join(home, ".claude"));
+    }
+  },
+  codex: {
+    name: "codex",
+    displayName: "Codex",
+    skillsDir: ".codex/skills",
+    globalSkillsDir: join(home, ".codex/skills"),
+    detectInstalled: async () => {
+      return existsSync(join(home, ".codex"));
+    }
+  },
+  cursor: {
+    name: "cursor",
+    displayName: "Cursor",
+    skillsDir: ".cursor/skills",
+    globalSkillsDir: join(home, ".cursor/skills"),
+    detectInstalled: async () => {
+      return existsSync(join(home, ".cursor"));
+    }
+  },
+  amp: {
+    name: "amp",
+    displayName: "Amp",
+    skillsDir: ".agents/skills",
+    globalSkillsDir: join(home, ".config/agents/skills"),
+    detectInstalled: async () => {
+      return existsSync(join(home, ".config/amp"));
+    }
+  },
+  kilo: {
+    name: "kilo",
+    displayName: "Kilo Code",
+    skillsDir: ".kilocode/skills",
+    globalSkillsDir: join(home, ".kilocode/skills"),
+    detectInstalled: async () => {
+      return existsSync(join(home, ".kilocode"));
+    }
+  },
+  roo: {
+    name: "roo",
+    displayName: "Roo Code",
+    skillsDir: ".roo/skills",
+    globalSkillsDir: join(home, ".roo/skills"),
+    detectInstalled: async () => {
+      return existsSync(join(home, ".roo"));
+    }
+  },
+  goose: {
+    name: "goose",
+    displayName: "Goose",
+    skillsDir: ".goose/skills",
+    globalSkillsDir: join(home, ".config/goose/skills"),
+    detectInstalled: async () => {
+      return existsSync(join(home, ".config/goose"));
+    }
+  },
+  "gemini-cli": {
+    name: "gemini-cli",
+    displayName: "Gemini CLI",
+    skillsDir: ".gemini/skills",
+    globalSkillsDir: join(home, ".gemini/skills"),
+    detectInstalled: async () => {
+      return existsSync(join(home, ".gemini"));
+    }
+  },
+  antigravity: {
+    name: "antigravity",
+    displayName: "Antigravity",
+    skillsDir: ".agent/skills",
+    globalSkillsDir: join(home, ".gemini/antigravity/skills"),
+    detectInstalled: async () => {
+      return existsSync(join(process.cwd(), ".agent")) || existsSync(join(home, ".gemini/antigravity"));
+    }
+  },
+  "github-copilot": {
+    name: "github-copilot",
+    displayName: "GitHub Copilot",
+    skillsDir: ".github/skills",
+    globalSkillsDir: join(home, ".copilot/skills"),
+    detectInstalled: async () => {
+      return existsSync(join(process.cwd(), ".github")) || existsSync(join(home, ".copilot"));
+    }
+  },
+  clawdbot: {
+    name: "clawdbot",
+    displayName: "Clawdbot",
+    skillsDir: "skills",
+    globalSkillsDir: join(home, ".clawdbot/skills"),
+    detectInstalled: async () => {
+      return existsSync(join(home, ".clawdbot"));
+    }
+  },
+  droid: {
+    name: "droid",
+    displayName: "Droid",
+    skillsDir: ".factory/skills",
+    globalSkillsDir: join(home, ".factory/skills"),
+    detectInstalled: async () => {
+      return existsSync(join(home, ".factory/skills"));
+    }
+  },
+  gemini: {
+    name: "gemini",
+    displayName: "Gemini CLI",
+    skillsDir: ".gemini/skills",
+    globalSkillsDir: join(home, ".gemini/skills"),
+    detectInstalled: async () => {
+      return existsSync(join(home, ".gemini"));
+    }
+  },
+  windsurf: {
+    name: "windsurf",
+    displayName: "Windsurf",
+    skillsDir: ".windsurf/skills",
+    globalSkillsDir: join(home, ".codeium/windsurf/skills"),
+    detectInstalled: async () => {
+      return existsSync(join(home, ".codeium/windsurf"));
+    }
+  }
+};
+async function detectInstalledAgents() {
+  const installed = [];
+  for (const [type, config] of Object.entries(agents)) {
+    if (await config.detectInstalled()) {
+      installed.push(type);
+    }
+  }
+  return installed;
+}
+
+// src/git.ts
+import { mkdtemp, rm } from "fs/promises";
+import { tmpdir } from "os";
+import { join as join2, normalize, resolve, sep } from "path";
+import simpleGit from "simple-git";
+function parseSource(input) {
+  const githubTreeMatch = input.match(/github\.com\/([^/]+)\/([^/]+)\/tree\/([^/]+)\/(.+)/);
+  if (githubTreeMatch) {
+    const [, owner, repo, , subpath] = githubTreeMatch;
+    return {
+      type: "github",
+      url: `https://github.com/${owner}/${repo}.git`,
+      subpath
+    };
+  }
+  const githubRepoMatch = input.match(/github\.com\/([^/]+)\/([^/]+)/);
+  if (githubRepoMatch) {
+    const [, owner, repo] = githubRepoMatch;
+    const cleanRepo = repo.replace(/\.git$/, "");
+    return {
+      type: "github",
+      url: `https://github.com/${owner}/${cleanRepo}.git`
+    };
+  }
+  const gitlabTreeMatch = input.match(/gitlab\.com\/([^/]+)\/([^/]+)\/-\/tree\/([^/]+)\/(.+)/);
+  if (gitlabTreeMatch) {
+    const [, owner, repo, , subpath] = gitlabTreeMatch;
+    return {
+      type: "gitlab",
+      url: `https://gitlab.com/${owner}/${repo}.git`,
+      subpath
+    };
+  }
+  const gitlabRepoMatch = input.match(/gitlab\.com\/([^/]+)\/([^/]+)/);
+  if (gitlabRepoMatch) {
+    const [, owner, repo] = gitlabRepoMatch;
+    const cleanRepo = repo.replace(/\.git$/, "");
+    return {
+      type: "gitlab",
+      url: `https://gitlab.com/${owner}/${cleanRepo}.git`
+    };
+  }
+  const shorthandMatch = input.match(/^([^/]+)\/([^/]+)(?:\/(.+))?$/);
+  if (shorthandMatch && !input.includes(":")) {
+    const [, owner, repo, subpath] = shorthandMatch;
+    return {
+      type: "github",
+      url: `https://github.com/${owner}/${repo}.git`,
+      subpath
+    };
+  }
+  return {
+    type: "git",
+    url: input
+  };
+}
+async function cloneRepo(url) {
+  const tempDir = await mkdtemp(join2(tmpdir(), "fetch-skill-"));
+  const git = simpleGit();
+  await git.clone(url, tempDir, ["--depth", "1"]);
+  return tempDir;
+}
+async function cleanupTempDir(dir) {
+  const normalizedDir = normalize(resolve(dir));
+  const normalizedTmpDir = normalize(resolve(tmpdir()));
+  if (!normalizedDir.startsWith(normalizedTmpDir + sep) && normalizedDir !== normalizedTmpDir) {
+    throw new Error("Attempted to clean up directory outside of temp directory");
+  }
+  await rm(dir, { recursive: true, force: true });
+}
+
+// src/installer.ts
+import { access, cp, mkdir, readdir } from "fs/promises";
+import { basename, join as join3, normalize as normalize2, resolve as resolve2, sep as sep2 } from "path";
+function sanitizeName(name) {
+  let sanitized = name.replace(/[/\\:\0]/g, "");
+  sanitized = sanitized.replace(/^[.\s]+|[.\s]+$/g, "");
+  sanitized = sanitized.replace(/^\.+/, "");
+  if (!sanitized || sanitized.length === 0) {
+    sanitized = "unnamed-skill";
+  }
+  if (sanitized.length > 255) {
+    sanitized = sanitized.substring(0, 255);
+  }
+  return sanitized;
+}
+function isPathSafe(basePath, targetPath) {
+  const normalizedBase = normalize2(resolve2(basePath));
+  const normalizedTarget = normalize2(resolve2(targetPath));
+  return normalizedTarget.startsWith(normalizedBase + sep2) || normalizedTarget === normalizedBase;
+}
+async function installSkillForAgent(skill, agentType, options = {}) {
+  const agent = agents[agentType];
+  const rawSkillName = skill.name || basename(skill.path);
+  const skillName = sanitizeName(rawSkillName);
+  const targetBase = options.global ? agent.globalSkillsDir : join3(options.cwd || process.cwd(), agent.skillsDir);
+  const targetDir = join3(targetBase, skillName);
+  if (!isPathSafe(targetBase, targetDir)) {
+    return {
+      success: false,
+      path: targetDir,
+      error: "Invalid skill name: potential path traversal detected"
+    };
+  }
+  try {
+    await mkdir(targetDir, { recursive: true });
+    await copyDirectory(skill.path, targetDir);
+    return { success: true, path: targetDir };
+  } catch (error) {
+    return {
+      success: false,
+      path: targetDir,
+      error: error instanceof Error ? error.message : "Unknown error"
+    };
+  }
+}
+var EXCLUDE_FILES = /* @__PURE__ */ new Set(["README.md", "metadata.json"]);
+var isExcluded = (name) => {
+  if (EXCLUDE_FILES.has(name)) return true;
+  if (name.startsWith("_")) return true;
+  return false;
+};
+async function copyDirectory(src, dest) {
+  await mkdir(dest, { recursive: true });
+  const entries = await readdir(src, { withFileTypes: true });
+  for (const entry of entries) {
+    if (isExcluded(entry.name)) {
+      continue;
+    }
+    const srcPath = join3(src, entry.name);
+    const destPath = join3(dest, entry.name);
+    if (entry.isDirectory()) {
+      await copyDirectory(srcPath, destPath);
+    } else {
+      await cp(srcPath, destPath);
+    }
+  }
+}
+async function isSkillInstalled(skillName, agentType, options = {}) {
+  const agent = agents[agentType];
+  const sanitized = sanitizeName(skillName);
+  const targetBase = options.global ? agent.globalSkillsDir : join3(options.cwd || process.cwd(), agent.skillsDir);
+  const skillDir = join3(targetBase, sanitized);
+  if (!isPathSafe(targetBase, skillDir)) {
+    return false;
+  }
+  try {
+    await access(skillDir);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function getInstallPath(skillName, agentType, options = {}) {
+  const agent = agents[agentType];
+  const sanitized = sanitizeName(skillName);
+  const targetBase = options.global ? agent.globalSkillsDir : join3(options.cwd || process.cwd(), agent.skillsDir);
+  const installPath = join3(targetBase, sanitized);
+  if (!isPathSafe(targetBase, installPath)) {
+    throw new Error("Invalid skill name: potential path traversal detected");
+  }
+  return installPath;
+}
+
+// src/skills.ts
+import { readdir as readdir2, readFile, stat } from "fs/promises";
+import { basename as basename2, dirname, join as join4 } from "path";
+import matter from "gray-matter";
+var SKIP_DIRS = ["node_modules", ".git", "dist", "build", "__pycache__"];
+async function hasSkillMd(dir) {
+  try {
+    const skillPath = join4(dir, "SKILL.md");
+    const stats = await stat(skillPath);
+    return stats.isFile();
+  } catch {
+    return false;
+  }
+}
+async function parseSkillMd(skillMdPath) {
+  try {
+    const content = await readFile(skillMdPath, "utf-8");
+    const { data } = matter(content);
+    if (!data.name || !data.description) {
+      return null;
+    }
+    return {
+      name: data.name,
+      description: data.description,
+      path: dirname(skillMdPath),
+      metadata: data.metadata
+    };
+  } catch {
+    return null;
+  }
+}
+async function findSkillDirs(dir, depth = 0, maxDepth = 5) {
+  const skillDirs = [];
+  if (depth > maxDepth) return skillDirs;
+  try {
+    if (await hasSkillMd(dir)) {
+      skillDirs.push(dir);
+    }
+    const entries = await readdir2(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isDirectory() && !SKIP_DIRS.includes(entry.name)) {
+        const subDirs = await findSkillDirs(join4(dir, entry.name), depth + 1, maxDepth);
+        skillDirs.push(...subDirs);
+      }
+    }
+  } catch {
+  }
+  return skillDirs;
+}
+async function discoverSkills(basePath, subpath) {
+  const skills = [];
+  const seenNames = /* @__PURE__ */ new Set();
+  const searchPath = subpath ? join4(basePath, subpath) : basePath;
+  if (await hasSkillMd(searchPath)) {
+    const skill = await parseSkillMd(join4(searchPath, "SKILL.md"));
+    if (skill) {
+      skills.push(skill);
+      return skills;
+    }
+  }
+  const prioritySearchDirs = [
+    searchPath,
+    join4(searchPath, "skills"),
+    join4(searchPath, "skills/.curated"),
+    join4(searchPath, "skills/.experimental"),
+    join4(searchPath, "skills/.system"),
+    join4(searchPath, ".codex/skills"),
+    join4(searchPath, ".claude/skills"),
+    join4(searchPath, ".opencode/skill"),
+    join4(searchPath, ".cursor/skills"),
+    join4(searchPath, ".agents/skills"),
+    join4(searchPath, ".kilocode/skills"),
+    join4(searchPath, ".roo/skills"),
+    join4(searchPath, ".goose/skills"),
+    join4(searchPath, ".agent/skills"),
+    join4(searchPath, ".github/skills")
+  ];
+  for (const dir of prioritySearchDirs) {
+    try {
+      const entries = await readdir2(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (entry.isDirectory()) {
+          const skillDir = join4(dir, entry.name);
+          if (await hasSkillMd(skillDir)) {
+            const skill = await parseSkillMd(join4(skillDir, "SKILL.md"));
+            if (skill && !seenNames.has(skill.name)) {
+              skills.push(skill);
+              seenNames.add(skill.name);
+            }
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  if (skills.length === 0) {
+    const allSkillDirs = await findSkillDirs(searchPath);
+    for (const skillDir of allSkillDirs) {
+      const skill = await parseSkillMd(join4(skillDir, "SKILL.md"));
+      if (skill && !seenNames.has(skill.name)) {
+        skills.push(skill);
+        seenNames.add(skill.name);
+      }
+    }
+  }
+  return skills;
+}
+function getSkillDisplayName(skill) {
+  return skill.name || basename2(skill.path);
+}
+
+// src/index.ts
+var version = package_default.version;
+program.name("fetch-skill").description(
+  "Install skills onto coding agents (OpenCode, Claude Code, Codex, Cursor, Antigravity, Github Copilot, Roo Code)"
+).version(version).argument("<source>", "Git repo URL, GitHub shorthand (owner/repo), or direct path to skill").option("-g, --global", "Install skill globally (user-level) instead of project-level").option(
+  "-a, --agent <agents...>",
+  "Specify agents to install to (opencode, claude-code, codex, cursor, antigravity, gitub-copilot, roo)"
+).option("-s, --skill <skills...>", "Specify skill names to install (skip selection prompt)").option("-l, --list", "List available skills in the repository without installing").option("-y, --yes", "Skip confirmation prompts").configureOutput({
+  outputError: (str, write) => {
+    if (str.includes("missing required argument")) {
+      console.log();
+      console.log(
+        `${chalk.bgRed.white.bold(" ERROR ")} ${chalk.red("Missing required argument: source")}`
+      );
+      console.log();
+      console.log(chalk.dim("  Usage:"));
+      console.log(
+        `    ${chalk.cyan("npx fetch-skill")} ${chalk.yellow("<source>")} ${chalk.dim("[options]")}`
+      );
+      console.log();
+      console.log(chalk.dim("  Example:"));
+      console.log(
+        `    ${chalk.cyan("npx fetch-skill")} ${chalk.yellow("shaneholloman/agent-skills")}`
+      );
+      console.log();
+      console.log(
+        chalk.dim("  Run") + ` ${chalk.cyan("npx fetch-skill --help")} ` + chalk.dim("for more information.")
+      );
+      console.log();
+    } else {
+      write(str);
+    }
+  }
+}).action(async (source, options) => {
+  await main(source, options);
+});
+program.parse();
+async function main(source, options) {
+  console.log();
+  p.intro(chalk.bgCyan.black(" fetch-skill "));
+  let tempDir = null;
+  try {
+    const spinner2 = p.spinner();
+    spinner2.start("Parsing source...");
+    const parsed = parseSource(source);
+    spinner2.stop(
+      `Source: ${chalk.cyan(parsed.url)}${parsed.subpath ? ` (${parsed.subpath})` : ""}`
+    );
+    spinner2.start("Cloning repository...");
+    tempDir = await cloneRepo(parsed.url);
+    spinner2.stop("Repository cloned");
+    spinner2.start("Discovering skills...");
+    const skills = await discoverSkills(tempDir, parsed.subpath);
+    if (skills.length === 0) {
+      spinner2.stop(chalk.red("No skills found"));
+      p.outro(
+        chalk.red("No valid skills found. Skills require a SKILL.md with name and description.")
+      );
+      await cleanup(tempDir);
+      process.exit(1);
+    }
+    spinner2.stop(`Found ${chalk.green(skills.length)} skill${skills.length > 1 ? "s" : ""}`);
+    if (options.list) {
+      console.log();
+      p.log.step(chalk.bold("Available Skills"));
+      for (const skill of skills) {
+        p.log.message(`  ${chalk.cyan(getSkillDisplayName(skill))}`);
+        p.log.message(`    ${chalk.dim(skill.description)}`);
+      }
+      console.log();
+      p.outro("Use --skill <name> to install specific skills");
+      await cleanup(tempDir);
+      process.exit(0);
+    }
+    let selectedSkills;
+    if (options.skill && options.skill.length > 0) {
+      selectedSkills = skills.filter(
+        (s) => options.skill.some(
+          (name) => s.name.toLowerCase() === name.toLowerCase() || getSkillDisplayName(s).toLowerCase() === name.toLowerCase()
+        )
+      );
+      if (selectedSkills.length === 0) {
+        p.log.error(`No matching skills found for: ${options.skill.join(", ")}`);
+        p.log.info("Available skills:");
+        for (const s of skills) {
+          p.log.message(`  - ${getSkillDisplayName(s)}`);
+        }
+        await cleanup(tempDir);
+        process.exit(1);
+      }
+      p.log.info(
+        `Selected ${selectedSkills.length} skill${selectedSkills.length !== 1 ? "s" : ""}: ${selectedSkills.map((s) => chalk.cyan(getSkillDisplayName(s))).join(", ")}`
+      );
+    } else if (skills.length === 1) {
+      selectedSkills = skills;
+      const firstSkill = skills[0];
+      p.log.info(`Skill: ${chalk.cyan(getSkillDisplayName(firstSkill))}`);
+      p.log.message(chalk.dim(firstSkill.description));
+    } else if (options.yes) {
+      selectedSkills = skills;
+      p.log.info(`Installing all ${skills.length} skills`);
+    } else {
+      const skillChoices = skills.map((s) => ({
+        value: s,
+        label: getSkillDisplayName(s),
+        hint: s.description.length > 60 ? `${s.description.slice(0, 57)}...` : s.description
+      }));
+      const selected = await p.multiselect({
+        message: "Select skills to install",
+        options: skillChoices,
+        required: true
+      });
+      if (p.isCancel(selected)) {
+        p.cancel("Installation cancelled");
+        await cleanup(tempDir);
+        process.exit(0);
+      }
+      selectedSkills = selected;
+    }
+    let targetAgents;
+    const validAgents = Object.keys(agents);
+    if (options.agent && options.agent.length > 0) {
+      const invalidAgents = options.agent.filter((a) => !validAgents.includes(a));
+      if (invalidAgents.length > 0) {
+        p.log.error(`Invalid agents: ${invalidAgents.join(", ")}`);
+        p.log.info(`Valid agents: ${validAgents.join(", ")}`);
+        await cleanup(tempDir);
+        process.exit(1);
+      }
+      targetAgents = options.agent;
+    } else {
+      spinner2.start("Detecting installed agents...");
+      const installedAgents = await detectInstalledAgents();
+      spinner2.stop(
+        `Detected ${installedAgents.length} agent${installedAgents.length !== 1 ? "s" : ""}`
+      );
+      if (installedAgents.length === 0) {
+        if (options.yes) {
+          targetAgents = validAgents;
+          p.log.info("Installing to all agents (none detected)");
+        } else {
+          p.log.warn("No coding agents detected. You can still install skills.");
+          const allAgentChoices = Object.entries(agents).map(([key, config]) => ({
+            value: key,
+            label: config.displayName
+          }));
+          const selected = await p.multiselect({
+            message: "Select agents to install skills to",
+            options: allAgentChoices,
+            required: true
+          });
+          if (p.isCancel(selected)) {
+            p.cancel("Installation cancelled");
+            await cleanup(tempDir);
+            process.exit(0);
+          }
+          targetAgents = selected;
+        }
+      } else if (installedAgents.length === 1 || options.yes) {
+        targetAgents = installedAgents;
+        if (installedAgents.length === 1) {
+          const firstAgent = installedAgents[0];
+          p.log.info(`Installing to: ${chalk.cyan(agents[firstAgent].displayName)}`);
+        } else {
+          p.log.info(
+            `Installing to: ${installedAgents.map((a) => chalk.cyan(agents[a].displayName)).join(", ")}`
+          );
+        }
+      } else {
+        const agentChoices = installedAgents.map((a) => ({
+          value: a,
+          label: agents[a].displayName,
+          hint: `${options.global ? agents[a].globalSkillsDir : agents[a].skillsDir}`
+        }));
+        const selected = await p.multiselect({
+          message: "Select agents to install skills to",
+          options: agentChoices,
+          required: true,
+          initialValues: installedAgents
+        });
+        if (p.isCancel(selected)) {
+          p.cancel("Installation cancelled");
+          await cleanup(tempDir);
+          process.exit(0);
+        }
+        targetAgents = selected;
+      }
+    }
+    let installGlobally = options.global ?? false;
+    if (options.global === void 0 && !options.yes) {
+      const scope = await p.select({
+        message: "Installation scope",
+        options: [
+          {
+            value: false,
+            label: "Project",
+            hint: "Install in current directory (committed with your project)"
+          },
+          {
+            value: true,
+            label: "Global",
+            hint: "Install in home directory (available across all projects)"
+          }
+        ]
+      });
+      if (p.isCancel(scope)) {
+        p.cancel("Installation cancelled");
+        await cleanup(tempDir);
+        process.exit(0);
+      }
+      installGlobally = scope;
+    }
+    console.log();
+    p.log.step(chalk.bold("Installation Summary"));
+    for (const skill of selectedSkills) {
+      p.log.message(`  ${chalk.cyan(getSkillDisplayName(skill))}`);
+      for (const agent of targetAgents) {
+        const path = getInstallPath(skill.name, agent, { global: installGlobally });
+        const installed = await isSkillInstalled(skill.name, agent, { global: installGlobally });
+        const status = installed ? chalk.yellow(" (will overwrite)") : "";
+        p.log.message(
+          `    ${chalk.dim("\u2192")} ${agents[agent].displayName}: ${chalk.dim(path)}${status}`
+        );
+      }
+    }
+    console.log();
+    if (!options.yes) {
+      const confirmed = await p.confirm({ message: "Proceed with installation?" });
+      if (p.isCancel(confirmed) || !confirmed) {
+        p.cancel("Installation cancelled");
+        await cleanup(tempDir);
+        process.exit(0);
+      }
+    }
+    spinner2.start("Installing skills...");
+    const results = [];
+    for (const skill of selectedSkills) {
+      for (const agent of targetAgents) {
+        const result = await installSkillForAgent(skill, agent, { global: installGlobally });
+        results.push({
+          skill: getSkillDisplayName(skill),
+          agent: agents[agent].displayName,
+          ...result
+        });
+      }
+    }
+    spinner2.stop("Installation complete");
+    console.log();
+    const successful = results.filter((r) => r.success);
+    const failed = results.filter((r) => !r.success);
+    if (successful.length > 0) {
+      p.log.success(
+        chalk.green(
+          `Successfully installed ${successful.length} skill${successful.length !== 1 ? "s" : ""}`
+        )
+      );
+      for (const r of successful) {
+        p.log.message(`  ${chalk.green("\u2713")} ${r.skill} \u2192 ${r.agent}`);
+        p.log.message(`    ${chalk.dim(r.path)}`);
+      }
+    }
+    if (failed.length > 0) {
+      console.log();
+      p.log.error(
+        chalk.red(`Failed to install ${failed.length} skill${failed.length !== 1 ? "s" : ""}`)
+      );
+      for (const r of failed) {
+        p.log.message(`  ${chalk.red("\u2717")} ${r.skill} \u2192 ${r.agent}`);
+        p.log.message(`    ${chalk.dim(r.error)}`);
+      }
+    }
+    console.log();
+    p.outro(chalk.green("Done!"));
+  } catch (error) {
+    p.log.error(error instanceof Error ? error.message : "Unknown error occurred");
+    p.outro(chalk.red("Installation failed"));
+    process.exit(1);
+  } finally {
+    await cleanup(tempDir);
+  }
+}
+async function cleanup(tempDir) {
+  if (tempDir) {
+    try {
+      await cleanupTempDir(tempDir);
+    } catch {
+    }
+  }
+}

package/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "fetch-skill",
+  "version": "1.0.0",
+  "description": "Install agent skills onto coding agents (OpenCode, Claude Code, Codex, Cursor)",
+  "type": "module",
+  "bin": {
+    "fetch-skill": "dist/index.js"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --dts --clean",
+    "dev": "tsx src/index.ts",
+    "lint": "biome lint --write .",
+    "format": "biome format --write .",
+    "check": "biome check --write .",
+    "prepublishOnly": "npm run build",
+    "update-readme": "tsx scripts/update-readme.ts"
+  },
+  "keywords": [
+    "cli",
+    "skills",
+    "opencode",
+    "claude-code",
+    "codex",
+    "cursor",
+    "amp",
+    "antigravity",
+    "roo-code",
+    "ai-agents"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/shaneholloman/fetch-skill.git"
+  },
+  "homepage": "https://github.com/shaneholloman/fetch-skill#readme",
+  "bugs": {
+    "url": "https://github.com/shaneholloman/fetch-skill/issues"
+  },
+  "author": "Shane Holloman",
+  "license": "MIT",
+  "dependencies": {
+    "@clack/prompts": "^0.11.0",
+    "chalk": "^5.6.2",
+    "commander": "^14.0.2",
+    "gray-matter": "^4.0.3",
+    "simple-git": "^3.30.0"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "^2.3.11",
+    "@types/node": "^25.0.9",
+    "tsup": "^8.5.1",
+    "tsx": "^4.21.0",
+    "typescript": "^5.9.3"
+  },
+  "engines": {
+    "node": ">=22"
+  }
+}