name: anyskill version: 2.0.0 description: "AnySkill — your private skill cloud. Manage, sync, and dynamically load agent skills from a GitHub-backed repository. Search cloud skills by natural language, auto-load prompts on demand, upload and share custom skills, batch install skill bundles. Works with OpenClaw, Antigravity, Claude Code, and Cursor." metadata: openclaw: requires: env: - ANYSKILL_GITHUB_TOKEN config: - ~/.anyskill/config.json bins: - git primaryEnv: ANYSKILL_GITHUB_TOKEN emoji: "🧠" homepage: https://github.com/lanyijianke/AnySkill

AnySkill Bootstrapper

Your local skills are incomplete. The user maintains all extended capabilities (Skills) in a cloud-based GitHub repository. You need to dynamically load your capabilities from the cloud.

Token scope required: This skill requires a GitHub Fine-grained PAT scoped to a single repository (the user's private skill repo) with Contents: Read and write permission only. The token is used to: clone the private repo, fetch index.json, commit new/updated skills, and push changes. A read-only token will work for loading/searching skills but not for upload/sync operations.

Config files accessed: ~/.anyskill/config.json (primary config) or {project root}/.anyskill.json (legacy project-level config).

Step Zero: Read or Initialize Configuration (Global Priority + Auto-Discovery)

Before performing any operation, you must search for the AnySkill configuration in the following priority chain. Once a valid configuration is found at any level, stop immediately and use it.

Configuration Lookup Priority Chain

Global config ~/.anyskill/config.json (machine-level, shared across projects and IDEs)
Project-level config {project root}/.anyskill.json (backward compatible with older versions)
None found → Enter the initialization flow

Token Retrieval Priority (for private repo authentication)

Regardless of which level the config is read from, the token retrieval priority is always:

Check environment variable ANYSKILL_GITHUB_TOKEN
Check the token field in the config file

If a token is obtained, include it in all HTTP requests as a header:

Authorization: token {token}

Case 1: Config Already Exists (returning user / previously initialized device)

The user has previously initialized on this machine. Skip all initialization and directly verify the config:

Read repo and localPath from the config.
Construct key URLs:
- Index URL: https://raw.githubusercontent.com/{repo}/{branch}/index.json
- Files base URL: https://raw.githubusercontent.com/{repo}/{branch}/skills/
Verify that the localPath directory exists. If not, automatically re-clone:
```
git clone https://github.com/{repo}.git {localPath}
```
(The token is passed via the Authorization header or GIT_ASKPASS environment, not embedded in the URL.)
Attempt to fetch index.json to confirm connectivity.
Inform the user:

✅ AnySkill configuration detected, connected to repository {repo}. Ready to use!
If current environment is OpenClaw: Check if TOOLS.md already contains a ### AnySkill section. If not, or if the skill list is outdated, execute the "OpenClaw Exclusive: Write Workspace Config" steps below to register/update the skill list.

If verification fails (network error or repo deleted), ask the user if they want to re-initialize.

Automatic Version Check (runs on every initialization)

After the config is verified (whether Case 1 or after initialization completes), perform a silent version check:

Fetch upstream version info:

https://raw.githubusercontent.com/lanyijianke/AnySkill/main/version.json

File structure:

{
  "engine": {
    "version": "x.y.z",
    "changelog": [
      { "version": "x.y.z", "date": "YYYY-MM-DD", "changes": ["change 1", "change 2"] },
      { "version": "x.y.z", "date": "YYYY-MM-DD", "changes": ["change 1"] }
    ]
  },
  "infra": {
    "version": "x.y.z",
    "files": ["generate-index.js", ".github/workflows/build-index.yml"],
    "changelog": [
      { "version": "x.y.z", "date": "YYYY-MM-DD", "changes": ["change 1"] }
    ]
  }
}

Engine version check:
- Read the version field from this file's (SKILL.md) frontmatter (currently 2.0.0).
- Compare with remote engine.version.
- If remote version is higher, filter all changelog entries above the local version and display newest to oldest:
  🔔 AnySkill engine update available v{remote} (current v{local})
  
  📋 Update history: v2.1.0 (2025-03-10)
  - New feature A
  - Improvement B
  v2.0.0 (2025-03-04)
  - New feature C
  To update, run: clawhub update anyskill
- Do not auto-overwrite SKILL.md. Inform the user to update via ClawHub CLI which provides versioned, auditable updates.
Infrastructure version check:
- Read the .anyskill-infra-version file from the user's private repo {localPath}. If it doesn't exist, treat as 0.0.0.
- Compare with remote infra.version.
- If remote version is higher, similarly filter and display all new version changes:
  🔔 Repository infrastructure update available v{remote} (current v{local})
  
  📋 Update history: v1.1.0 (2025-03-10)
  - Improved index generation
  Would you like to update?
- After user confirms, iterate over infra.files array, downloading each from upstream and overwriting in the user's {localPath}:
```
https://raw.githubusercontent.com/lanyijianke/AnySkill/main/{file}
```
- Write version marker file {localPath}/.anyskill-infra-version with the new version number.
- Execute git operations to commit changes:
```
cd {localPath}
git add -A
git commit -m "chore: update AnySkill infra to v{version}"
git push origin {branch}
```
If both versions are up to date, output nothing — pass silently.
If version.json fetch fails (network error), silently skip version check without affecting normal usage.

💡 Version check is a lightweight operation (only fetches a small JSON), it won't slow down normal workflows.

Case 2: Config Not Found (new device / first use)

Before asking the user any questions, first silently detect if a usable Token already exists:

Check if environment variable ANYSKILL_GITHUB_TOKEN exists.
If it exists (meaning the user has previously configured AnySkill on this machine):
- Do not ask the user for a Token, directly jump to "Path B: User only provided a Token" auto-discovery flow below.
- The entire process should be silent to the user: AI auto-detects cloud repo → confirms mount → writes global config → ready.
If it does not exist, then initiate the guided conversation (see below).

Guided Conversation (only when Token cannot be silently obtained)

Guide the user through initialization via natural language conversation. The user should never need to run any terminal commands.

Say something like this to the user:

👋 Welcome to AnySkill! Let me help you connect your private skill repository.

Do you already have an AnySkill skill repository?

A) I have a repo — Just provide your Token and repo name: github_pat_xxx username/my-skills (space-separated)

