mcpswitch-cli 0.1.0__py3-none-any.whl

mcpswitch/usage.py

@@ -0,0 +1,232 @@
+"""Usage tracking — log every MCP tool call to SQLite.
+
+This is the data moat. Every tool call logged here powers:
+- Waste detection (Pro): "you loaded this MCP 200 sessions, called 0 tools"
+- Predictive loading (Pro): "based on your history, you'll need github in 2 turns"
+- Team analytics (Team): "your team wasted X tokens in MCP overhead this month"
+"""
+
+import json
+import sqlite3
+import time
+from pathlib import Path
+from typing import Optional
+
+USAGE_DB = Path.home() / ".mcpswitch" / "usage.db"
+USAGE_DB.parent.mkdir(parents=True, exist_ok=True)
+
+
+def _get_db() -> sqlite3.Connection:
+    conn = sqlite3.connect(str(USAGE_DB))
+    conn.execute("""
+        CREATE TABLE IF NOT EXISTS tool_calls (
+            id           INTEGER PRIMARY KEY AUTOINCREMENT,
+            session_id   TEXT,
+            server_name  TEXT NOT NULL,
+            tool_name    TEXT NOT NULL,
+            called_at    REAL NOT NULL,
+            profile_name TEXT,
+            project_dir  TEXT,
+            success      INTEGER DEFAULT 1
+        )
+    """)
+    conn.execute("""
+        CREATE TABLE IF NOT EXISTS sessions (
+            session_id   TEXT PRIMARY KEY,
+            profile_name TEXT,
+            project_dir  TEXT,
+            started_at   REAL NOT NULL,
+            ended_at     REAL,
+            tools_called INTEGER DEFAULT 0,
+            tokens_saved INTEGER DEFAULT 0
+        )
+    """)
+    conn.execute("CREATE INDEX IF NOT EXISTS idx_server ON tool_calls(server_name)")
+    conn.execute("CREATE INDEX IF NOT EXISTS idx_called_at ON tool_calls(called_at)")
+    conn.commit()
+    return conn
+
+
+def log_tool_call(
+    tool_name: str,
+    session_id: Optional[str] = None,
+    profile_name: Optional[str] = None,
+    project_dir: Optional[str] = None,
+    success: bool = True,
+) -> None:
+    """Log a single MCP tool call. Called from PostToolUse hook."""
+    # Extract server name from tool name (mcp__github__create_pr -> github)
+    server_name = _extract_server(tool_name)
+    if not server_name:
+        return  # Not an MCP tool call
+
+    try:
+        conn = _get_db()
+        conn.execute(
+            """INSERT INTO tool_calls
+               (session_id, server_name, tool_name, called_at, profile_name, project_dir, success)
+               VALUES (?, ?, ?, ?, ?, ?, ?)""",
+            (session_id, server_name, tool_name, time.time(),
+             profile_name, project_dir, int(success))
+        )
+        conn.commit()
+        conn.close()
+    except Exception:
+        pass
+
+
+def _extract_server(tool_name: str) -> Optional[str]:
+    """Extract server name from MCP tool name.
+
+    mcp__github__create_pull_request  -> github
+    mcp__brave-search__search          -> brave-search
+    github__create_pull_request        -> github  (some servers drop the mcp__ prefix)
+    """
+    if tool_name.startswith("mcp__"):
+        parts = tool_name.split("__")
+        return parts[1] if len(parts) >= 2 else None
+    # Some tools use server__tool format without mcp__ prefix
+    if "__" in tool_name:
+        return tool_name.split("__")[0]
+    return None
+
+
+def get_server_usage_stats(days: int = 30) -> list[dict]:
+    """Return usage stats per server for the last N days.
+
+    Used for waste detection: servers loaded but rarely/never called.
+    """
+    since = time.time() - (days * 86400)
+    try:
+        conn = _get_db()
+        rows = conn.execute("""
+            SELECT
+                server_name,
+                COUNT(*)           as total_calls,
+                COUNT(DISTINCT DATE(called_at, 'unixepoch')) as active_days,
+                COUNT(DISTINCT session_id) as sessions_used,
+                MAX(called_at)     as last_used
+            FROM tool_calls
+            WHERE called_at > ?
+            GROUP BY server_name
+            ORDER BY total_calls DESC
+        """, (since,)).fetchall()
+        conn.close()
+        return [
+            {
+                "server": r[0],
+                "total_calls": r[1],
+                "active_days": r[2],
+                "sessions_used": r[3],
+                "last_used": r[4],
+                "last_used_days_ago": round((time.time() - r[4]) / 86400, 1) if r[4] else None,
+            }
+            for r in rows
+        ]
+    except Exception:
+        return []
+
+
+def get_waste_report(loaded_servers: list[str], days: int = 30) -> list[dict]:
+    """Compare loaded servers vs actually called servers.
+
+    Returns list of servers that are loaded but rarely/never used.
+    This is the core Pro feature.
+    """
+    usage = {s["server"]: s for s in get_server_usage_stats(days)}
+    waste = []
+
+    for server in loaded_servers:
+        stats = usage.get(server)
+        if stats is None:
+            # Loaded but NEVER called in last N days
+            waste.append({
+                "server": server,
+                "total_calls": 0,
+                "sessions_used": 0,
+                "last_used_days_ago": None,
+                "waste_level": "high",
+                "recommendation": f"Never called in {days} days. Remove from profile.",
+            })
+        elif stats["total_calls"] < 3:
+            # Loaded but almost never called
+            waste.append({
+                "server": server,
+                "total_calls": stats["total_calls"],
+                "sessions_used": stats["sessions_used"],
+                "last_used_days_ago": stats["last_used_days_ago"],
+                "waste_level": "medium",
+                "recommendation": f"Only {stats['total_calls']} calls in {days} days. Consider removing.",
+            })
+
+    return sorted(waste, key=lambda x: x["total_calls"])
+
+
+def get_session_tool_sequence(session_id: str) -> list[str]:
+    """Return ordered list of tools called in a session.
+
+    Used for predictive loading: if users always call github then playwright,
+    preload both when github profile is active.
+    """
+    try:
+        conn = _get_db()
+        rows = conn.execute(
+            "SELECT tool_name FROM tool_calls WHERE session_id = ? ORDER BY called_at",
+            (session_id,)
+        ).fetchall()
+        conn.close()
+        return [r[0] for r in rows]
+    except Exception:
+        return []
+
+
+def get_top_tools_by_server(server_name: str, limit: int = 10) -> list[dict]:
+    """Return the most-called tools from a specific server.
+
+    Used to build minimal profiles: instead of loading ALL 30 github tools,
+    load only the 5 you actually use.
+    """
+    try:
+        conn = _get_db()
+        rows = conn.execute("""
+            SELECT tool_name, COUNT(*) as calls
+            FROM tool_calls
+            WHERE server_name = ?
+            GROUP BY tool_name
+            ORDER BY calls DESC
+            LIMIT ?
+        """, (server_name, limit)).fetchall()
+        conn.close()
+        return [{"tool": r[0], "calls": r[1]} for r in rows]
+    except Exception:
+        return []
+
+
+def get_usage_summary(days: int = 7) -> dict:
+    """High-level summary for the weekly digest email."""
+    since = time.time() - (days * 86400)
+    try:
+        conn = _get_db()
+        total_calls = conn.execute(
+            "SELECT COUNT(*) FROM tool_calls WHERE called_at > ?", (since,)
+        ).fetchone()[0]
+
+        unique_servers = conn.execute(
+            "SELECT COUNT(DISTINCT server_name) FROM tool_calls WHERE called_at > ?", (since,)
+        ).fetchone()[0]
+
+        most_used = conn.execute("""
+            SELECT server_name, COUNT(*) as c FROM tool_calls
+            WHERE called_at > ?
+            GROUP BY server_name ORDER BY c DESC LIMIT 3
+        """, (since,)).fetchall()
+
+        conn.close()
+        return {
+            "days": days,
+            "total_calls": total_calls,
+            "unique_servers": unique_servers,
+            "top_servers": [{"server": r[0], "calls": r[1]} for r in most_used],
+        }
+    except Exception:
+        return {"days": days, "total_calls": 0, "unique_servers": 0, "top_servers": []}

