⏳ This skill is pending AI review.

Scores will appear once the review pipeline completes.

v2.2.0

skills-manager-cli

jiweiyeah@jiweiyeah⭐ 1.1k stars· last commit 2mo ago· 35 open issues

>

Choose how to use this skill

You do not need every option. Choose the path your AI client supports. The stable page stays the same; versioned files are immutable.

1. Native installer

This listing has no registered native installer command. Use the complete package or source fallback below, depending on what your client supports.

Do not guess an installer command or replace an existing version without reviewing the diff.

2. Complete package recommended

Download the ZIP when available. It includes SKILL.md plus the references, security notes and version metadata.

No complete ProSkills package is published for this listing yet.

3. Prompt-only

Copy the prompt above when the agent can read the stable page or when you want to adopt the workflow without installing a skill.

Need only the instruction file?

Download SKILL.md only if your client requires a single file. The complete ZIP is safer for a full installation because it preserves the references and release context.

No path installs or executes anything by itself. Your agent still needs access to the project files. Before updating, compare the installed version and review the diff.

—/10

// RATINGS

⭐GitHub Stars
⭐⭐⭐⭐⭐ 1.1k on GitHubGitHub ↗

Very popular

🟢ProSkills Score
—
📍

Not yet listed on ClawHub or SkillsMP

// README

Skills Manager

A unified desktop application for managing AI coding assistant skills. Seamlessly organize, sync, and share skills for Claude Code, Codex, Opencode and other AI tools.

Version Downloads Platform Tech

Website · 中文说明

🤝 Sponsors

Y-API provides a unified API for models from DeepSeek, Qwen, GLM, Kimi, OpenAI, and more.

  • Easy integration: OpenAI-compatible, so you can keep using your existing OpenAI SDK and access multiple models with one API key.
  • Flexible billing: Pay per token, with no monthly fee or minimum spend.
  • Easy to try: Signup credits let you get started without a credit card.

📖 Introduction

Skills Manager is a modern desktop application designed to solve the fragmentation of AI assistant skills configurations. Instead of managing skills and prompts separately for different tools, Skills Manager provides a central hub.

It uses a powerful symlink synchronization mechanism, allowing you to write a skill once and instantly use it across 32 supported AI tools including Claude Code, Codex, Cursor, Gemini CLI, Windsurf, Trae, and more.

✨ Key Features

  • 🎯 Unified Management: Centralize all your AI skills in one secure location.
  • 🔄 Smart Synchronization: Automatic symlink management ensures your tools always have the latest version of your skills without file duplication.
  • 🎛️ Granular Control: Enable or disable specific skills for individual tools without deleting the original files.
  • 🛒 Marketplace: Browse, install, and share community-contributed skills directly within the app.
  • 🌐 AI Translation: Translate skill names, descriptions, and content into your preferred language using LLM.
  • ⌨️ Command Palette: Quick navigation and actions via ⌘K / Ctrl+K.
  • 🌍 Bilingual UI: Full English and Chinese interface support.
  • ⚡ High Performance: Built with Rust and Tauri 2.0 for a lightweight, blazing-fast experience.
  • 🛡️ Cross-Platform: Native support for macOS, Windows, and Linux.
  • 🔌 Multi-Tool Support: Out-of-the-box support for 32 AI tools (Claude Code, Codex, Cursor, Gemini CLI, Windsurf, Trae, Cline, Augment, Goose, and many more), extensible via custom tools.
  • 🧩 Custom Tools: Add your own tools with custom paths and optional icons.
  • 🎨 Modern UI: Beautiful Raycast-style interface built with React 19, Tailwind CSS v4, and Radix UI.

📸 Screenshots

📥 Download

Get the build for your platform from the official website, which detects your OS and architecture automatically, or pick a file yourself on the Releases Page.

OSInstaller Type
macOS.dmg — separate builds for Apple Silicon (aarch64) and Intel (x64)
Windows.msi / .exe
Linux.deb / .AppImage / .rpm