B) I don't have one yet — Follow these steps (works on mobile too):

Step 1: Create a private skill repository Open 👉 One-click create repo

Repository name: enter my-skills (or any name you like)

⚠️ Must select Private (do not choose Public)

Click Create repository

Step 2: Create a Token (a key for AI to access your repo) Open 👉 Create Token

Token name: enter AnySkill

Expiration: pick a duration you're comfortable with

Repository access: select "Only select repositories" → Search for and select your my-skills repo in the dropdown ⚠️ Note: if you chose "Public Repositories", the permissions panel below will NOT appear!

After selecting a repo, a Permissions panel appears below → Expand "Repository permissions" → Scroll down to find "Contents" (near the top of the list) → Change it from "No access" to "Read and write"

Leave all other permissions at "No access"

Click "Generate token" at the bottom

Copy the generated Token (starts with github_pat_)

Step 3: Send me your Token and repo name Format: github_pat_xxx your-username/my-skills

Send it over when you're ready! If you get stuck on any step, just ask.

Handling User Response

Decision criteria: Whether the user's response contains a repository address (format: username/repo-name).

Contains repo address → Follow "Path A"
No repo address (Token only) → Follow "Path B"

Path A: User provided both Token and repository address

After the user provides a repo address and Token:

Ask the user where they want to clone the repo locally (default suggestion: /tmp/{repo-name}).
Securely store the Token (depends on IDE environment):
- OpenClaw: Set environment variable ANYSKILL_GITHUB_TOKEN via the platform's standard env configuration.
- Other IDEs (Antigravity/Claude Code/Cursor): Write token to the config file.
Execute clone:

git clone https://github.com/{repo}.git {localPath}

(Use GIT_ASKPASS or credential helper to authenticate, do not embed token in URL.) 4. Create global config file ~/.anyskill/config.json:

OpenClaw version (without token):

{
  "repo": "user-provided-address",
  "branch": "main",
  "localPath": "/tmp/{repo-name}"
}

Other IDE version (with token):

{
  "repo": "user-provided-address",
  "branch": "main",
  "token": "github_pat_xxxxxxxxxxxx",
  "localPath": "/tmp/{repo-name}"
}

Path B: User only provided a Token — Auto-Discovery Flow (⚠️ Core Path)

This is the most common scenario. The user only gave a Token without specifying a repo name. You must strictly follow these three steps. Never skip any step. Never directly create a new repo.

Step 1: Get the user's GitHub username via Token

Use the GitHub API or command line to get user info:

