mcpskills-cli 0.1.0__tar.gz

mcpskills_cli-0.1.0/.cursor/skills/dellstore/SKILL.md

@@ -0,0 +1,104 @@
+---
+name: dellstore
+description: MCP tools for dellstore. Available tools: list_tables, get_table_schema, execute_query, test_connection. Use when the user needs to call these MCP tools.
+---
+
+# dellstore MCP Tools
+
+
+
+## Tables
+
+**categories** — category (int PK), categoryname (varchar 50)
+
+**cust_hist** — customerid (int, FK→customers.customerid), orderid (int), prod_id (int)
+
+**customers** — customerid (int PK), firstname, lastname, address1, address2 (nullable), city, state (nullable), zip (int, nullable), country, region (smallint), email (nullable), phone (nullable), creditcardtype (int), creditcard, creditcardexpiration, username (unique), password, age (smallint, nullable), income (int, nullable), gender (varchar 1, nullable) — all strings varchar 50 unless noted
+
+**inventory** — prod_id (int PK), quan_in_stock (int), sales (int)
+
+**orderlines** — orderlineid (int), orderid (int, FK→orders.orderid), prod_id (int), quantity (smallint), orderdate (date)
+
+**orders** — orderid (int PK), orderdate (date), customerid (int, nullable, FK→customers.customerid), netamount (numeric), tax (numeric), totalamount (numeric)
+
+**products** — prod_id (int PK), category (int), title (varchar 50), actor (varchar 50), price (numeric), special (smallint, nullable), common_prod_id (int)
+
+**reorder** — prod_id (int), date_low (date), quan_low (int), date_reordered (date, nullable), quan_reordered (int, nullable), date_expected (date, nullable)
+
+## Available Tools
+
+### list_tables
+
+List all tables in the database.
+
+Args:
+    db_name: Identifier for the database instance (default: "default")
+
+**Execute:**
+```python
+python3 /Users/dhanababu/workspace/forge-mcp-to-skills/.cursor/skills/dellstore/scripts/call.py list_tables
+```
+
+### get_table_schema
+
+Get schema information for a specific table.
+
+Args:
+    table_name: Name of the table to inspect
+    db_name: Identifier for the database instance (default: "default")
+
+Returns:
+    JSON string with table schema information
+
+**Parameters:**
+- `table_name` (string, required): -
+
+**Execute:**
+```python
+python3 /Users/dhanababu/workspace/forge-mcp-to-skills/.cursor/skills/dellstore/scripts/call.py get_table_schema '{"table_name": "<table_name>"}'
+```
+
+### execute_query
+
+Execute a SQL query with optional parameters.
+
+This tool allows you to execute any SQL query
+(SELECT, INSERT, UPDATE, DELETE, etc.)
+with support for parameterized queries to prevent SQL injection.
+
+Args:
+    query: SQL query to execute
+    params: Optional dictionary of parameters for parameterized queries
+    db_name: Identifier for the database instance (default: "default")
+
+Returns:
+    For SELECT queries: List of dictionaries representing rows
+    For INSERT/UPDATE/DELETE: List with affected_rows count
+
+**Parameters:**
+- `query` (string, required): -
+- `params` (any, optional): -
+
+**Execute:**
+```python
+python3 /Users/dhanababu/workspace/forge-mcp-to-skills/.cursor/skills/dellstore/scripts/call.py execute_query '{"query": "<query>"}'
+```
+
+### test_connection
+
+Test the database connection and return connection status information.
+
+This tool verifies that the database connection is active and returns
+connection details including database type, version, and pool
+configuration.
+
+Args:
+
+Returns:
+    Dictionary with connection status, database information, and pool
+    settings
+
+**Execute:**
+```python
+python3 /Users/dhanababu/workspace/forge-mcp-to-skills/.cursor/skills/dellstore/scripts/call.py test_connection
+```

mcpskills_cli-0.1.0/.cursor/skills/dellstore/scripts/call.py

@@ -0,0 +1,63 @@
+#!/usr/bin/env python3
+"""Call MCP tool on server 'dellstore'."""
+import configparser
+import json
+import os
+import sys
+import urllib.request
+
+SERVER = "dellstore"
+CREDS_FILE = os.path.expanduser("~/.mcps/credentials")
+
+
+def load_credentials():
+    cfg = configparser.ConfigParser()
+    cfg.read(CREDS_FILE)
+    if SERVER not in cfg:
+        print(f"No section [{SERVER}] in {CREDS_FILE}", file=sys.stderr)
+        sys.exit(1)
+    return cfg[SERVER]["url"], cfg[SERVER]["token"]
+
+
+def call_tool(tool_name: str, arguments: dict) -> dict:
+    url, token = load_credentials()
+    url = url.rstrip("/") + "/"
+    body = json.dumps({
+        "jsonrpc": "2.0",
+        "method": "tools/call",
+        "params": {"name": tool_name, "arguments": arguments},
+        "id": 1,
+    }).encode()
+    req = urllib.request.Request(
+        url, data=body, method="POST",
+        headers={
+            "Authorization": f"Bearer {token}",
+            "Content-Type": "application/json",
+            "Accept": "application/json, text/event-stream",
+            "MCP-Protocol-Version": "2025-06-18",
+        },
+    )
+    with urllib.request.urlopen(req, timeout=30) as resp:
+        text = resp.read().decode()
+    for line in text.strip().split("\n"):
+        if line.startswith("data:"):
+            line = line[5:].strip()
+        if not line or line == "[DONE]":
+            continue
+        try:
+            obj = json.loads(line)
+            if "result" in obj or "error" in obj:
+                return obj
+        except json.JSONDecodeError:
+            pass
+    return json.loads(text)
+
+
+if __name__ == "__main__":
+    if len(sys.argv) < 2:
+        print(f"Usage: {sys.argv[0]} <tool_name> [json_args]", file=sys.stderr)
+        sys.exit(1)
+    tool = sys.argv[1]
+    args = json.loads(sys.argv[2]) if len(sys.argv) > 2 else {}
+    result = call_tool(tool, args)
+    print(json.dumps(result, indent=2))

