meta-skills
Install or update Meta-Skills into Cursor, Claude, Hermes, or OpenClaw. Clone/pull this repo into ~/.meta-skills (shared library), auto-detect the tool via TERMINAL_ENV / CLAUDECODE, ask target + scop
SKILL.mdSKILL.md
GitHubMeta-Skills — the skill installer (Cursor / Claude / Hermes / OpenCode / OpenClaw)
This skill is the installer. It manages a single shared library and a single shared Python/npm environment on the machine, then registers chosen skills into any tool. Nothing is re-cloned or re-installed per project.
Targets:
cursor,claude,hermes,opencode,openclaw.
Core idea — shared library, shared env
Heavy things live once under $META_SKILLS_HOME (default ~/.meta-skills); each
tool only gets the lightweight SKILL.md.
~/.meta-skills/ shared library root (this repo, or $META_SKILLS_HOME)
├── install.sh installer helper (fetch / pip init / npm init)
├── meta-skill-common/ shared Python package (import as ``common`` — SkillCred, …)
├── skills/<category>/…/<name>/ built-in skills (nested by domain; CLI + SKILL.md)
├── ext/<name>/ external skill repos, cloned ONCE
├── .venv/ shared Python venv — every python skill reuses it
└── .env optional machine-wide secrets (sourced by skills)
│ register = TO COPY slice + link to library SKILL.md; credentials next to it ↓
~/.cursor/skills/<name>/{SKILL.md,.env} (flat by skill basename; or ./.cursor/skills/<name>/)
Hybrid model: CLI code is shared under ~/.meta-skills/…; credentials
(.env / config.json / tokens) are per registered skill dir, resolved by
[meta-skill-common/skill_cred.py](meta-skill-common/skill_cred.py) via
SkillCred("<skill-name>", […filenames…]) and $CURRENT_SKILL_DIRECTORY.
Hybrid model — shared CLI, local secrets (common.skill_cred)
Do not put secrets only under the shared library skill tree (that would force one
account for every project). Do not copy the full skill tree into Cursor/Hermes for
Python CLIs that follow this pattern — register SKILL.md only (unless a skill
explicitly documents a full-tree exception).
| Layer | Location | Shared? |
|---|---|---|
| CLI / Python code | ~/.meta-skills/skills/<category>/…/<name>/ (or ext/<name>/) |
Yes |
| Shared helpers | ~/.meta-skills/meta-skill-common/ (pip-installed as common) |
Yes |
| Python deps | ~/.meta-skills/.venv |
Yes |
| Registered skill | $DEST/<name>/SKILL.md — TO COPY slice + library link |
Lightweight; body updates via git pull |
| Credentials | $DEST/<name>/ (.env, tokens, config.json, …) |
No — per workspace / profile |
Skill directory variable (CURRENT_SKILL_DIRECTORY) — must point at the directory
that contains the registered SKILL.md (where credentials live). Skills export it
in their Working directory section before running CLIs. SkillCred reads that env
(see meta-skill-common/skill_cred.py); if unset, it falls back to the process cwd.
Authoring a skill that uses it: start from [SKILL_TEMPLATE.md](SKILL_TEMPLATE.md) (or [META_SKILL_TEMPLATE.md](META_SKILL_TEMPLATE.md) for installer/hub skills that register multiple sub-skills); document provenance with [ORIGIN_TEMPLATE.md]
# Register (Cursor project = different account per repo)
mkdir -p ./.cursor/skills/my-skill
# copy SKILL.md AND substitute placeholders (see below)
cp ~/.meta-skills/skills/my-skill/.env.example ./.cursor/skills/my-skill/.env
# Run CLI from the shared library; credentials resolve via CURRENT_SKILL_DIRECTORY
cd ~/.meta-skills/skills/my-skill
~/.meta-skills/.venv/bin/python scripts/cli.py …
Copy-time placeholders (required)
Each built-in skill's library SKILL.md has a ### TO COPY … ##### END TO COPY
block (see [SKILL_TEMPLATE.md](SKILL_TEMPLATE.md)). Registration copies only
that slice into $DEST/<name>/SKILL.md, substitutes placeholders, then links
the canonical library file so git pull on ~/.meta-skills refreshes commands and
examples without re-registering.
Substitute in the copied slice:
IS_GLOBAL => {IS_GLOBAL} # TRUE if tool-global, else FALSE
TYPE_OF_AI_TOOLS => {TYPE_OF_AI_TOOLS} # CURSOR / HERMES / OPENCODE / OPENCLAW / CLAUDE
SKILL_PATH => {SKILL_PATH} # dir of the registered SKILL.md — see "SKILL_PATH value" below
{SKILL_PATH} value (portable across users)
| Install | {SKILL_PATH} becomes |
Example |
|---|---|---|
Project scope and $PWD is inside a git repo |
$(git rev-parse --show-toplevel)/<DEST relative to git root>/<name> (kept literal) |
$(git rev-parse --show-toplevel)/.claude/skills/godaddy |
| Global scope (root skill dirs, Hermes) or no git repo | absolute path of $DEST/<name> (hardcoded) |
/Users/you/.claude/skills/godaddy |
The $(git rev-parse --show-toplevel) text is not expanded at install time: the
Working directory block (the script that loads the env) evaluates it at run time, so
the committed SKILL.md works for every teammate, from any sub-folder. The same
$(…) syntax works in bash/zsh and PowerShell.
# project scope — compute the relative part once at install time
if GIT_ROOT=$(git rev-parse --show-toplevel 2>/dev/null) && [ "$SCOPE" = project ]; then
REL=$(cd "$DEST/<name>" && pwd -P); REL=${REL#"$(cd "$GIT_ROOT" && pwd -P)/"}
SKILL_PATH_VALUE='$(git rev-parse --show-toplevel)/'"$REL"
else
SKILL_PATH_VALUE=$(cd "$DEST/<name>" && pwd -P)
fi
Project scope inside git: also make sure secrets are ignored — append to the project
.gitignore (if missing) .<tool>/skills/*/.env plus any token files the skill uses
(e.g. google_token.json, .bw-appdata/).
These show up in the TO COPY Working directory block, in a bash/zsh and a PowerShell (Windows) variant — keep both when registering:
export CURRENT_SKILL_DIRECTORY="{SKILL_PATH}"
export IS_GLOBAL="{IS_GLOBAL}"
export TYPE_OF_AI_TOOLS="{TYPE_OF_AI_TOOLS}"
$env:CURRENT_SKILL_DIRECTORY = "{SKILL_PATH}"
$env:IS_GLOBAL = "{IS_GLOBAL}"
$env:TYPE_OF_AI_TOOLS = "{TYPE_OF_AI_TOOLS}"
Substitute so the registered slice has concrete values, for example:
# project scope (git) — portable
export CURRENT_SKILL_DIRECTORY="$(git rev-parse --show-toplevel)/.cursor/skills/google-workspace"
export IS_GLOBAL="FALSE"
export TYPE_OF_AI_TOOLS="CURSOR"
# global scope — hardcoded
export CURRENT_SKILL_DIRECTORY="/Users/you/.cursor/skills/google-workspace"
export IS_GLOBAL="TRUE"
Always set {SKILL_PATH} to the destination directory that contains the registered
SKILL.md (not the shared library path under ~/.meta-skills/skills/…).
After the slice, append a library pointer (use the real $SRC/SKILL.md path):
---
## Library reference
Full commands, examples, and prerequisites — read from the shared library (updates on `git pull`):
`~/.meta-skills/skills/<category>/…/<name>/SKILL.md`
Agents must read that library path for slash commands and detailed instructions. The registered file holds credentials context + placeholders only.
Meta-skills (meta-{domain}/)
Hub skills that install sub-skills do not use ### TO COPY and do not
copy library SKILL.md files. Registration writes a minimal stub per install
(meta + each chosen sub-skill) with:
CURRENT_SKILL_DIRECTORY(meta dir for credentials)- substituted
{IS_GLOBAL},{TYPE_OF_AI_TOOLS},{SKILL_PATH}/{META_SKILL_PATH} - a library reference to the canonical file under
~/.meta-skills/…
See [META_SKILL_TEMPLATE.md](META_SKILL_TEMPLATE.md) for stub templates. Only
copy .env.example → $DEST/meta-{domain}/.env (credentials stay local).
Exception: meta-skills (this installer) has no stub — register the full[SKILL.md](SKILL.md) global-only via [INSTALL_PROMPT.md](INSTALL_PROMPT.md).
Helper script — [install.sh](install.sh) (3 commands)
~/.meta-skills/install.sh has exactly three commands. They only manage the
shared cache/env — nothing per project:
./install.sh fetch <git-url> [name] # clone/pull → ~/.meta-skills/ext/<name>
./install.sh pip init [dir] # shared venv + install meta-skill-common + <dir> deps
./install.sh npm init [dir] # install <dir> node deps (shared skill dir)
Windows (PowerShell): same commands via ~/.meta-skills/install.ps1; the shared
interpreter is ~/.meta-skills/.venv/Scripts/python.exe (not .venv/bin/python).
- Registering a standard skill = extract
### TO COPYslice, substitute placeholders, prepend frontmatter, append library link to$SRC/SKILL.md. - Registering a meta-skill = write a stub + library link only (see
[META_SKILL_TEMPLATE.md](META_SKILL_TEMPLATE.md)); copy.env.examplefor credentials. - Dependencies are each skill's job. A skill calls
install.sh pip init ./install.sh npm init .from its own folder on first run — installed once into the shared venv (~/.meta-skills/.venv), reused across projects.
Targets & scopes
| Tool | Scope | Skills directory |
|---|---|---|
| cursor | global |
~/.cursor/skills/<name>/ |
| cursor | project |
./.cursor/skills/<name>/ |
| claude | global |
~/.claude/skills/<name>/ |
| claude | project |
./.claude/skills/<name>/ |
| hermes | all |
~/.hermes/skills/<name>/ |
| hermes | profile |
${HERMES_HOME}/skills/<name>/ |
| opencode | global |
${OPENCODE_CONFIG_DIR:-~/.config/opencode}/skills/<name>/ |
| opencode | project |
./.opencode/skills/<name>/ |
| openclaw | global |
~/.openclaw/skills/<name>/ (WIP) |
| openclaw | project |
./.openclaw/skills/<name>/ (WIP) |
Critical — ask the user first
Do not copy every skill blindly. After clone/pull, resolve the tool (auto-detect first), then ask in this order:
0) Auto-detect the tool
Detect from the env vars the running agent sets — not from the mere presence of
~/.cursor / ~/.claude (that only means a tool is installed, not that it is running).
Check in order:
$CLAUDECODEor$CLAUDE_CODE_ENTRYPOINTset → Claude Code.- Any env var whose name starts with
OPENCODE_→ OpenCode. The CLI setsOPENCODE_PID(andOPENCODE=1) for the process.OPENCODE_CONFIG_DIR, when set, is the global config root. $TERMINAL_ENVset (non-empty) → Hermes. Skip to the Hermes profile scope (step 2).$CURSOR_AGENTor$CURSOR_TRACE_IDset (fallback:$TERM_PROGRAM=vscode/cursor) → Cursor.- None matched / several → ask the tool question (step 1).
- OpenClaw is chosen explicitly (WIP).
1) Target tool (only if not auto-detected)
Install skills for Cursor, Claude, Hermes, OpenCode, and/or OpenClaw? (one or several)
2) Scope
- Cursor / Claude / OpenClaw → global (
~/.<tool>/skills) or this project (./.<tool>/skills). - OpenCode → global (
${OPENCODE_CONFIG_DIR:-~/.config/opencode}/skills) or this project (./.opencode/skills). Docs: opencode.ai/docs/skills. - Hermes → all profiles (
~/.hermes/skills) or this profile ($HERMES_HOME/skills; resolveHERMES_HOME, ask if unset).
3) Which skills
Ask for any of:
- built-in skills from Meta-Skills (nested under
skills/<category>/…/<name>/, catalog below), - an external git URL (any skill repo), or
- a local path to a skill folder.
Do not re-install meta-skills here — the installer itself is global only
(see [INSTALL_PROMPT.md](INSTALL_PROMPT.md)). When registering catalog skills, copy
only the skills the user asked for. Use the catalog Folder as SRC (not a flat skills/<name>).
Register into $DEST/<name>/ using the skill basename (destinations stay flat).
Skills catalog (show this to the user)
Built-in (skills/ — nested by category)
Productivity
| # | Name | Folder | What it does |
|---|---|---|---|
| 1 | google-workspace |
skills/productivity/google/google-workspace/ |
Gmail, Calendar, Drive, Docs, Sheets, Contacts, Chat |
| 2 | pc-report |
skills/productivity/pc/pc-report/ |
Host monitoring report (Linux / macOS / Windows) |
| 3 | fathom |
skills/productivity/video-conf/fathom/ |
Fathom meetings, transcripts, AI summaries, action items |
| 4 | jira |
skills/productivity/jira/ |
Jira Cloud via jira-as CLI — router + command.md/ domains + SkillCred .env |
| 5 | confluence |
skills/productivity/confluence/ |
Confluence via confluence-cli + SkillCred .env (read/search/write) |
| 6 | youtrack |
skills/productivity/youtrack/ |
YouTrack via yt (youtrack-cli) — SkillCred .env (URL, API_TOKEN) + yt auth login |
DevOps / DNS
| # | Name | Folder | What it does |
|---|---|---|---|
| 1 | godaddy |
skills/devops/dns/godaddy/ |
GoDaddy v3 discovery, owned domains, DNS CLI |
Database
| # | Name | Folder | What it does |
|---|---|---|---|
| 1 | elastic |
skills/db/elastic/ |
Elasticsearch CLI — env, ping, cluster health, indices |
MDM & Antivirus
| # | Name | Folder | What it does |
|---|---|---|---|
| 1 | eset |
skills/mdm-antivirus/eset/ |
ESET Connect OAuth + device / policy / incident / automation / patch APIs |
| 2 | hexnode |
skills/mdm-antivirus/hexnode/ |
Hexnode device / path management |
Security
| # | Name | Folder | What it does |
|---|---|---|---|
| 1 | bitwarden |
skills/security/bitwarden/ |
Bitwarden / Vaultwarden vault via bw — items, folders, attachments, Send |
| 2 | zscaler |
skills/security/zscaler/ |
Zscaler ZPA / ZIA / ZIdentity APIs — SkillCred .env with SECTION__FIELD keys |
| 3 | folder-crypt |
skills/security/folder-crypt/ |
Encrypt / decrypt a folder with a password (prompt, args, or SkillCred .env) |
Design
| # | Name | Folder | What it does |
|---|---|---|---|
| 1 | gif-creator |
skills/design/gif-creator/ |
Animated GIFs with Pillow (toss, frames → GIF, inspect) |
| 2 | image-converter |
skills/design/image-converter/ |
Convert, resize, trim, and thumbnail still images (WebP, PNG, JPG) |
| 3 | logo-dev-finder |
skills/design/logo.dev-finder/ |
Search logo.dev and download logos into a folder |
Buying
| # | Name | Folder | What it does |
|---|---|---|---|
| 1 | dealabs |
skills/buying/dealabs/ |
Dealabs REST v2 — search deals, get a deal, list comments |
External — any git URL (cloned into ~/.meta-skills/ext/<name>).
Flow (do this)
# 0) Shared library — clone/pull into ~/.meta-skills
If ~/.meta-skills exists: cd ~/.meta-skills && git pull
Else: git clone https://github.com/Acher1234/Meta-Skills.git ~/.meta-skills
# 1) Detect tool from the running agent's env: $CLAUDECODE → Claude; $OPENCODE_* → OpenCode;
# $TERMINAL_ENV → Hermes; $CURSOR_AGENT/$CURSOR_TRACE_ID → Cursor.
# OpenClaw only when explicitly asked.
# 2) Ask scope (see table). For Hermes-profile, resolve HERMES_HOME.
# 3) Ask what to install: built-in name(s), external git URL, or local path.
# 4a) EXTERNAL git skill → fetch once:
SRC=$(cd ~/.meta-skills && ./install.sh fetch <git-url> [name])
# 4b) BUILT-IN: SRC=~/.meta-skills/<catalog Folder> (e.g. skills/mdm-antivirus/eset)
# <name> for DEST = basename of that folder (eset), NOT the category path
# 4c) LOCAL: SRC is the given path
# 5) Register = extract TO COPY slice + link library SKILL.md into each chosen tool/scope:
LIB_SKILL="$SRC/SKILL.md"
REG="$DEST/<name>/SKILL.md"
mkdir -p "$DEST/<name>"
# 5a) YAML frontmatter (lines before first blank line after closing ---)
# 5b) Body between ### TO COPY and ##### END TO COPY (markers excluded)
sed -n '/^### TO COPY$/,/^##### END TO COPY$/p' "$LIB_SKILL" | sed '1d;$d' > /tmp/skill-slice.md
# 5c) Assemble registered file: frontmatter + slice + library pointer
{
awk '/^---$/{n++} {print} n==2{print ""; exit}' "$LIB_SKILL"
cat /tmp/skill-slice.md
echo ""
echo "---"
echo ""
echo "## Library reference"
echo ""
echo "Full commands, examples, and prerequisites — read from the shared library (updates on \`git pull\`):"
echo ""
echo "\`$LIB_SKILL\`"
} > "$REG"
# 5d) Substitute placeholders in the registered file:
# {IS_GLOBAL} → TRUE|FALSE
# {TYPE_OF_AI_TOOLS} → CURSOR|HERMES|OPENCODE|OPENCLAW|CLAUDE
# {SKILL_PATH} → project+git: '$(git rev-parse --show-toplevel)/<rel>/<name>' (literal)
# global or no git: absolute path of $DEST/<name>
# project+git: add .<tool>/skills/*/.env (+ token files) to the project .gitignore
# Do NOT also copy meta-skills — that installer is global-only (INSTALL_PROMPT.md).
# Legacy: no TO COPY markers → cp "$LIB_SKILL" "$REG" and substitute only.
# 5-meta) Meta-skill hub (meta-{domain} + sub-skills): write stubs only — do NOT cp library SKILL.md
LIB=~/.meta-skills/skills/<category>/…/meta-{domain}
META_DEST="$DEST/meta-{domain}"
mkdir -p "$META_DEST"
# write $META_DEST/SKILL.md stub (credentials + link to $LIB/SKILL.md)
cp "$LIB/.env.example" "$META_DEST/.env"
# for each chosen sub-skill <id>: write $DEST/<id>/SKILL.md stub → $LIB/sub_skills/<id>/SKILL.md
# see META_SKILL_TEMPLATE.md
# 6) Reload Cursor / Claude / OpenCode / OpenClaw, or reload the Hermes agent.
# NOTE: installer does NOT install skill deps. Each skill runs
# ./install.sh pip init . (or npm init .) on first run → ~/.meta-skills/.venv
# (pip init also installs meta-skill-common as importable ``common``).
Examples
cd ~/.meta-skills
# Built-in → Hermes (all profiles); SRC is nested, DEST stays flat by basename
LIB=~/.meta-skills/skills/productivity/google/google-workspace/SKILL.md
REG=~/.hermes/skills/google-workspace/SKILL.md
mkdir -p ~/.hermes/skills/google-workspace
# extract TO COPY slice + frontmatter + library link → $REG (see step 5)
# substitute {IS_GLOBAL}=TRUE, {TYPE_OF_AI_TOOLS}=HERMES,
# {SKILL_PATH}=$HOME/.hermes/skills/google-workspace in $REG
# External git skill → Claude (global): fetch once, then register slice + link
SRC=$(./install.sh fetch https://github.com/some/cool-skill.git cool-skill)
LIB="$SRC/SKILL.md"
REG=~/.claude/skills/cool-skill/SKILL.md
mkdir -p ~/.claude/skills/cool-skill
# extract TO COPY → $REG; substitute placeholders; library link = $LIB
# Same skill into Cursor (this project) — no re-clone
REG=./.cursor/skills/cool-skill/SKILL.md
mkdir -p ./.cursor/skills/cool-skill
# substitute → IS_GLOBAL=FALSE, TYPE_OF_AI_TOOLS=CURSOR, SKILL_PATH='$(git rev-parse --show-toplevel)/.cursor/skills/cool-skill'
# Same skill into OpenCode (this project)
REG=./.opencode/skills/cool-skill/SKILL.md
mkdir -p ./.opencode/skills/cool-skill
# substitute → IS_GLOBAL=FALSE, TYPE_OF_AI_TOOLS=OPENCODE, SKILL_PATH='$(git rev-parse --show-toplevel)/.opencode/skills/cool-skill'
# Global OpenCode: ${OPENCODE_CONFIG_DIR:-$HOME/.config/opencode}/skills/cool-skill
# Skill installs ITS OWN deps on first run (shared venv + common):
./install.sh pip init "$SRC"
Agent checklist
- Clone/pull
~/.meta-skills. - Detect tool from the running agent's env (
$CLAUDECODE→ Claude; any$OPENCODE_*→ OpenCode;$TERMINAL_ENV→ Hermes;$CURSOR_AGENT/$CURSOR_TRACE_ID→ Cursor). Ask if ambiguous / several. - Ask scope; resolve
HERMES_HOMEfor Hermes-profile. - Ask what to install (built-in / external git URL / local path). Don't copy all by default.
- External repo →
./install.sh fetch <url> [name](clone once intoext/). - Register — standard skill: TO COPY slice + library link; meta-skill: stub + library link (
[META_SKILL_TEMPLATE.md](META_SKILL_TEMPLATE.md)). Substitute placeholders. Do not copymeta-skillsinstaller (global-only via[INSTALL_PROMPT.md](INSTALL_PROMPT.md)). - Dependencies are each skill's responsibility — the skill runs
./install.sh pip init ./npm init .on first run into~/.meta-skills/.venv. - Remind: reload the tool(s).
Copy map (reference)
Pick DEST from the Targets table. Then mkdir -p "$DEST/<name>",
extract the TO COPY slice from the library SKILL.md, substitute placeholders,
and append a library reference to $SRC/SKILL.md.
Source (~/.meta-skills/…) |
Registered ($DEST/…) |
|---|---|
Standard skill → ### TO COPY slice |
$DEST/<name>/SKILL.md = frontmatter + slice + library link |
Meta-skill meta-{domain}/SKILL.md |
$DEST/meta-{domain}/SKILL.md = stub + library link + local .env |
Sub-skill sub_skills/<id>/SKILL.md |
$DEST/<id>/SKILL.md = stub + library link |
SKILL.md (this installer) |
Full copy global-only — [INSTALL_PROMPT.md](INSTALL_PROMPT.md) |
After install
- CLI working dirs stay under the nested catalog path (e.g.
~/.meta-skills/skills/mdm-antivirus/eset) or~/.meta-skills/ext/<name>. - Python skills should use
~/.meta-skills/.venv/bin/python(hascommoninstalled). - Credentials / tokens resolve under
$CURRENT_SKILL_DIRECTORY(the registered skill dir). - Re-run
/meta-skillsanytime to pull + ask targets/skills again + re-register (or justgit pull— librarySKILL.mdbodies update in place via the registered link).
Notes
- Override the shared library location with
META_SKILLS_HOME(default~/.meta-skills). - Never write into
~/.cursor/skills-cursor/(Cursor built-ins only). - Register with
cp(copy, not move). Prefer per-skill credentials next to the registeredSKILL.md. Use[meta-skill-common/skill_cred.py](meta-skill-common/skill_cred.py)(from common.skill_cred import SkillCred) from Python CLIs. - OpenCode skills: project
./.opencode/skills/<name>/, global${OPENCODE_CONFIG_DIR:-~/.config/opencode}/skills/<name>/(docs). - OpenClaw support is in progress — adjust its paths in the Targets table if needed.
- Repo: Acher1234/Meta-Skills