mcpswitch_cli-0.1.0.dist-info/METADATA

@@ -0,0 +1,130 @@
+Metadata-Version: 2.4
+Name: mcpswitch-cli
+Version: 0.1.0
+Summary: Smart MCP profile manager for Claude Code — save 30-40% of your context window
+License: MIT
+Project-URL: Homepage, https://mcpswitch.dev
+Project-URL: Repository, https://github.com/sathibabunaidu58/mcpswitch
+Project-URL: Issues, https://github.com/sathibabunaidu58/mcpswitch/issues
+Keywords: claude,mcp,claude-code,context-window,tokens,llm
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: click>=8.0
+Requires-Dist: rich>=13.0
+Requires-Dist: tiktoken>=0.5
+Provides-Extra: server
+Requires-Dist: flask>=3.0; extra == "server"
+Requires-Dist: requests>=2.31; extra == "server"
+
+# MCPSwitch
+
+**Smart MCP profile manager for Claude Code.**  
+Stop wasting 30-40% of your context window on MCP tools you never use.
+
+---
+
+## The Problem
+
+Every MCP server you install adds its tool schemas to Claude's context window at session start.  
+84 tools across 6 servers = **15,540 tokens consumed before you type a single message.**  
+That's up to 40% of your context window gone — every session, every time.
+
+MCPSwitch lets you define lean profiles for different workflows and switch between them instantly.
+
+---
+
+## Install
+
+```bash
+pip install mcpswitch
+```
+
+Or run from source:
+```bash
+git clone https://github.com/sathibabu/mcpswitch
+cd mcpswitch
+pip install -e .
+```
+
+---
+
+## Quick Start
+
+```bash
+# See what your current MCP config is costing you
+mcpswitch analyze
+
+# Save your current config as a profile
+mcpswitch import --name full
+
+# Create a lean profile
+mcpswitch create python-backend
+
+# Add only the servers you need for Python work
+mcpswitch add python-backend github
+mcpswitch add python-backend context7
+
+# Switch to it before starting a Claude Code session
+mcpswitch use python-backend
+
+# See all profiles and their token costs
+mcpswitch list
+```
+
+---
+
+## Commands
+
+| Command | What it does |
+|---------|-------------|
+| `mcpswitch status` | Show active profile + token cost of loaded servers |
+| `mcpswitch analyze` | Break down token cost by server, show savings potential |
+| `mcpswitch list` | List all profiles with token estimates |
+| `mcpswitch use <profile>` | Switch to a profile (rewrites Claude config) |
+| `mcpswitch import --name <n>` | Save current config as a named profile |
+| `mcpswitch create <profile>` | Create a new empty profile |
+| `mcpswitch add <profile> <server>` | Add a server to a profile |
+| `mcpswitch remove <profile> <server>` | Remove a server from a profile |
+| `mcpswitch save <profile>` | Save current active config as profile |
+| `mcpswitch delete <profile>` | Delete a profile |
+
+---
+
+## Real-World Savings
+
+| Scenario | All MCPs | Lean Profile | Saved |
+|----------|----------|-------------|-------|
+| Python backend work | 15,540 tokens | 3,200 tokens | 12,340 tokens (79%) |
+| Frontend work | 15,540 tokens | 4,100 tokens | 11,440 tokens (74%) |
+| Writing/docs | 15,540 tokens | 900 tokens | 14,640 tokens (94%) |
+
+Fewer wasted tokens = more context for your actual code = better Claude responses.
+
+---
+
+## How It Works
+
+MCPSwitch reads and writes the Claude MCP config files:
+- **Claude Code CLI**: `~/.claude/claude_desktop_config.json`
+- **Claude Desktop**: `~/AppData/Roaming/Claude/claude_desktop_config.json` (Windows)
+
+Profiles are stored in `~/.mcpswitch/profiles.json`. Every config change is backed up automatically before overwriting.
+
+---
+
+## Pricing
+
+- **Free**: unlimited profiles, all commands, open source
+- **Pro** ($19/month): coming soon — auto-detect project type and switch profiles automatically, usage analytics, team profile sharing
+
+---
+
+## License
+
+MIT

