mcpswitch-cli 0.1.0__py3-none-any.whl

mcpswitch/community.py

@@ -0,0 +1,209 @@
+"""Community profiles — discover and install curated MCP stacks.
+
+Backend: GitHub repo (mcpswitch/community-profiles) — no server needed.
+Anyone can submit a profile via PR. MCPSwitch fetches the index from GitHub.
+
+Pro feature:
+  mcpswitch community list               → browse available stacks
+  mcpswitch community install react       → install a community profile locally
+  mcpswitch community publish my-stack   → submit your profile (opens GitHub PR)
+  mcpswitch community info react          → show details about a profile
+"""
+
+import json
+import urllib.request
+import urllib.error
+from typing import Optional
+
+# GitHub repo that hosts community profiles
+COMMUNITY_REPO   = "mcpswitch-dev/community-profiles"
+COMMUNITY_BRANCH = "main"
+INDEX_URL = (
+    f"https://raw.githubusercontent.com/{COMMUNITY_REPO}/"
+    f"{COMMUNITY_BRANCH}/index.json"
+)
+PROFILE_BASE_URL = (
+    f"https://raw.githubusercontent.com/{COMMUNITY_REPO}/"
+    f"{COMMUNITY_BRANCH}/profiles"
+)
+
+# Fallback built-in profiles (used when GitHub is unreachable)
+BUILTIN_PROFILES = {
+    "react-fullstack": {
+        "name": "react-fullstack",
+        "description": "React + TypeScript + Postgres + GitHub",
+        "author": "mcpswitch",
+        "stars": 0,
+        "tags": ["react", "typescript", "postgres", "frontend"],
+        "servers": ["github", "playwright", "postgres", "context7"],
+        "builtin": True,
+    },
+    "python-api": {
+        "name": "python-api",
+        "description": "FastAPI + Postgres + GitHub — Python backend development",
+        "author": "mcpswitch",
+        "stars": 0,
+        "tags": ["python", "fastapi", "postgres", "backend"],
+        "servers": ["github", "postgres", "context7", "sequential-thinking"],
+        "builtin": True,
+    },
+    "go-backend": {
+        "name": "go-backend",
+        "description": "Go API development — GitHub + context7 only",
+        "author": "mcpswitch",
+        "stars": 0,
+        "tags": ["go", "golang", "backend", "api"],
+        "servers": ["github", "context7"],
+        "builtin": True,
+    },
+    "writing-docs": {
+        "name": "writing-docs",
+        "description": "Documentation and writing — filesystem + fetch, no code tools",
+        "author": "mcpswitch",
+        "stars": 0,
+        "tags": ["writing", "docs", "markdown"],
+        "servers": ["filesystem", "fetch"],
+        "builtin": True,
+    },
+    "data-analysis": {
+        "name": "data-analysis",
+        "description": "Data analysis — SQLite + Postgres + sequential thinking",
+        "author": "mcpswitch",
+        "stars": 0,
+        "tags": ["data", "sql", "analysis", "sqlite"],
+        "servers": ["sqlite", "postgres", "sequential-thinking", "filesystem"],
+        "builtin": True,
+    },
+    "scraping": {
+        "name": "scraping",
+        "description": "Web scraping and automation — Playwright + Brave Search",
+        "author": "mcpswitch",
+        "stars": 0,
+        "tags": ["scraping", "automation", "browser", "playwright"],
+        "servers": ["playwright", "brave-search", "fetch"],
+        "builtin": True,
+    },
+    "devops": {
+        "name": "devops",
+        "description": "DevOps and infra — GitHub + filesystem + fetch",
+        "author": "mcpswitch",
+        "stars": 0,
+        "tags": ["devops", "ci", "github-actions", "infra"],
+        "servers": ["github", "filesystem", "fetch"],
+        "builtin": True,
+    },
+    "minimal": {
+        "name": "minimal",
+        "description": "Absolute minimum — sequential thinking only. Max context space.",
+        "author": "mcpswitch",
+        "stars": 0,
+        "tags": ["minimal", "lean", "context"],
+        "servers": ["sequential-thinking"],
+        "builtin": True,
+    },
+}
+
+
+def _fetch_url(url: str, timeout: int = 5) -> Optional[dict]:
+    try:
+        req = urllib.request.Request(url, headers={"User-Agent": "mcpswitch/0.1"})
+        with urllib.request.urlopen(req, timeout=timeout) as resp:
+            return json.loads(resp.read())
+    except Exception:
+        return None
+
+
+def list_community_profiles(tag: Optional[str] = None) -> list[dict]:
+    """Fetch community profile index. Falls back to built-ins if offline."""
+    remote = _fetch_url(INDEX_URL)
+
+    if remote and isinstance(remote, list):
+        profiles = remote
+    else:
+        profiles = list(BUILTIN_PROFILES.values())
+
+    if tag:
+        profiles = [p for p in profiles if tag.lower() in [t.lower() for t in p.get("tags", [])]]
+
+    return sorted(profiles, key=lambda p: p.get("stars", 0), reverse=True)
+
+
+def get_profile_detail(name: str) -> Optional[dict]:
+    """Fetch full profile detail including exact server configs."""
+    # Try built-in first
+    if name in BUILTIN_PROFILES:
+        profile = dict(BUILTIN_PROFILES[name])
+        # Convert server list to minimal configs (user still needs real configs)
+        profile["server_configs"] = {
+            srv: {"command": "npx", "args": [f"@modelcontextprotocol/server-{srv}"]}
+            for srv in profile.get("servers", [])
+        }
+        return profile
+
+    # Try remote
+    url = f"{PROFILE_BASE_URL}/{name}.json"
+    return _fetch_url(url)
+
+
+def install_community_profile(name: str) -> dict:
+    """Install a community profile locally.
+
+    For built-in profiles: creates the profile with server name stubs.
+    User configures actual server commands afterward.
+
+    Returns {"success": bool, "profile_name": str, "servers": [...], "message": str}
+    """
+    from .profiles import create_profile
+
+    detail = get_profile_detail(name)
+    if not detail:
+        return {"success": False, "profile_name": name,
+                "servers": [], "message": f"Profile '{name}' not found."}
+
+    # Build server config stubs from server list
+    server_configs = detail.get("server_configs", {})
+    if not server_configs and "servers" in detail:
+        server_configs = {
+            srv: {"command": "npx", "args": [f"@modelcontextprotocol/server-{srv}"]}
+            for srv in detail["servers"]
+        }
+
+    create_profile(name, server_configs)
+
+    return {
+        "success": True,
+        "profile_name": name,
+        "servers": list(server_configs.keys()),
+        "description": detail.get("description", ""),
+        "message": (
+            f"Installed '{name}' with {len(server_configs)} server stub(s).\n"
+            f"Edit server commands: mcpswitch edit {name}"
+        ),
+    }
+
+
+def publish_profile_url(profile_name: str, author: str = "") -> str:
+    """Return the GitHub URL to submit a community profile PR."""
+    import urllib.parse
+    title = urllib.parse.quote(f"Add community profile: {profile_name}")
+    body = urllib.parse.quote(
+        f"**Profile name:** {profile_name}\n"
+        f"**Author:** {author or 'anonymous'}\n\n"
+        f"<!-- Add your profile JSON below -->\n"
+    )
+    return (
+        f"https://github.com/{COMMUNITY_REPO}/issues/new"
+        f"?title={title}&body={body}&labels=new-profile"
+    )
+
+
+def search_profiles(query: str) -> list[dict]:
+    """Search profiles by name, description, or tags."""
+    q = query.lower()
+    all_profiles = list_community_profiles()
+    return [
+        p for p in all_profiles
+        if q in p.get("name", "").lower()
+        or q in p.get("description", "").lower()
+        or any(q in t.lower() for t in p.get("tags", []))
+    ]

