feat: improve the schema (#31)

Author: JoJoJoJoJoJoJo

src/mcpm/clients/base.py

@@ -9,9 +9,10 @@
 import platform
 from typing import Any, Dict, List, Optional, Union
 
+from pydantic import TypeAdapter
 from ruamel.yaml import YAML
 
-from mcpm.utils.server_config import ServerConfig
+from mcpm.schemas.server_config import ServerConfig, STDIOServerConfig
 
 logger = logging.getLogger(__name__)
 
@@ -28,10 +29,10 @@ class BaseClientManager(abc.ABC):
     client_key = ""  # Client identifier (e.g., "claude-desktop")
     display_name = ""  # Human-readable name (e.g., "Claude Desktop")
     download_url = ""  # URL to download the client
+    config_path: str
 
     def __init__(self):
         """Initialize the client manager"""
-        self.config_path = None  # To be set by subclasses
         self._system = platform.system()
 
     @abc.abstractmethod
@@ -56,12 +57,11 @@ def get_server(self, server_name: str) -> Optional[ServerConfig]:
         pass
 
     @abc.abstractmethod
-    def add_server(self, server_config: Union[ServerConfig, Dict[str, Any]], name: Optional[str] = None) -> bool:
+    def add_server(self, server_config: ServerConfig) -> bool:
         """Add or update a server in the client config
 
         Args:
-            server_config: ServerConfig object or dictionary in client format
-            name: Required server name when using dictionary format
+            server_config: ServerConfig object
 
         Returns:
             bool: Success or failure
@@ -140,6 +140,7 @@ class JSONClientManager(BaseClientManager):
     This class implements the BaseClientManager interface using JSON files
     for configuration storage.
     """
+
     configure_key_name: str = "mcpServers"
 
     def __init__(self):
@@ -231,29 +232,21 @@ def get_server(self, server_name: str) -> Optional[ServerConfig]:
         client_config = servers[server_name]
         return self.from_client_format(server_name, client_config)
 
-    def add_server(self, server_config: Union[ServerConfig, Dict[str, Any]], name: Optional[str] = None) -> bool:
+    def add_server(self, server_config: ServerConfig) -> bool:
         """Add or update a server in the client config
 
         Can accept either a ServerConfig object or a raw dictionary in client format.
         When using a dictionary, a name must be provided.
 
         Args:
             server_config: ServerConfig object or dictionary in client format
-            name: Required server name when using dictionary format
 
         Returns:
             bool: Success or failure
         """
-        # Handle direct dictionary input
-        if isinstance(server_config, dict):
-            if name is None:
-                raise ValueError("Name must be provided when using dictionary format")
-            server_name = name
-            client_config = server_config  # Already in client format
         # Handle ServerConfig objects
-        else:
-            server_name = server_config.name
-            client_config = self.to_client_format(server_config)
+        server_name = server_config.name
+        client_config = self.to_client_format(server_config)
 
         # Update config directly
         config = self._load_config()
@@ -275,15 +268,18 @@ def to_client_format(self, server_config: ServerConfig) -> Dict[str, Any]:
             Dict containing client-specific configuration with core fields
         """
         # Base result containing only essential execution information
-        result = {
-            "command": server_config.command,
-            "args": server_config.args,
-        }
-
-        # Add filtered environment variables if present
-        non_empty_env = server_config.get_filtered_env_vars(os.environ)
-        if non_empty_env:
-            result["env"] = non_empty_env
+        if isinstance(server_config, STDIOServerConfig):
+            result = {
+                "command": server_config.command,
+                "args": server_config.args,
+            }
+
+            # Add filtered environment variables if present
+            non_empty_env = server_config.get_filtered_env_vars(os.environ)
+            if non_empty_env:
+                result["env"] = non_empty_env
+        else:
+            result = server_config.to_dict()
 
         return result
 
@@ -300,18 +296,11 @@ def from_client_format(cls, server_name: str, client_config: Dict[str, Any]) ->
         Returns:
             ServerConfig object
         """
-        # Create a dictionary that ServerConfig.from_dict can work with
         server_data = {
             "name": server_name,
-            "command": client_config.get("command", ""),
-            "args": client_config.get("args", []),
         }
-
-        # Add environment variables if present
-        if "env" in client_config:
-            server_data["env"] = client_config["env"]
-
-        return ServerConfig.from_dict(server_data)
+        server_data.update(client_config)
+        return TypeAdapter(ServerConfig).validate_python(server_data)
 
     def list_servers(self) -> List[str]:
         """List all MCP servers in client config
@@ -374,7 +363,6 @@ class YAMLClientManager(BaseClientManager):
     def __init__(self):
         """Initialize the YAML client manager"""
         super().__init__()
-        self.config_path = None  # To be set by subclasses
         self.yaml_handler: YAML = YAML()
 
     def _load_config(self) -> Dict[str, Any]:
@@ -454,7 +442,9 @@ def _get_all_server_names(self, config: Dict[str, Any]) -> List[str]:
         pass
 
     @abc.abstractmethod
-    def _add_server_to_config(self, config: Dict[str, Any], server_name: str, server_config: Dict[str, Any]) -> Dict[str, Any]:
+    def _add_server_to_config(
+        self, config: Dict[str, Any], server_name: str, server_config: Dict[str, Any]
+    ) -> Dict[str, Any]:
         """Add or update a server in the config
 
         Args:
@@ -589,11 +579,7 @@ def get_client_info(self) -> Dict[str, str]:
         Returns:
             Dict: Information about the client including display name, download URL, and config path
         """
-        return {
-            "name": self.display_name,
-            "download_url": self.download_url,
-            "config_file": self.config_path
-        }
+        return {"name": self.display_name, "download_url": self.download_url, "config_file": self.config_path}
 
     def is_client_installed(self) -> bool:
         """Check if this client is installed

src/mcpm/clients/client_registry.py

@@ -39,7 +39,7 @@ class ClientRegistry:
         "continue": ContinueManager(),
         "goose": GooseClientManager(),
         "5ire": FiveireManager(),
-        "roo-code": RooCodeManager()
+        "roo-code": RooCodeManager(),
     }
 
     @classmethod