Homebrew (macOS)

brew tap jiweiyeah/tap
brew install --cask jiweiyeah/tap/skills-manager

The cask picks the right build for your CPU automatically, and brew upgrade keeps it current.

Use the full jiweiyeah/tap/skills-manager path: Homebrew's official cask repository contains an unrelated cask that happens to share the skills-manager token, and the official tap wins on a bare name.

The app is ad-hoc signed but not notarized by Apple, so the cask strips the quarantine attribute on install — see the tap README for what that means and how to opt out.

🪟 Windows Notes

You do not need Administrator rights. When a skill is enabled for a tool, Skills Manager tries three strategies in order:

  1. Directory symlink — used when Developer Mode is enabled (or when the app happens to run elevated).
  2. Directory junction (mklink /J) — the normal path on a standard account. It needs no special permission.
  3. Tracked copy — if junctions are blocked as well, the folder is copied and its source path is recorded in .skills-manager-source.json, so the copy stays traceable and can still be disabled from the app.

A standard, non-elevated Windows account is enough for all three.

If a tool is not detected, elevation will not help either: the tool's own config directory has to exist on this machine. Check the tool compatibility matrix for the exact path each tool reads, or add it manually as a custom tool.

🚀 Getting Started

  1. Install: Run the installer for your platform.
  2. Setup: On first launch, the app will guide you to select your skills storage directory.
  3. Sync: The app automatically detects installed AI tools (like Claude Code) and links your skills.

⌨️ CLI (skm)

A companion command-line tool ships with every release for terminal-first workflows: SSH/headless machines, dotfiles setup scripts, and quick status checks. It reads and writes the same config and symlinks as the desktop app, so they can be used interchangeably.

Download skm-<target>.tar.gz (.zip on Windows) from the Releases Page, extract it, and put the binary on your PATH.

skm init                          # first-run setup without the GUI (writes config, detects tools)
skm adopt [--dry-run] [--yes]     # move skills already in tool dirs into the hub and relink them
skm list [--tool <id>] [--json]   # list skills and their per-tool link status
skm enable <skill> --for <tool>   # create the symlink (e.g. skm enable ab-testing --for claude)
skm disable <skill> --for <tool>  # remove the symlink
skm doctor [--json]               # detect installed tools + report sync issues
skm fix --yes                     # repair sync issues found by doctor

Both <skill> and <tool> accept a unique prefix (claude matches claude-code). Run skm <command> --help for details. The GUI is optional: skm init + skm adopt give a fully terminal-only workflow (e.g. on headless servers).

Installing the CLI (Settings → Command Line Tool, or skm init) also copies the skills-manager-cli companion skill into the hub and enables it for every currently detected tool, so other agents can drive skm without guessing flags. It covers --json contracts, dry-run vs apply, and which commands skm does not implement.

The same companion skill is published to ClawHub automatically on every version bump, so agents that pull skills from the marketplace instead of the app always get instructions matching the current skm. The release job runs npm run publish:skill; it queries ClawHub first and only uploads when the local version is strictly newer, so re-runs are no-ops. Use npm run publish:skill -- --dry-run to validate the file list and version gate without uploading.

❗ Linux Troubleshooting

If you encounter a blank white screen when launching the .AppImage on Linux (especially in virtual machines like VMware/VirtualBox), it is likely a WebKitGTK hardware acceleration issue.

Please run the application from the terminal with the following command:

WEBKIT_DISABLE_COMPOSITING_MODE=1 ./Skills-Manager_<version>_amd64.AppImage

🛠️ Technology Stack

Designed for developers who c

// HOW IT'S BUILT

// FILES