mcpswitch_cli-0.1.0.dist-info/RECORD

@@ -0,0 +1,19 @@
+mcpswitch/__init__.py,sha256=LCoxxRWg1T6LVsWLKmGa7W6XB4Vf7Sv1vhQh6z4Lqjk,86
+mcpswitch/auto.py,sha256=Kh6i4KH-SxuyfMlh2D-lnCsNkw48f0sKFh76XU6FCLk,11574
+mcpswitch/billing.py,sha256=Hy0m4JSuyuP2riS5c5hlatcE5Kieue4YvFwvUfeQahU,6569
+mcpswitch/cli.py,sha256=oz9hoPDjprr2RAx2QuAAorw5NfjBBWnRzQa_HKz4xZU,49492
+mcpswitch/community.py,sha256=2OG15XZrWX4HSomZRFxZKCF2qycTJ5xQ_mowl0BXrZg,7308
+mcpswitch/config.py,sha256=twj03wgKbl_jVtbIOAs1czkqWwgYTjfvG3uSgP-Ixag,2004
+mcpswitch/email.py,sha256=0V3CJ-fNqtxW-CGNUIp8V78HBHi5hAci_VbSUnc8GsA,7635
+mcpswitch/hooks.py,sha256=VmUCZy4tUqcsJKIMY61PS30fCCao-VeoiRTRj_EKZB8,7556
+mcpswitch/profiles.py,sha256=YkD-kutmYHonePLvtoqa3QkVduEj26cK0UuUkypTG2I,2786
+mcpswitch/sync.py,sha256=4C6CXrb0EMKoKH3F_47qGpKSLLD7CI5pcQj8DbsNpus,7146
+mcpswitch/team.py,sha256=_RCdj5KM_M3H5G_PqjbYGNetnUYx_754wq-B1KWpPOQ,21030
+mcpswitch/tier.py,sha256=gDNFP7mVAdc-hqjy9xg_6kNbajcE_FlK21fSL3Hvk-c,6058
+mcpswitch/tokens.py,sha256=GHyUIBRGGgiQ9176j6XH_kGHxcWhqj9hCye5ziHkLiI,12780
+mcpswitch/usage.py,sha256=AstK9F9psGJkh9En1k-mI1PEQHHxbUEiXyFfHOM3Qwk,7865
+mcpswitch_cli-0.1.0.dist-info/METADATA,sha256=ZXYGW56ooIRfS6Xw305V6dS_jlTwadH0a02gJkzTIEA,4049
+mcpswitch_cli-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+mcpswitch_cli-0.1.0.dist-info/entry_points.txt,sha256=lZXhszGsVir83rv4DfpiP2x__wv8F2kUh-oiEvTSOJQ,49
+mcpswitch_cli-0.1.0.dist-info/top_level.txt,sha256=3FTIQDqq6o1wZysYwsiKzM47ZXAApKdzfV2SyJt_cHc,10
+mcpswitch_cli-0.1.0.dist-info/RECORD,,

mcpswitch_cli-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

mcpswitch_cli-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+mcpswitch = mcpswitch.cli:main

mcpswitch_cli-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+mcpswitch