curl -s -H "Authorization: token {token}" https://api.github.com/user

Extract the login field from the returned JSON — that's the username.

Step 2: Auto-search for existing AnySkill skill repositories under the username

Call the GitHub Repository Search API:

curl -s -H "Authorization: token {token}" "https://api.github.com/search/repositories?q=user:{login}+anyskill+in:name,description"

For each candidate repo in the results, try to read its index.json: https://raw.githubusercontent.com/{login}/{candidate-repo-name}/{default-branch}/index.json If index.json can be read successfully, this repo is a genuine AnySkill skill repository.

Step 3: Branch based on detection results

✅ Existing skill repo detected: Inform user and request confirmation:

👋 Welcome back! I detected an existing skill repository {login}/{repo-name}. Mounting automatically...

Then auto-execute clone and config write (same as Path A steps 1-4), without asking unnecessary questions.
❌ No skill repo detected (confirmed as a brand new user):

Guide the user to create a repo first:

I couldn't find a skill repository under your account. Please create one first:

👉 One-click create skill repository

Suggested name: my-skills, make sure to check Private. Once created, tell me the repo name and I'll finish the setup!

After the user provides the repo name, execute clone and config write (same as Path A steps 1-4).

💡 Security tip: After the repo is created, go back to your Token settings and change Repository access to Only select repositories, selecting only this repo for minimal permissions.

Initialization Complete

Regardless of which path was taken, inform the user upon completion:

✅ AnySkill configuration complete! 📦 Skill repository: {repo} 📂 Local path: {localPath} 🔧 Global config: ~/.anyskill/config.json From now on, you can load, download, and publish skills from any project.

OpenClaw Exclusive: Write Workspace Config (only in OpenClaw environments)

If the current environment is OpenClaw (detected by: ANYSKILL_GITHUB_TOKEN exists in ~/.openclaw/.env, or user explicitly specified, or ~/.openclaw/ directory detected), perform these two additional steps after initialization:

Step 1: Append to TOOLS.md

Find the OpenClaw workspace TOOLS.md file (path: ~/.openclaw-config/workspace/TOOLS.md or {OpenClaw project root}/.openclaw-config/workspace/TOOLS.md).

First check if the file already contains a ### AnySkill section. Then read index.json (local {localPath}/index.json or remote fetch) to get the current skill inventory.

If ### AnySkill section does not exist, append at end of file; if it already exists, replace the entire section (ensure the skill list is up to date):


### AnySkill

- **Skill Repository**: `{repo}`
- **Global Config**: `~/.anyskill/config.json`
- **Local Path**: `{localPath}`
- **Skill Loading**: When you lack a skill, read the guide in `~/.openclaw/skills/anyskill/SKILL.md` to load from the cloud AnySkill repository on demand
- **Operation**: All skill management (load, download, upload, list, delete) is triggered via natural language, no CLI needed

#### Registered Cloud Skills

| Skill Name | Description |
|:---|:---|
| `{name}` | {description} |
| ... | ... |

(This list is dynamically generated from `index.json`, auto-updated after every skill add/remove/update)

📌 The "Registered Cloud Skills" table must be generated in real-time from index.json, iterating all skill entries and filling in name and description. If index.json is empty or fetch fails, display "No skills yet".

Step 2: Append to AGENTS.md

Find the OpenClaw workspace AGENTS.md file (same directory as TOOLS.md).

Search for the ## Tools section. At the end of that section (before the next ## heading), check if AnySkill-related content already exists. If not, append:


**🧠 AnySkill Cloud Skills**: When you need to perform specific tasks (frontend design, API integration, data scraping, etc.) but don't have the corresponding skill locally, first check the AnySkill guide in `~/.openclaw/skills/anyskill/SKILL.md` to load capabilities on demand from your cloud private skill repository.

If AnySkill-related content already exists, skip this step.

⚠️ Do not modify any other content in these two files. Only append or update the AnySkill section — never overwrite existing user configurations.

OpenClaw Skill Registry Sync (General Rule)

📌 Any operation that changes the skill list (Mode 4 upload, Mode 5 update, Mode 7 delete, Mode 9 Pack install) must, after completion, if the current environment is OpenClaw, re-read the latest index.json and replace the entire ### AnySkill section in TOOLS.md using the format above, ensuring the "Registered Cloud Skills" table always stays in sync with the cloud.

This sync operation should be performed after git push completes and a few seconds wait (because GitHub Actions needs to rebuild index.json), or directly read from local {localPath}/index.json.

