Skill Management MCP Server

Unified CRUD tool for skill management.

IMPORTANT NOTES:

• Skills are stored in ~/.skill-mcp/skills directory

• All file paths in responses are relative to the skill directory (e.g., 'main.py', not full paths)

• To execute scripts, use the 'run_skill_script' tool, NOT external bash/shell tools

Operations:

• create: Create a new skill with templates (basic, python, bash, nodejs)

• list: List all skills with optional search (supports text and regex)

• search: Search for skills by pattern (text or regex)

• get: Get detailed information about a specific skill

• validate: Validate skill structure and get diagnostics

• delete: Delete a skill directory (requires confirm=true)

• list_templates: List all available skill templates with descriptions

Examples:

// List available templates
{"operation": "list_templates"}

// Create a Python skill
{"operation": "create", "skill_name": "my-skill", "description": "My skill", "template": "python"}

// List all skills
{"operation": "list"}

// Search skills by text
{"operation": "search", "search": "weather"}

// Search skills by regex pattern
{"operation": "search", "search": "^api-"}

// Get skill details
{"operation": "get", "skill_name": "my-skill", "include_content": true}

// Validate skill
{"operation": "validate", "skill_name": "my-skill"}

// Delete skill
{"operation": "delete", "skill_name": "my-skill", "confirm": true}

Unified CRUD tool for skill file operations. Supports both single and bulk operations.

IMPORTANT PATH NOTES:

• All file paths are RELATIVE to the skill directory (e.g., 'main.py', 'scripts/utils.py')

• NEVER use absolute paths (e.g., NOT '/Users/username/.skill-mcp/skills/my-skill/main.py')

• To execute scripts, use the 'run_skill_script' tool, NOT external bash/shell tools

Operations:

• read: Read a file's content

• create: Create one or more files (supports atomic mode for bulk)

• update: Update one or more files

• delete: Delete a file (SKILL.md is protected and cannot be deleted)

Single File Examples:

// Read a file
{"operation": "read", "skill_name": "my-skill", "file_path": "script.py"}

// Create a single file
{"operation": "create", "skill_name": "my-skill", "file_path": "new.py", "content": "print('hello')"}

// Update a single file
{"operation": "update", "skill_name": "my-skill", "file_path": "script.py", "content": "print('updated')"}

// Delete a file
{"operation": "delete", "skill_name": "my-skill", "file_path": "old.py"}

Bulk File Examples:

// Read multiple files
{
  "operation": "read",
  "skill_name": "my-skill",
  "file_paths": ["file1.py", "file2.py", "file3.py"]
}

// Create multiple files atomically (all-or-nothing)
{
  "operation": "create",
  "skill_name": "my-skill",
  "files": [
    {"path": "src/main.py", "content": "# Main"},
    {"path": "src/utils.py", "content": "# Utils"},
    {"path": "README.md", "content": "# Docs"}
  ],
  "atomic": true
}

// Update multiple files
{
  "operation": "update",
  "skill_name": "my-skill",
  "files": [
    {"path": "file1.py", "content": "new content 1"},
    {"path": "file2.py", "content": "new content 2"}
  ]
}

Unified CRUD tool for skill environment variable operations. Supports single and bulk operations.

Operations:

• read: Read all environment variable keys (values are hidden for security)

• set: Set one or more environment variables (merges with existing)

• delete: Delete one or more environment variables

• clear: Clear all environment variables

Examples:

// Read all env var keys
{
  "operation": "read",
  "skill_name": "my-skill"
}

// Set single variable (merges with existing)
{
  "operation": "set",
  "skill_name": "my-skill",
  "variables": {"API_KEY": "sk-123"}
}

// Set multiple variables (bulk merge)
{
  "operation": "set",
  "skill_name": "my-skill",
  "variables": {
    "API_KEY": "sk-123",
    "DEBUG": "true",
    "TIMEOUT": "30"
  }
}

// Delete single variable
{
  "operation": "delete",
  "skill_name": "my-skill",
  "keys": ["API_KEY"]
}