4 files shipped with this skill. Inline text is the catalog copy. The upstream link is the source repository.

  • skills/skills-manager-cli/SKILL.md11 KB13507a8f4058upstream ↗
    ---
    name: skills-manager-cli
    description: >
      Drive the Skills Manager CLI (`skm`) to initialize the hub, adopt unmanaged
      skills, list/enable/disable skills per AI tool, and doctor/fix symlink sync.
      Use whenever the user or an agent needs to manage skills from a terminal,
      SSH session, CI job, or headless machine; when a skill is missing in Claude
      Code, Codex, Cursor, Gemini, OpenCode, or any other supported tool; when
      asked to run skm / Skills Manager CLI; or when setting up Skills Manager
      without the GUI. Do not use for `npx skills` / skills.sh search (different
      CLI), for writing SKILL.md content (skill-creator), or for marketplace
      browse/install (not in skm).
    ---
    
    # Skills Manager CLI (`skm`)
    
    **New here?** This skill drives `skm`, the command-line tool that ships with
    [**Skills Manager**](https://skillsmanager.freeourdays.com) — a desktop app
    (macOS / Windows / Linux) that installs one copy of a skill into a central hub
    and symlinks it into every AI coding tool you use (Claude Code, Codex, Cursor,
    Gemini, and ~30 more), so you write a skill once and it shows up everywhere.
    
    If you found this skill on ClawHub but don't have Skills Manager yet, that is
    the missing piece: `skm` is not a standalone binary you `npm install`. Get it
    by installing the app from the [official website](https://skillsmanager.freeourdays.com/?ref=clawhub#download)
    (then Settings → Command Line Tool, or run `skm init`), or grab a
    `skm-<target>.tar.gz` / `.zip` from the
    [GitHub Releases page](https://github.com/jiweiyeah/skills-manager/releases).
    Source and docs: <https://github.com/jiweiyeah/skills-manager>.
    
    `skm` is the terminal front-end of Skills Manager. It reads and writes the
    same `~/.skills-manager/config.json` and the same hub/tool symlinks as the
    desktop app, so GUI and CLI are interchangeable.
    
    It does **not** create, edit, search, translate, tag, or marketplace-install
    skills. Those stay in the GUI (or you write files into the hub yourself, then
    `skm enable`).
    
    ## Preconditions
    
    1. Resolve the binary. Prefer `skm` on `PATH`. If missing, say so and point
       at install: the [Skills Manager app](https://skillsmanager.freeourdays.com/?ref=clawhub#download)
       (Settings → Command Line Tool), or a release archive
       `skm-<target>.tar.gz` / `.zip` from
       [GitHub Releases](https://github.com/jiweiyeah/skills-manager/releases).
       Do not fall back to `npx skills` — that is a different, unrelated CLI.
    2. Confirm with `skm --version`. A stale binary from an older app release
       should be updated from Settings or a matching release.
    3. Every command except `init` requires an initialized config. If stderr
       says so, run `skm init --json` once — it is idempotent and will not
       clobber an existing config. `skm init` and Settings → Install CLI also
       copy this companion skill into the hub and enable it for every currently
       active tool, so you usually do not need to install it by hand.
    
    Hub path is fixed at `~/.skills-manager/skills` (`%USERPROFILE%\.skills-manager\skills`
    on Windows). `save()` always rewrites `skills_dir` to that default; there is
    no supported way to pick another hub from the CLI.
    
    ## Agent conventions
    
    These exist because `skm` is designed to be called by agents, not just humans.
    
    - Prefer `--json` on `init`, `list`, `doctor`, `fix`, and `adopt` (apply).
      Data is one JSON document on stdout. Errors go to stderr as
      `{"error":"..."}` when the command was in JSON mode, otherwise
      `error: ...`. A command can print a result on stdout and still exit 1
      (`fix` with failed repairs) — parse stdout, then trust the exit code.
    - `enable` / `disable` have no `--json`. Success is a one-line
      `enabled '<id>' for '<tool>'` (or `disabled`). Failure is `error: ...`
      on stderr, exit 1.
    - Never wait on a TTY prompt. `adopt` without `--yes` and without `--json`
      blocks on `[y/N]`. Pass `--yes` when applying. `--json` also skips the
      prompt (and therefore applies) — still pass `--yes` so the intent is
      obvious in the command line.
    - `skm adopt --json --dry-run` is not a machine-readable preview: if
      candidates exist it prints nothing. Preview with `skm adopt --dry-run`
      (human text), then apply with `skm adopt --yes --json`.
    - `doctor --json` exits 0 even when there are issues. Gate on
      `.issues_count`, not the exit code.
    - `fix` without `--yes` does not repair. JSON then looks like
      `{"applied": false, "issues_found": N, ...}`. Apply with `skm fix --yes --json`.
    - Write commands (`init`, `adopt`, `enable`, `disable`, `fix --yes`) take
      an advisory lock on `config.json` and fail fast if another `skm` is
      mid-write. Retry once. The desktop app does not take this lock.
    - Do not enable a skill for every detected tool unless the user asked.
      Pick the tool they named, or the host agent (see [Which tool](#which-tool)).
    
    JSON shapes, exit codes, and the dry-run/apply matrix live in
    `references/json.md`. Read that before parsing output or writing a script.
    
    ## Command map
    
    | Intent | Command |
    | --- | --- |
    | First-run / is it initialized? | `skm init --json` |
    | What skills exist, and where are they linked? | `skm list --json` |
    | Same, one tool only | `skm list --tool <id> --json` |
    | Turn a hub skill on for a tool | `skm enable <skill> --for <tool>` |
    | Turn it off (remove the link, keep the hub copy) | `skm disable <skill> --for <tool>` |
    | Which tools are installed, any broken links? | `skm doctor --json` |
    | Repair what doctor reported | `skm fix --yes --json` |
    | Preview leftover real dirs in tool skill folders | `skm adopt --dry-run` |
    | Move those dirs into the hub and relink | `skm adopt --yes --json` |
    
    `<skill>` and `<tool>` accept an exact id, an exact `instance_id`, or a
    **unique** prefix (`claude` → `claude-code`). Ambiguous prefixes error and
    list the matches — do not guess, rerun with a longer token. Exact tool id
    wins before prefix (`trae` is Trae, not Trae CN). Full ids and collision
    notes: `references/tools.md`.
    
    ## Workflows
    
    ### First-run on a machine with no GUI
    
    ```bash
    command -v skm
    skm init --json
    skm adopt --dry-run
    skm adopt --yes --json
    skm list --json
    skm doctor --json
    ```
    
    `init` on an already-initialized config returns
    `{"already_initialized": true, ...}` and does nothing else. If
    `config.json` exists but cannot be parsed, `init` refuses to overwrite it
    — move or fix the file, then retry.
    
    ### Make an existing hub skill available to a tool
    
    ```bash
    skm list --json                          # find id / instance_id
    skm enable <skill> --for <tool>
    skm list --tool <tool> --json            # confirm enabled_for
    ```
    
    Enabled state is derived from the link on disk, not stored as a separate
    flag. `enable` creates the symlink (Windows: symlink → junction → tracked
    copy). `disable` removes that link; the hub copy stays.
    
    If the same skill id exists in both global and the active project, a bare
    id is ambiguous. Use the `instance_id` from `list`: `global:<id>` or
    `project:<project_id>:<id>`.
    
    ### Add a brand-new skill (CLI cannot scaffold it)
    
    1. Write `~/.skills-manager/skills/<id>/SKILL.md` with YAML `name` +
       `description`. A directory is a skill if it contains `SKILL.md`,
       `skill.md`, or `meta.json`.
    2. `skm enable <id> --for <tool>`
    3. `skm list --tool <tool> --json` to confirm.
    
    Do not copy the folder into `~/.claude/skills` (or any other tool dir)
    yourself — that bypasses the hub and `adopt` will later see it as an
    unmanaged real directory.
    
    ### Adopt skills that already live in a tool directory
    
    `adopt` looks at **active** tools (enabled + detected) for real
    directories that are not symlinks/junctions and not hidden. It **moves**
    each one into the hub, then puts a link back at the original path.
    
    - Duplicate hub names are skipped and left in place (contents are not
      merged — they may differ).
    - Preview first (`--dry-run`), then apply (`--yes --json`).
    - After apply, `list` should show the new ids as enabled for the source
      tool.
    
    ### Diagnose "the skill is not showing up in Claude / Codex / …"
    
    ```bash
    skm doctor --json
    skm list --tool <tool> --json
    ```
    
    Read the results in this order:
    
    1. Binary missing or not on `PATH` → install, reopen the shell.
    2. `config_initialized` false → `skm init --json`.
    3. Tool `detected: false` → the tool's config dir is not on this machine.
       CLI does not re-detect existing tools on every call; a tool installed
       after `init` may still show `not installed` until the GUI redetects or
       the config is updated. Do not try to invent a custom tool from `skm`.
    4. Tool `enabled: false` → CLI cannot flip that flag. Use the GUI Tools
       page, or say so.
    5. Skill absent from `list` → it is not in the hub (and not in the active
       project). Write it into the hub or `adopt`.
    6. Skill present but not in `enabled_for` → `skm enable <skill> --for <tool>`.
    7. `link_issues` > 0 or `issues_count` > 0 → `skm fix --yes --json`. If
       `failed_count` > 0, report the `failed[].message` values; do not loop
       `fix`.
    8. A wrong-target or deleted link is treated as **disabled**, not as a
       doctor issue. Re-`enable` to recreate the link over the tampered path.
    
    `fix` only repairs what `should_report_sync_issue` flags. It will not
    delete a real (non-link) directory sitting in a tool's skills folder —
    that is what `adopt` is for.
    
    ## Which tool
    
    If the user named a tool, resolve it via `references/tools.md` and pass
    `--for <id>`. If they did not:
    
    | Host | `--for` |
    | --- | --- |
    | Claude Code | `claude-code` |
    | Codex | `codex` |
    | Cursor | `cursor` |
    | Gemini CLI | `gemini` |
    | OpenCode | `opencode` |
    | Unsure | `skm doctor --json`, pick `detected && enabled` |
    
    Prefix shortcuts that are unique today: `claude` → `claude-code`. Do not
    use `trae` when the user said Trae CN (`trae-cn`), or `qoder` when they
    said QoderWork CN (`qoderwork-cn`).
    
    ## Out of scope (do not fake these with `skm`)
    
    | Need | What to do instead |
    | --- | --- |
    | Search / install from skills.sh | `npx skills` / find-skills, or the GUI Marketplace |
    | Author SKILL.md | Write the file; this skill only covers linking it |
    | Tags, notes, favorites, translation | GUI |
    | Add/remove a custom tool, bind a project | GUI |
    | Enable or disable a tool itself | GUI Tools page |
    | Change the hub directory | Not supported; always `~/.skills-manager/skills` |
    | Marketplace publish / ClawHub | GUI |
    
    ## Install locations (when `skm` is missing)
    
    The desktop app copies a bundled binary:
    
    - macOS / Linux: `/usr/local/bin/skm` if writable, else the first of
      `~/bin`, `~/.local/bin` that is already on `PATH`, else `~/.local/bin/skm`
      (then the folder may need to be added to `PATH`)
    - Windows: next to the app executable (`skm.exe`)
    
    Standalone: GitHub Releases `skm-<target>.tar.gz` (`.zip` on Windows),
    extract, put on `PATH`.
    
  • skills/skills-manager-cli/references/json.md6.5 KB0fa8decc58d2upstream ↗
    # `skm` JSON contracts
    
    Read this before parsing stdout or writing a script. Human-mode output is
    not a stable API; `--json` is.
    
    ## Global rules
    
    - Success: one JSON object on stdout, trailing newline.
    - Failure: JSON `{"error":"<anyhow message>"}` on **stderr** when the
      command was invoked with `--json`; otherwise `error: ...` on stderr.
      Exit code 1.
    - `enable` / `disable` never take `--json`. Their success line is not JSON.
    - `fix --yes --json` can print a result object on stdout **and** still
      exit 1 when `failed` is non-empty. Parse stdout, then check the exit
      code (or `failed_count`).
    - `doctor --json` always exits 0. Gate on `issues_count`.
    - `init --json` always exits 0 on the happy path, including
      `already_initialized: true`.
    
    ## `skm init --json`
    
    ```json
    {
      "already_initialized": false,
      "skills_dir": "/Users/you/.skills-manager/skills",
      "detected_tools": ["claude-code", "codex"],
      "cli_skill": {
        "id": "skills-manager-cli",
        "path": "/Users/you/.skills-manager/skills/skills-manager-cli",
        "enabled_for": ["claude-code", "codex"],
        "failed": []
      }
    }
    ```
    
    `already_initialized: true` still writes/refreshes the companion skill and
    enables it for currently active tools — it is not a total no-op. `detected_tools`
    is the list of builtin tool ids whose `detected` flag is true in the
    loaded config (not a live re-detect of every tool). `cli_skill.failed` lists
    tools that could not be linked; `cli_skill.error` is set only if the hub
    copy itself could not be written.
    
    Hard errors (exit 1):
    
    - `config.json` exists, is non-empty, and cannot be parsed. Message tells
      the user to move or fix it.
    - Another `skm` holds the init lock.
    
    ## `skm list --json`
    
    ```json
    {
      "skills": [
        {
          "instance_id": "global:ab-testing",
          "id": "ab-testing",
          "name": "AB Testing",
          "scope": "global",
          "enabled_for": ["claude-code", "codex"],
          "link_issues": 0
        }
      ]
    }
    ```
    
    - `scope` is `"global"` or `"project"`. Project rows only appear for the
      **active** project binding.
    - `enabled_for` is the subset of **active** tools (enabled + detected)
      that currently have a valid link. `--tool <id>` restricts both
      `enabled_for` and `link_issues` to that one tool.
    - `link_issues` counts enabled-but-not-`Valid` links for the selected
      tools. Zero does not mean doctor is clean for disabled skills.
    - Empty hub: `{"skills":[]}` in JSON; human mode prints
      `no skills found in the configured skills directory`.
    
    ## `skm doctor --json`
    
    ```json
    {
      "config_initialized": true,
      "tools": [
        {
          "id": "claude-code",
          "name": "Claude Code",
          "detected": true,
          "enabled": true
        }
      ],
      "issues_count": 1,
      "issues": [
        {
          "skill": "global:ab-testing",
          "skill_id": "ab-testing",
          "tool": "claude-code",
          "expected": "enabled",
          "status": "Broken"
        }
      ]
    }
    ```
    
    - `tools` includes builtins and custom tools from config, including ones
      that are not detected.
    - `status` is `Debug` of `LinkStatus`: `Valid`, `Broken`, `WrongTarget`,
      `NotALink`, `Missing`.
    - `issues` is only the rows `should_report_sync_issue` would flag.
      Notably **not** reported: disabled + `Missing`, disabled +
      `WrongTarget`, disabled + `NotALink` (a real directory we did not
      create — never auto-deleted).
    
    ## `skm fix --json`
    
    Without `--yes` (report only):
    
    ```json
    {
      "applied": false,
      "issues_found": 2,
      "hint": "re-run with --yes to apply fixes"
    }
    ```
    
    With `--yes` and nothing to do:
    
    ```json
    {
      "fixed": [],
      "failed": [],
      "issues_found": 0,
      "failed_count": 0
    }
    ```
    
    With `--yes` after applying:
    
    ```json
    {
      "applied": true,
      "fixed": [
        {
          "skill": "global:ab-testing",
          "tool": "claude-code",
          "message": "Enabled successfully"
        }
      ],
      "failed": [
        {
          "skill": "global:other",
          "tool": "codex",
          "message": "..."
        }
      ],
      "issues_found": 2,
      "failed_count": 1
    }
    ```
    
    Do not read `issues_count` here — that key is doctor's "problems
    detected". On `fix`, use `issues_found` and `failed_count`. Non-empty
    `failed` → exit 1, plus `{"error":"N fix(es) could not be applied"}` on
    stderr.
    
    ## `skm adopt --json`
    
    Only emitted on the apply path (`--yes`, or `--json` without `--dry-run`).
    `--dry-run` never prints this object.
    
    ```json
    {
      "adopted": ["legacy-a"],
      "skipped": [
        {
          "path": "/Users/you/.claude/skills/legacy-b",
          "reason": "'legacy-b' is already in the hub — left in place"
        }
      ]
    }
    ```
    
    No candidates: `{"adopted":[],"skipped":[]}`.
    
    `--json` without `--yes` still applies (the confirmation prompt is
    skipped). Always pass `--yes` when applying so the command line records
    intent.
    
    ## `skm enable` / `skm disable`
    
    No JSON. Success:
    
    ```
    enabled 'ab-testing' for 'claude-code'
    disabled 'ab-testing' for 'claude-code'
    ```
    
    Typical stderr errors:
    
    - `Skills Manager is not initialized yet.`
    - `skill not found: '…'\nrun 'skm list' to see available skills`
    - `ambiguous skill reference '…', matches multiple skills:`
    - `tool not found: '…'\nrun 'skm doctor' to see detected tools`
    - `ambiguous tool reference '…', matches multiple tools:`
    - `Tool is disabled: <id>`
    - `Cannot disable a project Skill stored directly in the tool directory: …`
    - `another skm process is modifying the config; try again later`
    
    ## Dry-run / apply matrix (`adopt`, `fix`)
    
    | Command | Mutates? | JSON on stdout? |
    | --- | --- | --- |
    | `adopt --dry-run` | no | no (human candidate list, or "nothing to adopt") |
    | `adopt --json --dry-run` | no | **no** if candidates exist (prints the list only in human mode, then returns). Empty-candidate case still prints `{"adopted":[],"skipped":[]}` because that branch runs before `--dry-run`. |
    | `adopt --yes --json` | yes | yes |
    | `adopt --json` (no `--yes`) | **yes** (prompt skipped) | yes |
    | `fix` / `fix --json` | no | yes if `--json` (`applied: false`) |
    | `fix --yes --json` | yes | yes |
    
    ## Resolution
    
    Skill lookup (`enable` / `disable`):
    
    1. Exact `instance_id` (`global:ab-testing`, `project:<pid>:ab-testing`).
    2. Unique `id` prefix against scanned scoped skills (global + active project).
    3. Zero matches → not found. Two or more → ambiguous, lists `id`s.
    
    Tool lookup:
    
    1. Exact id against `config.collect_tool_configs()` (builtins + custom).
    2. Unique prefix. Exact match wins, so `trae` is Trae even though
       `trae-cn` shares the prefix.
    
    ## Concurrency
    
    Write commands lock `~/.skills-manager/config.json` with
    `try_lock_exclusive` (fail fast). Read-only `list`, `doctor`, and `fix`
    without `--yes` take no lock. The GUI does not participate — last writer
    wins against the app.
    
  • skills/skills-manager-cli/references/tools.md3.4 KB555fbcb77415upstream ↗
    # Tool ids for `skm --for` / `skm list --tool`
    
    Pass these ids (or a unique prefix) to `--for` and `--tool`. Exact id wins
    before prefix, so `trae` is Trae, not Trae CN.
    
    `detected` means the tool's config directory exists on this machine.
    `skm init` records that snapshot; later `skm` loads do not re-run full
    detection for tools already in config. A tool installed after init may
    still show `not installed` until the GUI redetects.
    
    Project-local skills (workspace copies) are only defined for the tools
    that have a `project_skills_dir` below. Other tools are global-hub only.
    
    | id | Name | Home config dir | CLI | Project skills dir |
    | --- | --- | --- | --- | --- |
    | `claude-code` | Claude Code | `.claude` | `claude` | `.claude/skills` |
    | `codex` | Codex | `.codex` | `codex` | `.agents/skills` |
    | `deepseek-harness` | DeepSeek Harness | `.dsh` | `dsh` | `.dsh/skills` |
    | `codebuddy` | CodeBuddy | `.codebuddy` | `codebuddy` | — |
    | `opencode` | OpenCode | `.config/opencode` (alt `.opencode`) | `opencode` | `.opencode/skills` |
    | `cursor` | Cursor | `.cursor` | `cursor` | `.cursor/skills` |
    | `gemini` | Gemini CLI | `.gemini` | `gemini` | `.gemini/skills` |
    | `antigravity` | Antigravity | `.antigravity` | `antigravity` | — |
    | `windsurf` | Windsurf | `.windsurf` | `windsurf` | — |
    | `trae` | Trae | `.trae` | `trae` | — |
    | `droid` | Droid | `.factory` (alt `.droid`) | `droid` | — |
    | `augment` | Augment | `.augment` | `augment` | — |
    | `openclaw` | OpenClaw | `.openclaw` | `openclaw` | — |
    | `cline` | Cline | `.cline` | `cline` | — |
    | `vercel-skills` | Vercel Skills | `.agents` (alt `.vercel`, `.vercel-skills`) | `vercel` | `.agents/skills` |
    | `commandcode` | CommandCode | `.commandcode` | `commandcode` | — |
    | `continue` | Continue | `.continue` | `continue` | — |
    | `crush` | Crush | `.config/crush` (alt `.crush`) | `crush` | — |
    | `goose` | Goose | `.config/goose` (alt `.goose`) | `goose` | — |
    | `iflow` | iFlow | `.iflow` | `iflow` | — |
    | `junie` | Junie | `.junie` | `junie` | — |
    | `kilo-code` | Kilo Code | `.kilocode` | `kilo` | — |
    | `kiro` | Kiro | `.kiro` | `kiro` | — |
    | `qoder` | Qoder | `.qoder` | `qoder` | — |
    | `qwen-code` | Qwen Code | `.qwen` | `qwen` | — |
    | `roo-code` | Roo Code | `.roo` | `roo` | — |
    | `zencoder` | Zencoder | `.zencoder` | `zencoder` | — |
    | `pi` | Pi | `.pi/agent` | `pi` | — |
    | `trae-cn` | Trae CN | `.trae-cn` | `trae` | — |
    | `hermes` | Hermes | `.hermes` | `hermes` | — |
    | `workbuddy` | WorkBuddy | `.workbuddy` | `workbuddy` | — |
    | `qoderwork-cn` | QoderWork CN | `.qoderworkcn` | `qoderworkcn` | — |
    
    Custom tools from the GUI also appear in `skm doctor --json` / `skm list`
    under whatever id the user gave them. Prefix-match those the same way.
    
    ## Prefix collisions to avoid
    
    | Typed | Resolves to | Collision |
    | --- | --- | --- |
    | `trae` | `trae` (exact) | `trae-cn` exists; use `trae-cn` for Trae CN |
    | `qoder` | `qoder` (exact) | `qoderwork-cn` exists; use `qoderwork-cn` |
    | `claude` | `claude-code` | unique prefix |
    | `code` | ambiguous | `codebuddy`, `codex`, `commandcode` |
    
    When unsure, copy `id` from `skm doctor --json`.
    
    ## Windows linking
    
    `enable` tries, in order: directory symlink (Developer Mode or elevated) →
    directory junction (`mklink /J`, no admin) → tracked copy with
    `.skills-manager-source.json`. A standard account is enough. Elevation
    does not help a tool that is not detected — the tool's config directory
    still has to exist.
    
  • README.mdupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

Plain-text copy, no login: /skill-bundles/jiweiyeah-skills-manager-skills-skills-manager-cli.md

// REPO STATS

1.1k stars
35 open issues
Last commit: 2mo ago