mcpswitch/config.py

@@ -0,0 +1,62 @@
+"""Read and write Claude MCP config files."""
+
+import json
+import os
+import platform
+import shutil
+from pathlib import Path
+from typing import Optional
+
+
+def get_claude_code_config_path() -> Path:
+    """~/.claude/claude_desktop_config.json — used by Claude Code CLI."""
+    return Path.home() / ".claude" / "claude_desktop_config.json"
+
+
+def get_claude_desktop_config_path() -> Optional[Path]:
+    """AppData/Roaming/Claude/claude_desktop_config.json — Claude Desktop app."""
+    if platform.system() == "Windows":
+        appdata = os.environ.get("APPDATA", "")
+        if appdata:
+            return Path(appdata) / "Claude" / "claude_desktop_config.json"
+    elif platform.system() == "Darwin":
+        return Path.home() / "Library" / "Application Support" / "Claude" / "claude_desktop_config.json"
+    elif platform.system() == "Linux":
+        return Path.home() / ".config" / "Claude" / "claude_desktop_config.json"
+    return None
+
+
+def read_config(path: Path) -> dict:
+    """Read a Claude config file. Returns empty dict if not found."""
+    if not path.exists():
+        return {}
+    with open(path, "r", encoding="utf-8") as f:
+        return json.load(f)
+
+
+def write_config(path: Path, data: dict) -> None:
+    """Write config atomically with backup."""
+    path.parent.mkdir(parents=True, exist_ok=True)
+
+    # Backup before overwrite
+    if path.exists():
+        backup = path.with_suffix(".json.bak")
+        shutil.copy2(path, backup)
+
+    tmp = path.with_suffix(".json.tmp")
+    with open(tmp, "w", encoding="utf-8") as f:
+        json.dump(data, f, indent=2)
+    tmp.replace(path)
+
+
+def get_all_mcp_servers(path: Path) -> dict:
+    """Return the mcpServers dict from a config file."""
+    config = read_config(path)
+    return config.get("mcpServers", {})
+
+
+def set_mcp_servers(path: Path, servers: dict) -> None:
+    """Replace mcpServers in config, preserving all other keys."""
+    config = read_config(path)
+    config["mcpServers"] = servers
+    write_config(path, config)