mcpskills_cli-0.1.0/PKG-INFO

@@ -0,0 +1,7 @@
+Metadata-Version: 2.4
+Name: mcpskills-cli
+Version: 0.1.0
+Summary: Generate Cursor Agent Skills from MCP server tools
+Requires-Python: >=3.10
+Requires-Dist: fastmcp>=2.3
+Requires-Dist: jinja2>=3.1

mcpskills_cli-0.1.0/README.md

@@ -0,0 +1,85 @@
+# mcpskills-cli
+
+Generate Agent Skills from MCP server tools. Connects via Streamable HTTP, discovers tools, and outputs a skill with schema docs and a call script in the language of your choice.
+
+## Install
+
+```bash
+pip install .
+# or for development:
+pip install -e .
+```
+
+## Usage
+
+```bash
+mcpskills-cli --url <MCP_SERVER_URL> --token <TOKEN> [--name <NAME>] [--output <DIR>] [--script <LANG>] [--multi-skills]
+```
+
+| Flag | Default | Description |
+|---|---|---|
+| `--url` | (required) | MCP server endpoint |
+| `--token` | (required) | Bearer token |
+| `--name` | from URL | Server name (skill dir + credentials key) |
+| `--output` | `~/.cursor/skills` | Skills output directory |
+| `--script` | `bash` | Call script language: `bash`, `python`, `node`, `go`, `rust` |
+| `--multi-skills` | `false` | Generate a separate skill for each tool |
+
+### Examples
+
+```bash
+# Generate single skill with all tools (default)
+mcpskills-cli --url http://localhost:8027/mcp/abc123 --token mytoken --name my-db
+
+# Generate separate skill for each tool
+mcpskills-cli --url http://localhost:8027/mcp/abc123 --token mytoken --name my-db --multi-skills
+
+# Generate with Python call script
+mcpskills-cli --url http://localhost:8027/mcp/abc123 --token mytoken --name my-db --script python
+
+# Generate with Node.js call script
+mcpskills-cli --url http://localhost:8027/mcp/abc123 --token mytoken --name my-db --script node
+```
+
+## Credentials
+
+Stored in `~/.mcps/credentials` (INI format, `chmod 600`). One section per server, updated automatically.
+
+```ini
+[my-db]
+url = http://localhost:8027/mcp/abc123/
+token = mytoken
+```
+
+Rotate tokens by editing the file directly; no need to regenerate skills.
+
+## Generated Output
+
+### Default Mode (Single Skill)
+
+```
+~/.cursor/skills/<server-name>/
+  SKILL.md              # Documents all tools with parameters
+  scripts/
+    call.<ext>          # Calls any tool: ./call.<ext> <tool_name> '{"key":"val"}'
+```
+
+### Multi-Skills Mode (--multi-skills)
+
+```
+~/.cursor/skills/<server-name>-<tool-name-1>/
+  SKILL.md              # Documents single tool
+  scripts/
+    call.<ext>          # Calls tool: ./call.<ext> <tool_name> '{"key":"val"}'
+
+~/.cursor/skills/<server-name>-<tool-name-2>/
+  SKILL.md
+  scripts/
+    call.<ext>
+```
+
+## Requirements
+
+- Python >= 3.10
+- `fastmcp` >= 2.3
+- `jinja2` >= 3.1

mcpskills_cli-0.1.0/Untitled-1

@@ -0,0 +1 @@
+mcp-cli --url http://localhost:8032/mcp/8bb059d5-0115-4c08-b994-25c26695b027 --token mcp_token_Na7kQzvA2RxhzvAjT9P3Q0rPiaxlIHUnXiPHCoeMrhE --name neo4j-movie --script python --output .cursor/skills

mcpskills_cli-0.1.0/docs/LOW_TOKEN_SKILLS.md

@@ -0,0 +1,49 @@
+# Auto-Generated Skills for Low Token Consumption
+
+For questions like "show me top 10 products", token cost comes from:
+
+1. **Skill doc reads** – agent loads multiple SKILL.md files
+2. **Exploratory tool calls** – list_tables → get_table_schema → execute_query (3 round-trips)
+
+## Recommendations
+
+### 1. Generate a single skill (do not use `--multi-skills`)
+
+- **One** SKILL.md that documents all MCP tools (list_tables, get_table_schema, execute_query, test_connection).
+- Agent loads 1 skill instead of N → fewer tokens.
+- Run: `mcpskills-cli --url <URL> --token <TOKEN> --name dellstore` (omit `--multi-skills`).
+
+### 2. Add usage guidance in the single skill
+
+Include a short "When to use" so the agent skips discovery when not needed:
+
+- **Known table / clear intent** (e.g. "top 10 products") → use **execute_query** only with a `SELECT ... LIMIT` query.
+- **Unknown database** → use list_tables, then get_table_schema, then execute_query.
+
+This reduces 3 tool calls to 1 for the common case.
+
+### 3. Optional: embed schema at generation time
+
+If the generator can call the MCP at build time (list_tables + get_table_schema) and embed a "Known tables" section into SKILL.md, the agent gets table names and columns in one read and can go straight to execute_query. Requires a new option (e.g. `--include-schema`) and one-off MCP calls during `mcpskills-cli` run.
+
+### 4. MCP server: high-level tools (lowest tokens)
+
+Expose tools such as:
+
+- `get_products(limit=10, offset=0, category=...)`  
+  or  
+- `query_table(table_name, limit, columns, order_by)`
+
+Then the agent: 1 skill + 1 call. mcpskills-cli just generates the skill for that tool; no generator change.
+
+## Summary
+
+| Approach              | Skill reads | Tool calls (e.g. top 10 products) | Token impact   |
+|-----------------------|------------|------------------------------------|----------------|
+| Multi-skills (current)| 3          | 3 (list + schema + query)         | Highest        |
+| Single skill          | 1          | 3                                 | Lower (docs)   |
+| Single skill + guidance | 1        | 1 (execute_query only)            | Lower (docs + calls) |
+| Single skill + embedded schema | 1  | 1                                 | Same as above  |
+| MCP high-level tool   | 1          | 1                                 | Lowest         |
+
+**Practical minimum for mcpskills-cli:** generate **one skill** (no `--multi-skills`) and add **usage guidance** so the agent uses execute_query directly when the intent is clear.