@@ -139,7 +139,7 @@ def get_active_client_manager(cls) -> Optional[BaseClientManager]:
         return cls.get_client_manager(active_client)
 
     @classmethod
-    def get_recommended_client(cls) -> str:
+    def get_recommended_client(cls) -> str | None:
         """
         Get the recommended client based on installation status
 

src/mcpm/clients/managers/__init__.py

@@ -5,11 +5,19 @@
 """
 
 from mcpm.clients.managers.claude_desktop import ClaudeDesktopManager
+from mcpm.clients.managers.cline import ClineManager
+from mcpm.clients.managers.continue_extension import ContinueManager
 from mcpm.clients.managers.cursor import CursorManager
+from mcpm.clients.managers.fiveire import FiveireManager
+from mcpm.clients.managers.goose import GooseClientManager
 from mcpm.clients.managers.windsurf import WindsurfManager
 
 __all__ = [
     "ClaudeDesktopManager",
     "CursorManager",
     "WindsurfManager",
+    "ClineManager",
+    "ContinueManager",
+    "FiveireManager",
+    "GooseClientManager",
 ]

src/mcpm/clients/managers/continue_extension.py

@@ -6,8 +6,10 @@
 import os
 from typing import Any, Dict, List, Optional
 
+from pydantic import TypeAdapter
+
 from mcpm.clients.base import YAMLClientManager
-from mcpm.utils.server_config import ServerConfig
+from mcpm.schemas.server_config import ServerConfig, STDIOServerConfig
 
 logger = logging.getLogger(__name__)
 
@@ -69,7 +71,7 @@ def _get_empty_config(self) -> Dict[str, Any]:
             "prompts": [],
             "context": [],
             "mcpServers": [],
-            "data": []
+            "data": [],
         }
 
     def _get_servers_section(self, config: Dict[str, Any]) -> List[Dict[str, Any]]:
@@ -107,9 +109,11 @@ def _get_all_server_names(self, config: Dict[str, Any]) -> List[str]:
         Returns:
             List of server names
         """
-        return [server.get("name") for server in self._get_servers_section(config) if server.get("name") is not None] # type: ignore
+        return [server.get("name") for server in self._get_servers_section(config) if server.get("name") is not None]  # type: ignore
 
-    def _add_server_to_config(self, config: Dict[str, Any], server_name: str, server_config: Dict[str, Any]) -> Dict[str, Any]:
+    def _add_server_to_config(
+        self, config: Dict[str, Any], server_name: str, server_config: Dict[str, Any]
+    ) -> Dict[str, Any]:
         """Add or update a server in the config
 
         Args:
@@ -168,17 +172,19 @@ def to_client_format(self, server_config: ServerConfig) -> Dict[str, Any]:
         Returns:
             Dict containing client-specific configuration
         """
-        # Base result containing essential information
-        result = {
-            "name": server_config.name,
-            "command": server_config.command,
-            "args": server_config.args,
-        }
-
-        # Add filtered environment variables if present
-        non_empty_env = server_config.get_filtered_env_vars(os.environ)
-        if non_empty_env:
-            result["env"] = non_empty_env
+        # Base result containing only essential execution information
+        if isinstance(server_config, STDIOServerConfig):
+            result = {
+                "command": server_config.command,
+                "args": server_config.args,
+            }
+
+            # Add filtered environment variables if present
+            non_empty_env = server_config.get_filtered_env_vars(os.environ)
+            if non_empty_env:
+                result["env"] = non_empty_env
+        else:
+            result = server_config.to_dict()
 
         return result
 
@@ -192,15 +198,8 @@ def from_client_format(self, server_name: str, client_config: Dict[str, Any]) ->
         Returns:
             ServerConfig object
         """
-        # Create a dictionary that ServerConfig.from_dict can work with
         server_data = {
             "name": server_name,
-            "command": client_config.get("command", ""),
-            "args": client_config.get("args", []),
         }
-
-        # Add environment variables if present
-        if "env" in client_config:
-            server_data["env"] = client_config["env"]
-
-        return ServerConfig.from_dict(server_data)
+        server_data.update(client_config)
+        return TypeAdapter(ServerConfig).validate_python(server_data)

src/mcpm/clients/managers/fiveire.py

@@ -4,13 +4,15 @@
 import re
 from typing import Any, Dict, List, Optional, Union
 
+from pydantic import TypeAdapter
+
 from mcpm.clients.base import JSONClientManager
-from mcpm.utils.server_config import ServerConfig
+from mcpm.schemas.server_config import ServerConfig, STDIOServerConfig
 
 logger = logging.getLogger(__name__)
 
-class FiveireManager(JSONClientManager):
 
+class FiveireManager(JSONClientManager):
     # Client information
     client_key = "5ire"
     display_name = "5ire"
@@ -167,24 +169,32 @@ def to_client_format(self, server_config: ServerConfig) -> Dict[str, Any]:
         Returns:
             Dict containing client-specific configuration
         """
+
+        if isinstance(server_config, STDIOServerConfig):
+            result = {
+                "command": server_config.command,
+                "args": server_config.args,
+            }
+
+            # Add filtered environment variables if present
+            non_empty_env = server_config.get_filtered_env_vars(os.environ)
+            if non_empty_env:
+                result["env"] = non_empty_env
+        else:
+            result = server_config.to_dict()
+
         # Base result containing essential information
         key_slug = re.sub(r"[^a-zA-Z0-9]", "", server_config.name)
         # If the key starts with a number, prepend an key prefix
         if key_slug and key_slug[0].isdigit():
             key_slug = f"key{key_slug}"
 
-        result = {
-            "name": server_config.name,
-            "key": key_slug,
-            "command": server_config.command,
-            "args": server_config.args,
-            "isActive": True
-        }
-
-        # Add filtered environment variables if present
-        non_empty_env = server_config.get_filtered_env_vars(os.environ)
-        if non_empty_env:
-            result["env"] = non_empty_env
+        result.update(
+            {
+                "key": key_slug,
+                "isActive": True,
+            }
+        )
 
         return result
 
@@ -199,18 +209,11 @@ def from_client_format(cls, server_name: str, client_config: Dict[str, Any]) ->
         Returns:
             ServerConfig object
         """
-        # Create a dictionary that ServerConfig.from_dict can work with
         server_data = {
             "name": server_name,
-            "command": client_config.get("command", ""),
-            "args": client_config.get("args", []),
         }
-
-        # Add environment variables if present
-        if "env" in client_config:
-            server_data["env"] = client_config["env"]
-
-        return ServerConfig.from_dict(server_data)
+        server_data.update(client_config)
+        return TypeAdapter(ServerConfig).validate_python(server_data)
 
     def list_servers(self) -> List[str]:
         """List all MCP servers in client config
@@ -307,7 +310,4 @@ def is_server_disabled(self, server_name: str) -> bool:
         servers = self.get_servers()
 
         # Check if the server exists and is not active
-        return (
-            server_name in servers
-            and servers[server_name].get("isActive", True) is False
-        )
+        return server_name in servers and servers[server_name].get("isActive", True) is False