// Delete multiple variables
{
  "operation": "delete",
  "skill_name": "my-skill",
  "keys": ["API_KEY", "DEBUG", "TIMEOUT"]
}

// Clear all environment variables
{
  "operation": "clear",
  "skill_name": "my-skill"
}

Note: The 'set' operation always merges with existing variables. To replace everything, use 'clear' first, then 'set'.

Execute Python code directly without requiring a script file.

RECOMMENDATION: Prefer Python over bash/shell scripts for better portability, error handling, and maintainability.

IMPORTANT: Use this tool instead of creating temporary script files when you need to run quick Python code.

✅ SUPPORTS PEP 723 INLINE DEPENDENCIES - just like run_skill_script!

FEATURES:

• PEP 723 inline dependencies: Include dependencies directly in code using /// script comments (auto-detected and installed)

• Dependency aggregation: When importing from skills, their PEP 723 dependencies are automatically merged into your code

• Skill file imports: Reference files from skills using namespace format (skill_name:path/to/file.py)

• Automatic dependency installation: Code with PEP 723 metadata is run with 'uv run'

• Environment variable loading: Automatically loads .env files from all referenced skills

• Clean execution: Temporary file is automatically cleaned up after execution

PARAMETERS:

• code: Python code to execute (can include PEP 723 dependencies)

• skill_references: Optional list of skill files to make available for import Format: ["calculator:utils.py", "weather:api/client.py"] The skill directories will be added to PYTHONPATH Environment variables from each skill's .env file will be loaded

• timeout: Optional timeout in seconds (defaults to 30 seconds if not specified)

CROSS-SKILL IMPORTS - BUILD REUSABLE LIBRARIES: Create utility skills once, import them anywhere! Perfect for:

• Math/statistics libraries (calculator:stats.py)

• API clients (weather:api_client.py)

• Data processors (etl:transformers.py)

• Common utilities (helpers:string_utils.py)

AUTOMATIC DEPENDENCY AGGREGATION: When you reference skill files, their PEP 723 dependencies are automatically collected and merged into your code! You don't need to redeclare dependencies - just reference the modules and their deps are included automatically.

Example - library module with deps:

# data-processor:json_fetcher.py
# /// script
# dependencies = ["requests>=2.31.0"]
# ///
import requests
def fetch_json(url): return requests.get(url).json()

Your code - NO need to declare requests!

{
  "code": "from json_fetcher import fetch_json\ndata = fetch_json('https://api.example.com')\nprint(data)",
  "skill_references": ["data-processor:json_fetcher.py"]
}

Dependencies from json_fetcher.py are automatically aggregated!

Import from single skill:

{
  "code": "from math_utils import add, multiply\nprint(add(10, 20))",
  "skill_references": ["calculator:math_utils.py"]
}

Import from multiple skills:

{
  "code": "from math_utils import add\nfrom stats_utils import mean\nfrom converters import celsius_to_fahrenheit\n\nresult = add(10, 20)\navg = mean([10, 20, 30])\ntemp = celsius_to_fahrenheit(25)\nprint(f'Sum: {result}, Avg: {avg}, Temp: {temp}F')",
  "skill_references": ["calculator:math_utils.py", "calculator:stats_utils.py", "calculator:converters.py"]
}

Import from subdirectories:

{
  "code": "from advanced.calculus import derivative_at_point\ndef f(x): return x**2\nprint(derivative_at_point(f, 5))",
  "skill_references": ["calculator:advanced/calculus.py"]
}

ENVIRONMENT VARIABLES FROM REFERENCED SKILLS: When you import from a skill, its environment variables are automatically loaded:

{
  "code": "from api_client import fetch_weather\ndata = fetch_weather('London')\nprint(data)",
  "skill_references": ["weather:api_client.py"]
}

If weather:api_client.py uses API_KEY from its .env file, it will be available automatically!

EXAMPLE WITH PEP 723 DEPENDENCIES:

{
  "code": "# /// script\n# dependencies = [\n#   \"requests>=2.31.0\",\n#   \"pandas\",\n# ]\n# ///\n\nimport requests\nimport pandas as pd\n\nresponse = requests.get('https://api.example.com/data')\ndf = pd.DataFrame(response.json())\nprint(df.head())"
}

WHY PYTHON OVER BASH/JS:

• Better error handling and debugging

• Rich standard library

• Cross-platform compatibility

• Easier to read and maintain

• Strong typing support

• Better dependency management

RETURNS: Execution result with:

• Exit code (0 = success, non-zero = failure)

• STDOUT (standard output)

• STDERR (error output)

Execute a script within a skill directory. Skills are modular libraries with reusable code - scripts can import from their own modules or use external dependencies.

IMPORTANT: ALWAYS use this tool to execute scripts. DO NOT use external bash/shell tools to execute scripts directly. This tool provides:

• Automatic dependency management (Python PEP 723, npm packages)

• Proper environment variable injection from .env files

• Secure execution within skill directory boundaries

• Proper error handling and output capture

SKILLS AS LIBRARIES: Scripts within a skill can import from local modules naturally:

weather-skill/
├── main.py          # Script that imports from modules below
├── api_client.py    # Reusable API client module
├── parsers.py       # Data parsing utilities
└── formatters.py    # Output formatting

In main.py:

from api_client import WeatherAPI
from formatters import format_temperature

api = WeatherAPI()
data = api.get_weather("London")
print(format_temperature(data))

Execute with:

{
  "skill_name": "weather-skill",
  "script_path": "main.py",
  "args": ["--city", "London"]
}

SUPPORTED LANGUAGES:

• Python: Automatically detects and installs PEP 723 inline dependencies via 'uv run'

• JavaScript/Node.js: Automatically runs 'npm install' if package.json exists

• Bash: Executes shell scripts (.sh files)

• Other: Any executable file with proper shebang line

FEATURES:

• Module imports: Scripts can import from other files within the skill directory

• Automatic PEP 723 dependency detection: Python scripts with inline metadata are automatically run with 'uv run'

• Automatic npm dependency installation: Node.js scripts install dependencies from package.json

• Environment variables: Loads skill-specific .env file and injects variables into script environment

• Working directory: Can specify a subdirectory to run the script from

• Arguments: Pass command-line arguments to the script

• Output capture: Returns stdout, stderr, and exit code

PEP 723 AUTOMATIC DEPENDENCY DETECTION: Python scripts with inline dependencies are automatically detected and executed with 'uv run':

Example Python script with PEP 723 (e.g., weather-skill/fetch_weather.py):

#!/usr/bin/env python3
# /// script
# dependencies = [
#   "requests>=2.31.0",
#   "beautifulsoup4>=4.12.0",
# ]
# ///

import requests
from bs4 import BeautifulSoup

response = requests.get("https://api.weather.com/data")
print(response.json())

Execute with automatic dependency handling:

{
  "skill_name": "weather-skill",
  "script_path": "fetch_weather.py",
  "args": ["--city", "London"]
}

No manual dependency installation needed - the server automatically:

1. Detects the PEP 723 metadata in your script

2. Uses 'uv run' to create an isolated environment

3. Installs the declared dependencies

4. Executes your script with access to those dependencies

PARAMETERS:

• skill_name: The name of the skill directory (e.g., 'weather-skill')

• script_path: Relative path to the script within skill directory (e.g., 'main.py', 'scripts/fetch_weather.py', 'bin/process.sh')

• args: Optional list of command-line arguments (e.g., ['--verbose', 'input.txt'])

• working_dir: Optional working directory relative to skill root (e.g., 'scripts')

• timeout: Optional timeout in seconds (defaults to 30 seconds if not specified)

IMPORTANT PATH NOTES:

• All paths are RELATIVE to the skill directory, never absolute paths

• Script path example: 'main.py' NOT '/Users/username/.skill-mcp/skills/my-skill/main.py'

• Working dir example: 'scripts' NOT '/full/path/to/scripts'

RETURNS: Script execution result with:

• Exit code (0 = success, non-zero = failure)

• STDOUT (standard output)

• STDERR (error output)