mcpskills_cli-0.1.0/pyproject.toml

@@ -0,0 +1,19 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "mcpskills-cli"
+version = "0.1.0"
+description = "Generate Cursor Agent Skills from MCP server tools"
+requires-python = ">=3.10"
+dependencies = [
+    "fastmcp>=2.3",
+    "jinja2>=3.1",
+]
+
+[project.scripts]
+mcpskills-cli = "mcp_cli.cli:main"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/mcp_cli"]

mcpskills_cli-0.1.0/src/mcp_cli/__init__.py

@@ -0,0 +1,3 @@
+"""mcpskills-cli: Generate Cursor Agent Skills from MCP server tools."""
+
+__version__ = "0.1.0"

mcpskills_cli-0.1.0/src/mcp_cli/cli.py

@@ -0,0 +1,86 @@
+"""CLI entry point for mcpskills-cli."""
+
+import argparse
+import os
+import re
+import sys
+
+from mcp_cli import credentials, client, generator
+
+DEFAULT_OUTPUT = os.path.expanduser("~/.cursor/skills")
+SCRIPT_CHOICES = list(generator.SCRIPT_LANG_MAP.keys())
+
+
+def sanitize_name(s: str) -> str:
+    return re.sub(r"[^a-z0-9]+", "-", s.lower()).strip("-") or "mcp-server"
+
+
+def derive_server_name(url: str) -> str:
+    u = url.rstrip("/")
+    if "/" in u:
+        return sanitize_name(u.split("/")[-1])
+    return sanitize_name(u.replace(":", "-"))
+
+
+def main():
+    ap = argparse.ArgumentParser(
+        prog="mcpskills-cli",
+        description="Generate Cursor Agent Skill from MCP server tools",
+    )
+    ap.add_argument("--url", required=True, help="MCP server URL (Streamable HTTP)")
+    ap.add_argument("--token", required=True, help="Bearer token for auth")
+    ap.add_argument("--output", default=DEFAULT_OUTPUT, help=f"Skills output dir (default: {DEFAULT_OUTPUT})")
+    ap.add_argument("--name", help="Server name (default: derived from URL)")
+    ap.add_argument(
+        "--script",
+        choices=SCRIPT_CHOICES,
+        default="bash",
+        help="Language for the generated call script (default: bash)",
+    )
+    ap.add_argument(
+        "--multi-skills",
+        action="store_true",
+        help="Generate a separate skill for each tool",
+    )
+    args = ap.parse_args()
+
+    server_name = sanitize_name((args.name or derive_server_name(args.url)).strip())
+    url = args.url.rstrip("/") + "/"
+
+    try:
+        tools = client.list_tools(url, args.token)
+    except Exception as e:
+        print(f"Error fetching tools: {e}", file=sys.stderr)
+        sys.exit(1)
+
+    if not tools:
+        print("No tools returned by server.", file=sys.stderr)
+        sys.exit(1)
+
+    credentials.save(server_name, url, args.token)
+    print(f"Credentials saved to {credentials.CREDS_FILE} (chmod 600)")
+
+    result = generator.generate_skill(
+        server_name=server_name,
+        raw_tools=tools,
+        output_dir=os.path.expanduser(args.output),
+        script=args.script,
+        multi_skills=args.multi_skills,
+    )
+    lang_cfg = generator.SCRIPT_LANG_MAP[args.script]
+    
+    if args.multi_skills:
+        print(f"\nSkills generated:")
+        for out_dir in result:
+            print(f"  {out_dir}")
+    else:
+        out_dir = result
+        call_file = os.path.join(out_dir, "scripts", f"call.{lang_cfg['ext']}")
+        print(f"Skill generated at {out_dir}")
+        print(f"  SKILL.md ({len(tools)} tools)")
+        print(f"  scripts/call.{lang_cfg['ext']}")
+        print(f"Usage: {lang_cfg['bin']} {call_file} <tool_name> '{{}}' ")
+
+
+if __name__ == "__main__":
+    main()

mcpskills_cli-0.1.0/src/mcp_cli/client.py

@@ -0,0 +1,18 @@
+"""MCP client wrapper using fastmcp."""
+
+import asyncio
+from typing import Any
+
+from fastmcp import Client
+from fastmcp.client.transports import StreamableHttpTransport
+
+
+async def _list_tools(url: str, token: str) -> list[dict[str, Any]]:
+    transport = StreamableHttpTransport(url, auth=token)
+    async with Client(transport) as client:
+        tools = await client.list_tools()
+        return [t.model_dump() for t in tools]
+
+
+def list_tools(url: str, token: str) -> list[dict[str, Any]]:
+    return asyncio.run(_list_tools(url, token))