Then continue executing the user's original request.

Mode 1: On-Demand Loading (default behavior, in-memory only)

When the user issues a task and you determine that the local environment lacks specific execution details:

Read AnySkill config via the priority chain (global ~/.anyskill/config.json → project-level .anyskill.json).
Use your web reading tool to fetch index.json from the index URL (include auth header if token is available).
Find the most matching entry based on each skill's description for the current task.
For each file in the files array, read all files from the cloud into memory (do not save to local disk), then digest the SKILL.md specifications.
Complete the user's original request based on the loaded specifications.

💡 On-demand loading is lightweight and leaves no local files. Ideal for one-time use or trying out skills.

Mode 2: On-Demand Download (specific skill to disk)

When the user explicitly says "download XX skill", "pull XX to local", "install XX skill" or similar instructions targeting a single skill:

Read AnySkill config via the priority chain.
Fetch index.json, match the target skill by the name or description the user specified.
Detect the current AI IDE environment and determine the download path (see path reference table below).
Download each file from the skill's files array to the local IDE skill directory, preserving the original directory structure.
Inform the user upon completion: Skill {skill-name} downloaded to {path}, N files total.

Mode 3: Full Download to Local

When the user explicitly says "download all skills", "pull skills to local", "sync cloud skills" or similar instructions, perform a full download.

Steps

Read AnySkill config via the priority chain.
Fetch index.json for the complete skill list.
Detect the current AI IDE environment and determine the download path (see table below). If unable to detect automatically, ask the user.
For each skill, iterate its files array, downloading each file and preserving the original directory structure.
- For example, if files contains my-skill/scripts/helper.py, the download URL is {files-base-url}my-skill/scripts/helper.py, and the local path is {IDE-skill-directory}/my-skill/scripts/helper.py.
After completion, report the list of downloaded skills and file counts to the user.

IDE Download Path Reference

AI IDE	Download Path	Entry File
Antigravity	`{project root}/.agent/skills/{skill-name}/`	`SKILL.md`
Claude Code	`{project root}/.claude/skills/{skill-name}/`	`SKILL.md`
Cursor	`{project root}/.cursor/rules/{skill-name}/`	`SKILL.md`
OpenClaw	`~/.openclaw/skills/{skill-name}/`	`SKILL.md`

IDE Auto-Detection Logic

If the current project has an .agent/ directory or you are Antigravity → Use Antigravity path
If the current project has a .claude/ directory or you are Claude Code → Use Claude Code path
If the current project has a .cursor/ directory or you are Cursor → Use Cursor path
If the user explicitly mentions OpenClaw → Use OpenClaw path
If unable to determine → Ask the user: "Which IDE are you currently using? (Antigravity/Claude Code/Cursor/OpenClaw)"

Mode 4: Upload Skill to Cloud

When the user explicitly says "upload skill", "upload this skill", "push skill to cloud", "push to repo" or similar instructions, execute the upload flow.

Read localPath from the AnySkill config to operate in the local repository.

Upload Steps

Confirm the skill content to upload with the user.
The skill folder name must use the user's original name exactly — never translate or rename it. If the user provides a Chinese name (e.g., 前端设计), use that; if English (e.g., web-scraper), use English.
Create SKILL.md under {localPath}/skills/{user-specified-name}/.
- SKILL.md must include correct YAML frontmatter (name and description).
- If the user provides additional files (scripts, references, etc.), place them in the corresponding subdirectory.
Auto-provision infrastructure files (may be missing on first upload):
- Check if {localPath}/.github/workflows/build-index.yml exists; if not, download from template repo: https://raw.githubusercontent.com/lanyijianke/AnySkill/main/.github/workflows/build-index.yml
- Check if {localPath}/generate-index.js exists; if not, download from template repo: https://raw.githubusercontent.com/lanyijianke/AnySkill/main/generate-index.js

Execute git operations:

cd {localPath}
git add -A
git commit -m "feat: add skill {user-specified-name}"
git push origin {branch}

Inform the user upon completion:

✅ Skill {name} has been uploaded to the cloud repository! GitHub Actions will automatically rebuild index.json in a few seconds, after which other projects can load this skill.
If current environment is OpenClaw, execute "OpenClaw Skill Registry Sync" to update the skill list in TOOLS.md.

Mode 5: Update a Specific Skill

When the user explicitly says "update XX skill", "modify XX skill", "change XX" or similar instructions:

Read localPath from AnySkill config via the priority chain.
Confirm that {localPath}/skills/{name}/ exists. If not, inform the user the skill doesn't exist and suggest using upload mode to create a new one.
Read and display the existing SKILL.md content to the user, ask which parts need modification.
Modify the corresponding files based on the user's description.

Execute git operations:

cd {localPath}
git add skills/{name}/
git commit -m "fix: update skill {name}"
git push origin {branch}

Inform the user upon completion:

✅ Skill {name} has been updated! GitHub Actions will automatically update the index.
If current environment is OpenClaw, execute "OpenClaw Skill Registry Sync" to update the skill list in TOOLS.md.

Mode 6: List Cloud Skills

When the user explicitly says "list skills", "what skills are there", "show cloud skills", "skill list" or similar instructions:

Read AnySkill config via the priority chain.
Fetch index.json.
Display all skills in a table:

Skill Name	Description	File Count
`{name}`	`{description}`	`{files.length}`

After display, ask the user if they want to load or download any skill.

Mode 7: Delete a Specific Skill

When the user explicitly says "delete XX skill", "remove XX skill", "remove XX from repo" or similar instructions:

Read localPath from AnySkill config via the priority chain.
Confirm that {localPath}/skills/{user-specified-name}/ exists.
Must confirm with the user:

⚠️ About to delete skill {name}. This will permanently remove the folder from the cloud repository. Confirm deletion?

After user confirms, execute:

cd {localPath}
git rm -rf skills/{name}/
git commit -m "feat: remove skill {name}"
git push origin {branch}

Inform the user upon completion:

✅ Skill {name} has been deleted from the cloud repository. GitHub Actions will automatically update the index.
If current environment is OpenClaw, execute "OpenClaw Skill Registry Sync" to remove the skill from the TOOLS.md skill list.

Mode 8: Delete Entire Skill Repository (requires manual action)

When the user explicitly says "delete the entire repo", "destroy skill space", "I don't want this repo anymore" or similar instructions:

⛔ This operation is extremely dangerous and irreversible. AI is strictly forbidden from executing it automatically.

You may only provide guidance for the user to do it themselves:

Inform the user:
⚠️ Deleting the entire repository is irreversible, and I cannot do it on your behalf. Please go to GitHub yourself:
1. Open https://github.com/{repo}/settings (scroll to the bottom Danger Zone)
2. Click Delete this repository
3. Confirm by typing the repository name as prompted
After deletion, manually remove the local global config ~/.anyskill/config.json (and project-level .anyskill.json, if any) and the {localPath} directory.
Strictly forbidden to call GitHub API or any command to delete the repository.

Mode 9: Install Skills from Packs

When the user explicitly says "install from Packs", "what packs are available", "install XX pack", "browse packs" or similar instructions:

Packs repository URL: https://raw.githubusercontent.com/lanyijianke/AnySkill-Packs/main/

Browse Available Packs

Fetch https://raw.githubusercontent.com/lanyijianke/AnySkill-Packs/main/index.json (public repo, no Token needed).
Display all packs and their skills in a table:

Pack	Skill Name	Description
`{category}`	`{skill.name}`	`{skill.description}`

Install a Specific Pack

Find all skills in the target pack from index.json.
Download each skill's files individually, saving to the user's private repo at {localPath}/skills/{skill-name}/.
- File URL pattern: https://raw.githubusercontent.com/lanyijianke/AnySkill-Packs/main/packs/{file-path}
Error tolerance: If a skill download fails, skip it and continue to the next one.

After download completes, execute git operations to commit skills to the user's private repo:

cd {localPath}
git add skills/
git commit -m "feat: install pack {category}"
git push origin {branch}

Provide a summary report:
✅ Pack {category} installation complete!
- Succeeded: {N} (skill-a, skill-b)
- Failed: {M} (skill-x — reason: download failed)
If current environment is OpenClaw, execute "OpenClaw Skill Registry Sync" to update the skill list in TOOLS.md.

Code of Conduct

Never guess details — always rely on cloud-fetched "injected capabilities".
You may briefly report to the user: "Loading [skill-name] from cloud skill repository..."
If index.json has no matching skill, inform the user that the cloud repository currently lacks the corresponding capability.
If a network request fails, report to the user and suggest checking network connectivity or repository availability.
Throughout the entire process, never ask the user to manually run terminal commands. All file creation, downloading, and git operations are performed automatically by you.

AnySkill Skill Cloud Manager

Description