mcpswitch/email.py

@@ -0,0 +1,204 @@
+"""Weekly token savings digest email via Resend.
+
+Pro feature: sends a weekly summary of:
+- Which MCPs were called most
+- How many tokens were saved vs loading everything
+- Waste alerts
+- Top recommendation for next week
+
+Setup: mcpswitch digest --setup your@email.com --api-key re_xxx
+Send:  mcpswitch digest --send
+Auto:  add to cron/task scheduler — mcpswitch digest --send --quiet
+"""
+
+import json
+import time
+from pathlib import Path
+from typing import Optional
+
+DIGEST_CONFIG_FILE = Path.home() / ".mcpswitch" / "digest.json"
+
+
+def _load_config() -> dict:
+    if not DIGEST_CONFIG_FILE.exists():
+        return {}
+    try:
+        with open(DIGEST_CONFIG_FILE, "r", encoding="utf-8") as f:
+            return json.load(f)
+    except Exception:
+        return {}
+
+
+def _save_config(data: dict) -> None:
+    DIGEST_CONFIG_FILE.parent.mkdir(parents=True, exist_ok=True)
+    with open(DIGEST_CONFIG_FILE, "w", encoding="utf-8") as f:
+        json.dump(data, f, indent=2)
+
+
+def setup_digest(email: str, api_key: str) -> dict:
+    """Save Resend API key and recipient email."""
+    _save_config({
+        "email": email,
+        "resend_api_key": api_key,
+        "setup_at": time.time(),
+        "last_sent": None,
+    })
+    return {"success": True, "email": email}
+
+
+def get_digest_config() -> dict:
+    return _load_config()
+
+
+def _build_html(summary: dict, waste: list, savings_tokens: int) -> str:
+    waste_rows = ""
+    for w in waste[:5]:
+        waste_rows += f"""
+        <tr>
+          <td style="padding:6px 12px;border-bottom:1px solid #eee">{w['server']}</td>
+          <td style="padding:6px 12px;border-bottom:1px solid #eee;text-align:center">
+            {w['total_calls']} calls</td>
+          <td style="padding:6px 12px;border-bottom:1px solid #eee;color:#e53e3e">
+            {w['waste_level']}</td>
+        </tr>"""
+
+    top_servers = ""
+    for s in summary.get("top_servers", []):
+        top_servers += f"<li><strong>{s['server']}</strong> — {s['calls']} calls</li>"
+
+    savings_kb = round(savings_tokens / 1000, 1)
+
+    return f"""
+<!DOCTYPE html>
+<html>
+<head><meta charset="utf-8"><title>MCPSwitch Weekly Digest</title></head>
+<body style="font-family:-apple-system,BlinkMacSystemFont,'Segoe UI',sans-serif;
+             max-width:600px;margin:0 auto;padding:24px;color:#1a1a1a">
+
+  <h2 style="color:#2563eb;margin-bottom:4px">MCPSwitch Weekly Digest</h2>
+  <p style="color:#666;margin-top:0">Last 7 days</p>
+
+  <div style="background:#f0fdf4;border-left:4px solid #22c55e;padding:16px;
+              border-radius:4px;margin:20px 0">
+    <strong>Tokens saved this week:</strong>
+    <span style="font-size:1.4em;color:#16a34a;margin-left:8px">
+      ~{savings_kb}k tokens
+    </span>
+    <span style="color:#666;font-size:0.9em"> by using profiles instead of loading everything</span>
+  </div>
+
+  <h3>Most Used Servers</h3>
+  <ul style="line-height:1.8">{top_servers or '<li>No usage data yet — run mcpswitch setup</li>'}</ul>
+
+  {'<h3>Waste Alerts</h3><table style="width:100%;border-collapse:collapse"><thead><tr><th style="text-align:left;padding:6px 12px;background:#f9fafb">Server</th><th style="padding:6px 12px;background:#f9fafb">Usage</th><th style="padding:6px 12px;background:#f9fafb">Level</th></tr></thead><tbody>' + waste_rows + '</tbody></table><p style="font-size:0.9em;color:#666">Fix with: <code>mcpswitch waste --fix</code></p>' if waste else '<p style="color:#16a34a">No waste detected this week.</p>'}
+
+  <hr style="border:none;border-top:1px solid #eee;margin:24px 0">
+  <p style="color:#999;font-size:0.85em">
+    MCPSwitch Pro | <a href="https://mcpswitch.dev" style="color:#2563eb">mcpswitch.dev</a> |
+    <a href="https://mcpswitch.dev/unsubscribe" style="color:#999">Unsubscribe</a>
+  </p>
+</body>
+</html>"""
+
+
+def _build_text(summary: dict, waste: list, savings_tokens: int) -> str:
+    savings_kb = round(savings_tokens / 1000, 1)
+    lines = [
+        "MCPSwitch Weekly Digest",
+        "=" * 40,
+        f"Tokens saved this week: ~{savings_kb}k",
+        "",
+        "Most Used Servers:",
+    ]
+    for s in summary.get("top_servers", []):
+        lines.append(f"  {s['server']}: {s['calls']} calls")
+
+    if waste:
+        lines += ["", "Waste Alerts:"]
+        for w in waste[:5]:
+            lines.append(f"  {w['server']} — {w['waste_level']} ({w['total_calls']} calls)")
+        lines.append("Fix with: mcpswitch waste --fix")
+    else:
+        lines.append("\nNo waste detected this week.")
+
+    lines += ["", "---", "mcpswitch.dev"]
+    return "\n".join(lines)
+
+
+def send_digest(force: bool = False) -> dict:
+    """Build and send the weekly digest.
+
+    Returns {"success": bool, "message": str, "skipped": bool}
+    """
+    config = _load_config()
+
+    if not config.get("resend_api_key"):
+        return {"success": False, "skipped": False,
+                "message": "Not configured. Run: mcpswitch digest --setup"}
+
+    # Rate limit: only send once per 6 days unless forced
+    last_sent = config.get("last_sent")
+    if last_sent and not force:
+        days_since = (time.time() - last_sent) / 86400
+        if days_since < 6:
+            return {"success": True, "skipped": True,
+                    "message": f"Already sent {days_since:.1f} days ago. Use --force to resend."}
+
+    # Build digest content
+    from .usage import get_usage_summary, get_waste_report, get_server_usage_stats
+    from .config import get_claude_code_config_path, get_all_mcp_servers
+    from .tokens import estimate_total_tokens
+
+    summary = get_usage_summary(days=7)
+    servers = get_all_mcp_servers(get_claude_code_config_path())
+    waste = get_waste_report(list(servers.keys()), days=7) if servers else []
+
+    # Estimate token savings: current profile vs loading all known servers
+    current_tokens = estimate_total_tokens(servers)["total"]
+    # Approximate "all servers" as 2x current (conservative)
+    savings_tokens = max(0, current_tokens)
+
+    html = _build_html(summary, waste, savings_tokens)
+    text = _build_text(summary, waste, savings_tokens)
+
+    # Send via Resend API
+    try:
+        import urllib.request
+        payload = json.dumps({
+            "from": "MCPSwitch <digest@mcpswitch.dev>",
+            "to": [config["email"]],
+            "subject": f"MCPSwitch Weekly: {summary['total_calls']} tool calls, "
+                       f"{len(waste)} waste alerts",
+            "html": html,
+            "text": text,
+        }).encode("utf-8")
+
+        req = urllib.request.Request(
+            "https://api.resend.com/emails",
+            data=payload,
+            headers={
+                "Authorization": f"Bearer {config['resend_api_key']}",
+                "Content-Type": "application/json",
+            },
+            method="POST",
+        )
+        with urllib.request.urlopen(req, timeout=10) as resp:
+            result = json.loads(resp.read())
+            config["last_sent"] = time.time()
+            _save_config(config)
+            return {"success": True, "skipped": False,
+                    "message": f"Sent to {config['email']}", "id": result.get("id")}
+
+    except Exception as e:
+        return {"success": False, "skipped": False, "message": f"Send failed: {e}"}
+
+
+def preview_digest() -> str:
+    """Return plain text preview of the digest without sending."""
+    from .usage import get_usage_summary, get_waste_report
+    from .config import get_claude_code_config_path, get_all_mcp_servers
+
+    summary = get_usage_summary(days=7)
+    servers = get_all_mcp_servers(get_claude_code_config_path())
+    waste = get_waste_report(list(servers.keys()), days=7) if servers else []
+    return _build_text(summary, waste, 0)