@softspark/ai-toolkit 2.0.2 → 2.1.1

package/scripts/mcp_manager.py

@@ -1,10 +1,12 @@
 #!/usr/bin/env python3
-"""MCP template manager -- add, remove, list, and inspect MCP server configs.
+"""MCP template manager -- add, remove, inspect, and install MCP configs.
 
 Usage:
   mcp_manager.py list                           List available templates
+  mcp_manager.py editors                        List native editor MCP adapters
   mcp_manager.py show <name>                    Show template details
   mcp_manager.py add <name> [names..] [--target <path>]  Add to .mcp.json
+  mcp_manager.py install --editor <name[,..]> [--scope project|global] [--target <path>] [name..]
   mcp_manager.py remove <name>                  Remove from .mcp.json
 """
 from __future__ import annotations
@@ -13,6 +15,14 @@ import json
 import sys
 from pathlib import Path
 
+from mcp_editors import (
+    editor_rows,
+    install_servers,
+    load_project_mcp_servers,
+    remove_servers,
+    supported_editors,
+)
+
 TOOLKIT_DIR = Path(__file__).resolve().parent.parent
 TEMPLATES_DIR = TOOLKIT_DIR / "app" / "mcp-templates"
 MCP_CONFIG_NAME = ".mcp.json"
@@ -85,6 +95,20 @@ def cmd_list() -> None:
     print(f"Add with: ai-toolkit mcp add <name>")
 
 
+def cmd_editors() -> None:
+    """List editors with native MCP config adapters."""
+    rows = editor_rows()
+    print(f"{'Editor':<12} {'Scope':<18} {'Project Path':<28} {'Global Path'}")
+    print("-" * 110)
+    for row in rows:
+        print(
+            f"{row['name']:<12} {row['scope']:<18} "
+            f"{row['project_path']:<28} {row['global_path']}"
+        )
+    print()
+    print(f"{len(rows)} editors supported")
+
+
 def cmd_show(name: str) -> None:
     """Show details of a specific template."""
     data = load_template(name)
@@ -132,14 +156,84 @@ def cmd_add(names: list[str], target_dir: Path) -> None:
     print(f"Added: {', '.join(added)}")
 
 
-def cmd_remove(name: str, target_dir: Path) -> None:
+def cmd_install(
+    names: list[str],
+    editors: list[str],
+    *,
+    target_dir: Path | None,
+    scope: str | None,
+) -> None:
+    """Install MCP templates into native editor config files."""
+    if not editors:
+        print("Error: install requires --editor <name[,..]>", file=sys.stderr)
+        print(
+            f"Supported editors: {', '.join(supported_editors())}",
+            file=sys.stderr,
+        )
+        sys.exit(1)
+
+    eff_scope = scope or ("project" if target_dir is not None or not names else "global")
+    if eff_scope == "project":
+        project_dir = target_dir or Path.cwd()
+        if names:
+            cmd_add(names, project_dir)
+            servers = {}
+            for name in names:
+                servers.update(load_template(name).get("mcpServers", {}))
+        else:
+            servers = load_project_mcp_servers(project_dir)
+        updated = install_servers(
+            editors,
+            servers,
+            scope="project",
+            project_dir=project_dir,
+        )
+    else:
+        if not names:
+            print(
+                "Error: global install requires at least one template name.",
+                file=sys.stderr,
+            )
+            sys.exit(1)
+        servers = {}
+        for name in names:
+            servers.update(load_template(name).get("mcpServers", {}))
+        updated = install_servers(editors, servers, scope="global")
+
+    for path in updated:
+        print(f"Updated: {path}")
+
+
+def cmd_remove(name: str, target_dir: Path | None, *, editors: list[str], scope: str | None) -> None:
     """Remove an MCP server from .mcp.json."""
-    config_path = target_dir / MCP_CONFIG_NAME
+    if editors:
+        eff_scope = scope or ("project" if target_dir else "global")
+        if eff_scope == "project":
+            project_dir = target_dir or Path.cwd()
+            config_path = project_dir / MCP_CONFIG_NAME
+            if config_path.is_file():
+                config = load_mcp_config(project_dir)
+                config.get("mcpServers", {}).pop(name, None)
+                write_mcp_config(project_dir, config)
+            updated = remove_servers(
+                editors,
+                [name],
+                scope="project",
+                project_dir=project_dir,
+            )
+        else:
+            updated = remove_servers(editors, [name], scope="global")
+        for path in updated:
+            print(f"Updated: {path}")
+        print(f"Removed: {name}")
+        return
+
+    config_path = (target_dir or Path.cwd()) / MCP_CONFIG_NAME
     if not config_path.is_file():
         print(f"Error: {config_path} not found.", file=sys.stderr)
         sys.exit(1)
 
-    config = load_mcp_config(target_dir)
+    config = load_mcp_config(target_dir or Path.cwd())
     servers = config.get("mcpServers", {})
 
     if name not in servers:
@@ -148,7 +242,7 @@ def cmd_remove(name: str, target_dir: Path) -> None:
         sys.exit(1)
 
     del servers[name]
-    write_mcp_config(target_dir, config)
+    write_mcp_config(target_dir or Path.cwd(), config)
     print(f"Removed: {name}")
 
 
@@ -156,19 +250,27 @@ def cmd_remove(name: str, target_dir: Path) -> None:
 # Argument parsing
 # ---------------------------------------------------------------------------
 
-def parse_target(args: list[str]) -> tuple[list[str], Path]:
-    """Extract --target <path> from args, return (remaining_args, target_dir)."""
-    target_dir = Path.cwd()
+def parse_options(args: list[str]) -> tuple[list[str], Path | None, list[str], str | None]:
+    """Extract common MCP CLI options."""
+    target_dir: Path | None = None
+    editors: list[str] = []
+    scope: str | None = None
     remaining = []
     i = 0
     while i < len(args):
         if args[i] == "--target" and i + 1 < len(args):
             target_dir = Path(args[i + 1]).resolve()
             i += 2
+        elif args[i] == "--editor" and i + 1 < len(args):
+            editors = [e.strip() for e in args[i + 1].split(",") if e.strip()]
+            i += 2
+        elif args[i] == "--scope" and i + 1 < len(args):
+            scope = args[i + 1]
+            i += 2
         else:
             remaining.append(args[i])
             i += 1
-    return remaining, target_dir
+    return remaining, target_dir, editors, scope
 
 
 def main() -> None:
@@ -182,20 +284,30 @@ def main() -> None:
 
     if subcmd == "list":
         cmd_list()
+    elif subcmd == "editors":
+        cmd_editors()
     elif subcmd == "show":
         if not rest:
             print("Usage: ai-toolkit mcp show <name>", file=sys.stderr)
             sys.exit(1)
         cmd_show(rest[0])
     elif subcmd == "add":
-        names, target_dir = parse_target(rest)
-        cmd_add(names, target_dir)
+        names, target_dir, _editors, _scope = parse_options(rest)
+        cmd_add(names, target_dir or Path.cwd())
+    elif subcmd == "install":
+        names, target_dir, editors, scope = parse_options(rest)
+        cmd_install(names, editors, target_dir=target_dir, scope=scope)
     elif subcmd == "remove":
-        names, target_dir = parse_target(rest)
+        names, target_dir, editors, scope = parse_options(rest)
         if not names:
             print("Usage: ai-toolkit mcp remove <name>", file=sys.stderr)
             sys.exit(1)
-        cmd_remove(names[0], target_dir)
+        cmd_remove(
+            names[0],
+            target_dir if editors else (target_dir or Path.cwd()),
+            editors=editors,
+            scope=scope,
+        )
     else:
         print(f"Unknown subcommand: {subcmd}", file=sys.stderr)
         print(__doc__)