mcpskills_cli-0.1.0/src/mcp_cli/credentials.py

@@ -0,0 +1,41 @@
+"""Manage MCP server credentials in ~/.mcps/credentials (INI format, chmod 600)."""
+
+import configparser
+import os
+from dataclasses import dataclass
+
+CREDS_DIR = os.path.expanduser("~/.mcps")
+CREDS_FILE = os.path.join(CREDS_DIR, "credentials")
+
+
+@dataclass
+class ServerCredentials:
+    url: str
+    token: str
+
+
+def save(server_name: str, url: str, token: str) -> None:
+    os.makedirs(CREDS_DIR, mode=0o700, exist_ok=True)
+    cfg = configparser.ConfigParser()
+    if os.path.isfile(CREDS_FILE):
+        cfg.read(CREDS_FILE)
+    if server_name not in cfg:
+        cfg[server_name] = {}
+    cfg[server_name]["url"] = url
+    cfg[server_name]["token"] = token
+    with open(CREDS_FILE, "w") as f:
+        cfg.write(f)
+    os.chmod(CREDS_FILE, 0o600)
+
+
+def load(server_name: str) -> ServerCredentials:
+    cfg = configparser.ConfigParser()
+    if not os.path.isfile(CREDS_FILE):
+        raise FileNotFoundError(f"Missing {CREDS_FILE}")
+    cfg.read(CREDS_FILE)
+    if server_name not in cfg:
+        raise KeyError(f"No section [{server_name}] in {CREDS_FILE}")
+    return ServerCredentials(
+        url=cfg[server_name]["url"],
+        token=cfg[server_name]["token"],
+    )

mcpskills_cli-0.1.0/src/mcp_cli/generator.py

@@ -0,0 +1,170 @@
+"""Fetch MCP tools, render templates, write skill output."""
+
+import json
+import os
+from dataclasses import dataclass
+from typing import Any
+
+import jinja2
+
+SCRIPT_LANG_MAP = {
+    "bash": {
+        "template": "call_bash.sh.j2",
+        "ext": "sh",
+        "bin": "bash",
+        "lang": "bash",
+    },
+    "python": {
+        "template": "call_python.py.j2",
+        "ext": "py",
+        "bin": "python3",
+        "lang": "python",
+    },
+    "node": {
+        "template": "call_node.js.j2",
+        "ext": "js",
+        "bin": "node",
+        "lang": "javascript",
+    },
+    "go": {
+        "template": "call_go.go.j2",
+        "ext": "go",
+        "bin": "go run",
+        "lang": "go",
+    },
+    "rust": {
+        "template": "call_rust.rs.j2",
+        "ext": "rs",
+        "bin": "cargo run --",
+        "lang": "rust",
+    },
+}
+
+
+@dataclass
+class ToolParam:
+    name: str
+    type: str
+    required: str
+    description: str
+
+
+@dataclass
+class ToolInfo:
+    name: str
+    description: str
+    params: list[ToolParam]
+    required_params: list[str]
+    example_args: str
+
+
+def parse_tool(raw: dict[str, Any]) -> ToolInfo:
+    schema = raw.get("inputSchema") or {}
+    props = schema.get("properties") or {}
+    required_set = set(schema.get("required") or [])
+    params = []
+    for key, spec in props.items():
+        if isinstance(spec, dict):
+            params.append(ToolParam(
+                name=key,
+                type=spec.get("type", "any"),
+                required="required" if key in required_set else "optional",
+                description=(spec.get("description") or "").strip(),
+            ))
+        else:
+            params.append(
+                ToolParam(name=key, type="any", required="optional", description="")
+            )
+    req_params = [p.name for p in params if p.required == "required"]
+    example = (
+        json.dumps({k: f"<{k}>" for k in req_params}) if req_params else ""
+    )
+    return ToolInfo(
+        name=raw.get("name", "unknown"),
+        description=(raw.get("description") or "No description.").strip(),
+        params=params,
+        required_params=req_params,
+        example_args=example,
+    )
+
+
+def _get_env() -> jinja2.Environment:
+    return jinja2.Environment(
+        loader=jinja2.PackageLoader("mcp_cli", "templates"),
+        keep_trailing_newline=True,
+        trim_blocks=True,
+        lstrip_blocks=True,
+    )
+
+
+def generate_skill(
+    server_name: str,
+    raw_tools: list[dict[str, Any]],
+    output_dir: str,
+    script: str = "bash",
+    multi_skills: bool = False,
+) -> str | list[str]:
+    env = _get_env()
+    tools = [parse_tool(t) for t in raw_tools]
+    lang_cfg = SCRIPT_LANG_MAP[script]
+
+    if multi_skills:
+        generated_dirs = []
+        for tool in tools:
+            out_dir = os.path.join(output_dir, f"{server_name}-{tool.name}")
+            scripts_dir = os.path.join(out_dir, "scripts")
+            os.makedirs(scripts_dir, exist_ok=True)
+            skill_path = os.path.abspath(out_dir)
+
+            skill_md = env.get_template("skill_single.md.j2").render(
+                server_name=server_name,
+                tool=tool,
+                skill_path=skill_path,
+                script_lang=lang_cfg["lang"],
+                script_bin=lang_cfg["bin"],
+                script_ext=lang_cfg["ext"],
+            )
+            with open(os.path.join(out_dir, "SKILL.md"), "w") as f:
+                f.write(skill_md)
+
+            call_content = env.get_template(lang_cfg["template"]).render(
+                server_name=server_name
+            )
+            call_filename = f"call.{lang_cfg['ext']}"
+            call_path = os.path.join(scripts_dir, call_filename)
+            with open(call_path, "w") as f:
+                f.write(call_content)
+            os.chmod(call_path, 0o755)
+
+            generated_dirs.append(out_dir)
+
+        return generated_dirs
+    else:
+        tool_names = ", ".join(t.name for t in tools)
+        out_dir = os.path.join(output_dir, server_name)
+        scripts_dir = os.path.join(out_dir, "scripts")
+        os.makedirs(scripts_dir, exist_ok=True)
+        skill_path = os.path.abspath(out_dir)
+
+        skill_md = env.get_template("skill.md.j2").render(
+            server_name=server_name,
+            tools=tools,
+            tool_names=tool_names,
+            skill_path=skill_path,
+            script_lang=lang_cfg["lang"],
+            script_bin=lang_cfg["bin"],
+            script_ext=lang_cfg["ext"],
+        )
+        with open(os.path.join(out_dir, "SKILL.md"), "w") as f:
+            f.write(skill_md)
+
+        call_content = env.get_template(lang_cfg["template"]).render(
+            server_name=server_name
+        )
+        call_filename = f"call.{lang_cfg['ext']}"
+        call_path = os.path.join(scripts_dir, call_filename)
+        with open(call_path, "w") as f:
+            f.write(call_content)
+        os.chmod(call_path, 0o755)
+
+        return out_dir

mcpskills_cli-0.1.0/src/mcp_cli/templates/call_bash.sh.j2

@@ -0,0 +1,57 @@
+#!/usr/bin/env bash
+set -e
+SERVER="{{ server_name }}"
+CREDS="${HOME}/.mcps/credentials"
+if [[ ! -f "$CREDS" ]]; then
+  echo "Missing $CREDS" >&2
+  exit 1
+fi
+get_ini() {
+  local section="$1" key="$2"
+  awk -v S="\\[$section\\]" -v K="$key" '
+    $0 ~ S { found=1; next }
+    found && /^\[/ { exit }
+    found && $0 ~ "^" K "[[:space:]]*=" { sub(/^[^=]*=[[:space:]]*/, ""); print; exit }
+  ' "$CREDS"
+}
+URL=$(get_ini "$SERVER" "url")
+TOKEN=$(get_ini "$SERVER" "token")
+if [[ -z "$URL" || -z "$TOKEN" ]]; then
+  echo "Missing url or token for [$SERVER] in $CREDS" >&2
+  exit 1
+fi
+[[ "$URL" != */ ]] && URL="$URL/"
+TOOL="$1"
+ARGS="${2:-{}}"
+if [[ -z "$TOOL" ]]; then
+  echo "Usage: $0 <tool_name> [json_args]" >&2
+  exit 1
+fi
+BODY=$(python3 -c "
+import json, sys
+name, raw = sys.argv[1], sys.argv[2] if len(sys.argv) > 2 else '{}'
+try: args = json.loads(raw)
+except: args = {}
+print(json.dumps({'jsonrpc':'2.0','method':'tools/call','params':{'name':name,'arguments':args},'id':1}))
+" "$TOOL" "$ARGS")
+RESPONSE=$(curl -s --max-time 30 -X POST "$URL" \
+  -H "Authorization: Bearer $TOKEN" \
+  -H "Content-Type: application/json" \
+  -H "Accept: application/json, text/event-stream" \
+  -H "MCP-Protocol-Version: 2025-06-18" \
+  -d "$BODY")
+echo "$RESPONSE" | python3 -c "
+import json, sys
+text = sys.stdin.read().strip()
+for line in text.split('\n'):
+    if line.startswith('data:'):
+        line = line[5:].strip()
+    if not line or line == '[DONE]': continue
+    try:
+        obj = json.loads(line)
+        if 'result' in obj or 'error' in obj:
+            print(json.dumps(obj, indent=2))
+            sys.exit(0)
+    except json.JSONDecodeError: pass
+print(text)
+"

mcpskills_cli-0.1.0/src/mcp_cli/templates/call_go.go.j2

@@ -0,0 +1,113 @@
+// Call MCP tool on server '{{ server_name }}'.
+// Usage: go run call.go <tool_name> [json_args]
+package main
+
+import (
+	"bufio"
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"os"
+	"path/filepath"
+	"strings"
+	"time"
+)
+
+const server = "{{ server_name }}"
+
+func loadCredentials() (string, string) {
+	home, _ := os.UserHomeDir()
+	data, err := os.ReadFile(filepath.Join(home, ".mcps", "credentials"))
+	if err != nil {
+		fmt.Fprintln(os.Stderr, err)
+		os.Exit(1)
+	}
+	var url, token string
+	inSection := false
+	scanner := bufio.NewScanner(bytes.NewReader(data))
+	for scanner.Scan() {
+		line := strings.TrimSpace(scanner.Text())
+		if line == fmt.Sprintf("[%s]", server) {
+			inSection = true
+			continue
+		}
+		if inSection && strings.HasPrefix(line, "[") {
+			break
+		}
+		if inSection {
+			if k, v, ok := strings.Cut(line, "="); ok {
+				switch strings.TrimSpace(k) {
+				case "url":
+					url = strings.TrimSpace(v)
+				case "token":
+					token = strings.TrimSpace(v)
+				}
+			}
+		}
+	}
+	if url == "" || token == "" {
+		fmt.Fprintf(os.Stderr, "Missing url or token for [%s]\n", server)
+		os.Exit(1)
+	}
+	if !strings.HasSuffix(url, "/") {
+		url += "/"
+	}
+	return url, token
+}
+
+func main() {
+	if len(os.Args) < 2 {
+		fmt.Fprintf(os.Stderr, "Usage: %s <tool_name> [json_args]\n", os.Args[0])
+		os.Exit(1)
+	}
+	toolName := os.Args[1]
+	args := json.RawMessage("{}")
+	if len(os.Args) > 2 {
+		args = json.RawMessage(os.Args[2])
+	}
+	url, token := loadCredentials()
+	body, _ := json.Marshal(map[string]any{
+		"jsonrpc": "2.0",
+		"method":  "tools/call",
+		"params":  map[string]any{"name": toolName, "arguments": args},
+		"id":      1,
+	})
+	req, _ := http.NewRequest("POST", url, bytes.NewReader(body))
+	req.Header.Set("Authorization", "Bearer "+token)
+	req.Header.Set("Content-Type", "application/json")
+	req.Header.Set("Accept", "application/json, text/event-stream")
+	req.Header.Set("MCP-Protocol-Version", "2025-06-18")
+	client := &http.Client{Timeout: 30 * time.Second}
+	resp, err := client.Do(req)
+	if err != nil {
+		fmt.Fprintln(os.Stderr, err)
+		os.Exit(1)
+	}
+	defer resp.Body.Close()
+	raw, _ := io.ReadAll(resp.Body)
+	for _, line := range strings.Split(string(raw), "\n") {
+		line = strings.TrimSpace(line)
+		if strings.HasPrefix(line, "data:") {
+			line = strings.TrimSpace(line[5:])
+		}
+		if line == "" || line == "[DONE]" {
+			continue
+		}
+		var obj map[string]any
+		if json.Unmarshal([]byte(line), &obj) == nil {
+			if _, ok := obj["result"]; ok {
+				out, _ := json.MarshalIndent(obj, "", "  ")
+				fmt.Println(string(out))
+				return
+			}
+			if _, ok := obj["error"]; ok {
+				out, _ := json.MarshalIndent(obj, "", "  ")
+				fmt.Println(string(out))
+				return
+			}
+		}
+	}
+	fmt.Println(string(raw))
+}

mcpskills_cli-0.1.0/src/mcp_cli/templates/call_node.js.j2

@@ -0,0 +1,63 @@
+#!/usr/bin/env node
+// Call MCP tool on server '{{ server_name }}'
+const fs = require("fs");
+const path = require("path");
+
+const SERVER = "{{ server_name }}";
+const CREDS_FILE = path.join(process.env.HOME, ".mcps", "credentials");
+
+function loadCredentials() {
+  const text = fs.readFileSync(CREDS_FILE, "utf-8");
+  const section = new RegExp(`\\[${SERVER}\\]([\\s\\S]*?)(?=\\n\\[|$)`);
+  const match = text.match(section);
+  if (!match) {
+    console.error(`No section [${SERVER}] in ${CREDS_FILE}`);
+    process.exit(1);
+  }
+  const block = match[1];
+  const url = block.match(/^url\s*=\s*(.+)$/m)?.[1]?.trim();
+  const token = block.match(/^token\s*=\s*(.+)$/m)?.[1]?.trim();
+  if (!url || !token) {
+    console.error(`Missing url or token for [${SERVER}]`);
+    process.exit(1);
+  }
+  return { url: url.replace(/\/?$/, "/"), token };
+}
+
+async function callTool(toolName, args) {
+  const { url, token } = loadCredentials();
+  const body = JSON.stringify({
+    jsonrpc: "2.0",
+    method: "tools/call",
+    params: { name: toolName, arguments: args },
+    id: 1,
+  });
+  const resp = await fetch(url, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${token}`,
+      "Content-Type": "application/json",
+      Accept: "application/json, text/event-stream",
+      "MCP-Protocol-Version": "2025-06-18",
+    },
+    body,
+  });
+  const text = await resp.text();
+  for (const line of text.split("\n")) {
+    let data = line.startsWith("data:") ? line.slice(5).trim() : line.trim();
+    if (!data || data === "[DONE]") continue;
+    try {
+      const obj = JSON.parse(data);
+      if (obj.result || obj.error) return obj;
+    } catch {}
+  }
+  return JSON.parse(text);
+}
+
+const [toolName, rawArgs] = process.argv.slice(2);
+if (!toolName) {
+  console.error(`Usage: ${process.argv[1]} <tool_name> [json_args]`);
+  process.exit(1);
+}
+const args = rawArgs ? JSON.parse(rawArgs) : {};
+callTool(toolName, args).then((r) => console.log(JSON.stringify(r, null, 2)));

mcpskills_cli-0.1.0/src/mcp_cli/templates/call_python.py.j2

@@ -0,0 +1,63 @@
+#!/usr/bin/env python3
+"""Call MCP tool on server '{{ server_name }}'."""
+import configparser
+import json
+import os
+import sys
+import urllib.request
+
+SERVER = "{{ server_name }}"
+CREDS_FILE = os.path.expanduser("~/.mcps/credentials")
+
+
+def load_credentials():
+    cfg = configparser.ConfigParser()
+    cfg.read(CREDS_FILE)
+    if SERVER not in cfg:
+        print(f"No section [{SERVER}] in {CREDS_FILE}", file=sys.stderr)
+        sys.exit(1)
+    return cfg[SERVER]["url"], cfg[SERVER]["token"]
+
+
+def call_tool(tool_name: str, arguments: dict) -> dict:
+    url, token = load_credentials()
+    url = url.rstrip("/") + "/"
+    body = json.dumps({
+        "jsonrpc": "2.0",
+        "method": "tools/call",
+        "params": {"name": tool_name, "arguments": arguments},
+        "id": 1,
+    }).encode()
+    req = urllib.request.Request(
+        url, data=body, method="POST",
+        headers={
+            "Authorization": f"Bearer {token}",
+            "Content-Type": "application/json",
+            "Accept": "application/json, text/event-stream",
+            "MCP-Protocol-Version": "2025-06-18",
+        },
+    )
+    with urllib.request.urlopen(req, timeout=30) as resp:
+        text = resp.read().decode()
+    for line in text.strip().split("\n"):
+        if line.startswith("data:"):
+            line = line[5:].strip()
+        if not line or line == "[DONE]":
+            continue
+        try:
+            obj = json.loads(line)
+            if "result" in obj or "error" in obj:
+                return obj
+        except json.JSONDecodeError:
+            pass
+    return json.loads(text)
+
+
+if __name__ == "__main__":
+    if len(sys.argv) < 2:
+        print(f"Usage: {sys.argv[0]} <tool_name> [json_args]", file=sys.stderr)
+        sys.exit(1)
+    tool = sys.argv[1]
+    args = json.loads(sys.argv[2]) if len(sys.argv) > 2 else {}
+    result = call_tool(tool, args)
+    print(json.dumps(result, indent=2))

mcpskills_cli-0.1.0/src/mcp_cli/templates/call_rust.rs.j2

@@ -0,0 +1,101 @@
+// Call MCP tool on server '{{ server_name }}'.
+// Dependencies: ureq, serde_json
+//   cargo install cargo-script  OR  use a Cargo.toml with:
+//     [dependencies]
+//     ureq = "2"
+//     serde_json = "1"
+// Usage: cargo run -- <tool_name> [json_args]
+
+use std::env;
+use std::fs;
+use std::path::PathBuf;
+use std::process;
+
+const SERVER: &str = "{{ server_name }}";
+
+fn creds_path() -> PathBuf {
+    let home = env::var("HOME").unwrap_or_else(|_| ".".into());
+    PathBuf::from(home).join(".mcps").join("credentials")
+}
+
+fn load_credentials() -> (String, String) {
+    let text = fs::read_to_string(creds_path()).unwrap_or_else(|e| {
+        eprintln!("Cannot read credentials: {}", e);
+        process::exit(1);
+    });
+    let header = format!("[{}]", SERVER);
+    let mut in_section = false;
+    let (mut url, mut token) = (String::new(), String::new());
+    for line in text.lines() {
+        let trimmed = line.trim();
+        if trimmed == header {
+            in_section = true;
+            continue;
+        }
+        if in_section && trimmed.starts_with('[') {
+            break;
+        }
+        if in_section {
+            if let Some((k, v)) = trimmed.split_once('=') {
+                match k.trim() {
+                    "url" => url = v.trim().to_string(),
+                    "token" => token = v.trim().to_string(),
+                    _ => {}
+                }
+            }
+        }
+    }
+    if url.is_empty() || token.is_empty() {
+        eprintln!("Missing url or token for [{}]", SERVER);
+        process::exit(1);
+    }
+    if !url.ends_with('/') {
+        url.push('/');
+    }
+    (url, token)
+}
+
+fn main() {
+    let args: Vec<String> = env::args().collect();
+    if args.len() < 2 {
+        eprintln!("Usage: {} <tool_name> [json_args]", args[0]);
+        process::exit(1);
+    }
+    let tool_name = &args[1];
+    let tool_args: serde_json::Value = if args.len() > 2 {
+        serde_json::from_str(&args[2]).unwrap_or(serde_json::json!({}))
+    } else {
+        serde_json::json!({})
+    };
+    let (url, token) = load_credentials();
+    let body = serde_json::json!({
+        "jsonrpc": "2.0",
+        "method": "tools/call",
+        "params": {"name": tool_name, "arguments": tool_args},
+        "id": 1
+    });
+    let resp = ureq::post(&url)
+        .set("Authorization", &format!("Bearer {}", token))
+        .set("Content-Type", "application/json")
+        .set("Accept", "application/json, text/event-stream")
+        .set("MCP-Protocol-Version", "2025-06-18")
+        .send_string(&body.to_string())
+        .unwrap_or_else(|e| {
+            eprintln!("Request failed: {}", e);
+            process::exit(1);
+        });
+    let text = resp.into_string().unwrap_or_default();
+    for line in text.lines() {
+        let data = if line.starts_with("data:") { line[5..].trim() } else { line.trim() };
+        if data.is_empty() || data == "[DONE]" {
+            continue;
+        }
+        if let Ok(obj) = serde_json::from_str::<serde_json::Value>(data) {
+            if obj.get("result").is_some() || obj.get("error").is_some() {
+                println!("{}", serde_json::to_string_pretty(&obj).unwrap());
+                return;
+            }
+        }
+    }
+    println!("{}", text);
+}

mcpskills_cli-0.1.0/src/mcp_cli/templates/skill.md.j2

@@ -0,0 +1,27 @@
+---
+name: {{ server_name }}
+description: MCP tools for {{ server_name }}. Available tools: {{ tool_names }}. Use when the user needs to call these MCP tools.
+---
+
+# {{ server_name }} MCP Tools
+
+## Available Tools
+{% for tool in tools %}
+
+### {{ tool.name }}
+
+{{ tool.description | default("No description.", true) }}
+{% if tool.params %}
+
+**Parameters:**
+{% for p in tool.params %}
+- `{{ p.name }}` ({{ p.type }}, {{ p.required }}): {{ p.description | default("-", true) }}
+{% endfor %}
+{% endif %}
+
+**Execute:**
+```{{ script_lang }}
+{{ script_bin }} {{ skill_path }}/scripts/call.{{ script_ext }} {{ tool.name }}{% if tool.required_params %} '{{ tool.example_args }}'{% endif %}
+
+```
+{% endfor %}

mcpskills_cli-0.1.0/src/mcp_cli/templates/skill_single.md.j2

@@ -0,0 +1,21 @@
+---
+name: {{ server_name }}-{{ tool.name }}
+description: MCP tool {{ tool.name }} from {{ server_name }}. {{ tool.description }}
+---
+
+# {{ tool.name }}
+
+{{ tool.description | default("No description.", true) }}
+{% if tool.params %}
+
+**Parameters:**
+{% for p in tool.params %}
+- `{{ p.name }}` ({{ p.type }}, {{ p.required }}): {{ p.description | default("-", true) }}
+{% endfor %}
+{% endif %}
+
+**Execute:**
+```{{ script_lang }}
+{{ script_bin }} {{ skill_path }}/scripts/call.{{ script_ext }} {{ tool.name }}{% if tool.required_params %} '{{ tool.example_args }}'{% endif %}
+
+```

mcpskills_cli-0.1.0/test_token_compare.py

@@ -0,0 +1,107 @@
+import json
+import urllib.request
+import tiktoken
+
+SERVERS = {
+    "dellstore": {
+        "url": "http://localhost:8027/mcp/a0504710-203f-4c4b-b864-5e64641d9ed3/",
+        "token": "mcp_token_bb1HbX3e-wykRQYziLNaGGYod_qhxrlffUm4DxmMn7w",
+        "skill": ".cursor/skills/dellstore/SKILL.md",
+    },
+    "neo4j-movie": {
+        "url": "http://localhost:8032/mcp/8bb059d5-0115-4c08-b994-25c26695b027/",
+        "token": "mcp_token_Na7kQzvA2RxhzvAjT9P3Q0rPiaxlIHUnXiPHCoeMrhE",
+        "skill": ".cursor/skills/neo4j-movie/SKILL.md",
+    },
+}
+
+enc = tiktoken.encoding_for_model("gpt-4o")
+
+
+def count_tokens(text: str) -> int:
+    return len(enc.encode(text))
+
+
+def get_mcp_tools_payload(url: str, token: str) -> str:
+    body = json.dumps({
+        "jsonrpc": "2.0",
+        "method": "tools/list",
+        "params": {},
+        "id": 1,
+    }).encode()
+    req = urllib.request.Request(
+        url, data=body, method="POST",
+        headers={
+            "Authorization": f"Bearer {token}",
+            "Content-Type": "application/json",
+            "Accept": "application/json, text/event-stream",
+            "MCP-Protocol-Version": "2025-06-18",
+        },
+    )
+    with urllib.request.urlopen(req, timeout=30) as resp:
+        text = resp.read().decode()
+    for line in text.strip().split("\n"):
+        if line.startswith("data:"):
+            line = line[5:].strip()
+        if not line or line == "[DONE]":
+            continue
+        try:
+            obj = json.loads(line)
+            if "result" in obj:
+                return json.dumps(obj["result"]["tools"], indent=2)
+        except json.JSONDecodeError:
+            pass
+    return text
+
+
+def main():
+    print("=" * 60)
+    print("MCP Tools vs Skills — Token Comparison")
+    print("=" * 60)
+
+    mcp_payloads = {}
+    skill_payloads = {}
+
+    for name, cfg in SERVERS.items():
+        print(f"\n--- {name} ---")
+
+        mcp_json = get_mcp_tools_payload(cfg["url"], cfg["token"])
+        mcp_payloads[name] = mcp_json
+
+        with open(cfg["skill"]) as f:
+            skill_md = f.read()
+        skill_payloads[name] = skill_md
+
+        mcp_tokens = count_tokens(mcp_json)
+        skill_tokens = count_tokens(skill_md)
+        saved = mcp_tokens - skill_tokens
+        pct = (saved / mcp_tokens * 100) if mcp_tokens else 0
+
+        print(f"  MCP JSON schema tokens : {mcp_tokens:>6}")
+        print(f"  Skill markdown tokens  : {skill_tokens:>6}")
+        print(f"  Savings                : {saved:>6} ({pct:.1f}%)")
+
+    print("\n" + "=" * 60)
+    print("Multi-server scenario (all servers active)")
+    print("=" * 60)
+
+    all_mcp = "\n".join(mcp_payloads.values())
+    all_mcp_tokens = count_tokens(all_mcp)
+
+    print(f"\n  Traditional MCP (all tools every turn) : {all_mcp_tokens:>6} tokens")
+
+    for name, skill_md in skill_payloads.items():
+        t = count_tokens(skill_md)
+        saved = all_mcp_tokens - t
+        pct = (saved / all_mcp_tokens * 100) if all_mcp_tokens else 0
+        print(f"  Skill '{name}' only              : {t:>6} tokens  (saves {saved}, {pct:.1f}%)")
+
+    all_skills = "\n".join(skill_payloads.values())
+    all_skills_tokens = count_tokens(all_skills)
+    saved = all_mcp_tokens - all_skills_tokens
+    pct = (saved / all_mcp_tokens * 100) if all_mcp_tokens else 0
+    print(f"  All skills loaded (worst case)         : {all_skills_tokens:>6} tokens  (saves {saved}, {pct:.1f}%)")
+
+
+if __name__ == "__main__":
+    main()