hatch-xclam 0.7.1.dev3__py3-none-any.whl → 0.8.0.dev1__py3-none-any.whl

hatch/mcp_host_config/strategies.py

@@ -17,17 +17,26 @@ import logging
 from .host_management import MCPHostStrategy, register_host_strategy
 from .models import MCPHostType, MCPServerConfig, HostConfiguration
 from .backup import MCPHostConfigBackupManager, AtomicFileOperations
+from .adapters import get_adapter
 
 logger = logging.getLogger(__name__)
 
 
 class ClaudeHostStrategy(MCPHostStrategy):
     """Base strategy for Claude family hosts with shared patterns."""
-    
+
     def __init__(self):
         self.company_origin = "Anthropic"
         self.config_format = "claude_format"
-    
+
+    def get_adapter_host_name(self) -> str:
+        """Return the adapter host name for this strategy.
+
+        Subclasses should override to return their specific adapter host name.
+        Default is 'claude-desktop' for backward compatibility.
+        """
+        return "claude-desktop"
+
     def get_config_key(self) -> str:
         """Claude family uses 'mcpServers' key."""
         return "mcpServers"
@@ -85,15 +94,15 @@ class ClaudeHostStrategy(MCPHostStrategy):
             return HostConfiguration()
     
     def write_configuration(self, config: HostConfiguration, no_backup: bool = False) -> bool:
-        """Write Claude configuration file."""
+        """Write Claude configuration file using adapter-based serialization."""
         config_path = self.get_config_path()
         if not config_path:
             return False
-        
+
         try:
             # Ensure parent directory exists
             config_path.parent.mkdir(parents=True, exist_ok=True)
-            
+
             # Read existing configuration to preserve non-MCP settings
             existing_config = {}
             if config_path.exists():
@@ -102,23 +111,24 @@ class ClaudeHostStrategy(MCPHostStrategy):
                         existing_config = json.load(f)
                 except Exception:
                     pass  # Start with empty config if read fails
-            
-            # Convert MCPServerConfig objects to dict
+
+            # Use adapter for serialization (includes validation and field filtering)
+            adapter = get_adapter(self.get_adapter_host_name())
             servers_dict = {}
             for name, server_config in config.servers.items():
-                servers_dict[name] = server_config.model_dump(exclude_none=True)
-            
+                servers_dict[name] = adapter.serialize(server_config)
+
             # Preserve Claude-specific settings
             updated_config = self._preserve_claude_settings(existing_config, servers_dict)
-            
+
             # Write atomically
             temp_path = config_path.with_suffix('.tmp')
             with open(temp_path, 'w') as f:
                 json.dump(updated_config, f, indent=2)
-            
+
             temp_path.replace(config_path)
             return True
-            
+
         except Exception as e:
             logger.error(f"Failed to write Claude configuration: {e}")
             return False
@@ -149,13 +159,17 @@ class ClaudeDesktopStrategy(ClaudeHostStrategy):
 @register_host_strategy(MCPHostType.CLAUDE_CODE)
 class ClaudeCodeStrategy(ClaudeHostStrategy):
     """Configuration strategy for Claude for VS Code."""
-    
+
+    def get_adapter_host_name(self) -> str:
+        """Return the adapter host name for Claude Code."""
+        return "claude-code"
+
     def get_config_path(self) -> Optional[Path]:
         """Get Claude Code configuration path (workspace-specific)."""
         # Claude Code uses workspace-specific configuration
         # This would be determined at runtime based on current workspace
         return Path.home() / ".claude.json"
-    
+
     def is_host_available(self) -> bool:
         """Check if Claude Code is available."""
         # Check for Claude Code user configuration file
@@ -165,15 +179,22 @@ class ClaudeCodeStrategy(ClaudeHostStrategy):
 
 class CursorBasedHostStrategy(MCPHostStrategy):
     """Base strategy for Cursor-based hosts (Cursor and LM Studio)."""
-    
+
     def __init__(self):
         self.config_format = "cursor_format"
         self.supports_remote_servers = True
-    
+
+    def get_adapter_host_name(self) -> str:
+        """Return the adapter host name for this strategy.
+
+        Subclasses should override. Default is 'cursor'.
+        """
+        return "cursor"
+
     def get_config_key(self) -> str:
         """Cursor family uses 'mcpServers' key."""
         return "mcpServers"
-    
+
     def validate_server_config(self, server_config: MCPServerConfig) -> bool:
         """Cursor family validation - supports both local and remote servers."""
         # Cursor family is more flexible with paths and supports remote servers
@@ -182,11 +203,14 @@ class CursorBasedHostStrategy(MCPHostStrategy):
         elif server_config.url:
             return True  # Remote server
         return False
-    
+
     def _format_cursor_server_config(self, server_config: MCPServerConfig) -> Dict:
-        """Format server configuration for Cursor family."""
+        """Format server configuration for Cursor family.
+
+        DEPRECATED: Use adapter.serialize() instead.
+        """
         config = {}
-        
+
         if server_config.command:
             # Local server configuration
             config["command"] = server_config.command
@@ -199,22 +223,22 @@ class CursorBasedHostStrategy(MCPHostStrategy):
             config["url"] = server_config.url
             if server_config.headers:
                 config["headers"] = server_config.headers
-        
+
         return config
-    
+
     def read_configuration(self) -> HostConfiguration:
         """Read Cursor-based configuration file."""
         config_path = self.get_config_path()
         if not config_path or not config_path.exists():
             return HostConfiguration()
-        
+
         try:
             with open(config_path, 'r') as f:
                 config_data = json.load(f)
-            
+
             # Extract MCP servers
             mcp_servers = config_data.get(self.get_config_key(), {})
-            
+
             # Convert to MCPServerConfig objects
             servers = {}
             for name, server_data in mcp_servers.items():
@@ -223,23 +247,23 @@ class CursorBasedHostStrategy(MCPHostStrategy):
                 except Exception as e:
                     logger.warning(f"Invalid server config for {name}: {e}")
                     continue
-            
+
             return HostConfiguration(servers=servers)
-            
+
         except Exception as e:
             logger.error(f"Failed to read Cursor configuration: {e}")
             return HostConfiguration()
-    
+
     def write_configuration(self, config: HostConfiguration, no_backup: bool = False) -> bool:
-        """Write Cursor-based configuration file."""
+        """Write Cursor-based configuration file using adapter-based serialization."""
         config_path = self.get_config_path()
         if not config_path:
             return False
-        
+
         try:
             # Ensure parent directory exists
             config_path.parent.mkdir(parents=True, exist_ok=True)
-            
+
             # Read existing configuration
             existing_config = {}
             if config_path.exists():
@@ -248,23 +272,24 @@ class CursorBasedHostStrategy(MCPHostStrategy):
                         existing_config = json.load(f)
                 except Exception:
                     pass
-            
-            # Convert MCPServerConfig objects to dict
+
+            # Use adapter for serialization (includes validation and field filtering)
+            adapter = get_adapter(self.get_adapter_host_name())
             servers_dict = {}
             for name, server_config in config.servers.items():
-                servers_dict[name] = server_config.model_dump(exclude_none=True)
-            
+                servers_dict[name] = adapter.serialize(server_config)
+
             # Update configuration
             existing_config[self.get_config_key()] = servers_dict
-            
+
             # Write atomically
             temp_path = config_path.with_suffix('.tmp')
             with open(temp_path, 'w') as f:
                 json.dump(existing_config, f, indent=2)
-            
+
             temp_path.replace(config_path)
             return True
-            
+
         except Exception as e:
             logger.error(f"Failed to write Cursor configuration: {e}")
             return False
@@ -287,11 +312,15 @@ class CursorHostStrategy(CursorBasedHostStrategy):
 @register_host_strategy(MCPHostType.LMSTUDIO)
 class LMStudioHostStrategy(CursorBasedHostStrategy):
     """Configuration strategy for LM Studio (follows Cursor format)."""
-    
+
+    def get_adapter_host_name(self) -> str:
+        """Return the adapter host name for LM Studio."""
+        return "lmstudio"
+
     def get_config_path(self) -> Optional[Path]:
         """Get LM Studio configuration path."""
         return Path.home() / ".lmstudio" / "mcp.json"
-    
+
     def is_host_available(self) -> bool:
         """Check if LM Studio is installed."""
         config_path = self.get_config_path()
@@ -302,6 +331,10 @@ class LMStudioHostStrategy(CursorBasedHostStrategy):
 class VSCodeHostStrategy(MCPHostStrategy):
     """Configuration strategy for VS Code MCP extension with user-wide mcp support."""
 
+    def get_adapter_host_name(self) -> str:
+        """Return the adapter host name for VS Code."""
+        return "vscode"
+
     def get_config_path(self) -> Optional[Path]:
         """Get VS Code user mcp configuration path (cross-platform)."""
         try:
@@ -343,7 +376,7 @@ class VSCodeHostStrategy(MCPHostStrategy):
     def validate_server_config(self, server_config: MCPServerConfig) -> bool:
         """VS Code validation - flexible path handling."""
         return server_config.command is not None or server_config.url is not None
-    
+
     def read_configuration(self) -> HostConfiguration:
         """Read VS Code mcp.json configuration."""
         config_path = self.get_config_path()
@@ -373,7 +406,7 @@ class VSCodeHostStrategy(MCPHostStrategy):
             return HostConfiguration()
     
     def write_configuration(self, config: HostConfiguration, no_backup: bool = False) -> bool:
-        """Write VS Code mcp.json configuration."""
+        """Write VS Code mcp.json configuration using adapter-based serialization."""
         config_path = self.get_config_path()
         if not config_path:
             return False
@@ -391,10 +424,11 @@ class VSCodeHostStrategy(MCPHostStrategy):
                 except Exception:
                     pass
 
-            # Convert MCPServerConfig objects to dict
+            # Use adapter for serialization (includes validation and field filtering)
+            adapter = get_adapter(self.get_adapter_host_name())
             servers_dict = {}
             for name, server_config in config.servers.items():
-                servers_dict[name] = server_config.model_dump(exclude_none=True)
+                servers_dict[name] = adapter.serialize(server_config)
 
             # Update configuration with new servers (preserves non-MCP settings)
             existing_config[self.get_config_key()] = servers_dict
@@ -415,83 +449,88 @@ class VSCodeHostStrategy(MCPHostStrategy):
 @register_host_strategy(MCPHostType.KIRO)
 class KiroHostStrategy(MCPHostStrategy):
     """Configuration strategy for Kiro IDE."""
-    
+
+    def get_adapter_host_name(self) -> str:
+        """Return the adapter host name for Kiro."""
+        return "kiro"
+
     def get_config_path(self) -> Optional[Path]:
         """Get Kiro configuration path (user-level only per constraint)."""
         return Path.home() / ".kiro" / "settings" / "mcp.json"
-    
+
     def get_config_key(self) -> str:
         """Kiro uses 'mcpServers' key."""
         return "mcpServers"
-    
+
     def is_host_available(self) -> bool:
         """Check if Kiro is available by checking for settings directory."""
         kiro_dir = Path.home() / ".kiro" / "settings"
         return kiro_dir.exists()
-    
+
     def validate_server_config(self, server_config: MCPServerConfig) -> bool:
         """Kiro validation - supports both local and remote servers."""
         return server_config.command is not None or server_config.url is not None
-    
+
     def read_configuration(self) -> HostConfiguration:
         """Read Kiro configuration file."""
         config_path_str = self.get_config_path()
         if not config_path_str:
             return HostConfiguration(servers={})
-        
+
         config_path = Path(config_path_str)
         if not config_path.exists():
             return HostConfiguration(servers={})
-        
+
         try:
             with open(config_path, 'r', encoding='utf-8') as f:
                 data = json.load(f)
-            
+
             servers = {}
             mcp_servers = data.get(self.get_config_key(), {})
-            
+
             for name, config in mcp_servers.items():
                 try:
                     servers[name] = MCPServerConfig(**config)
                 except Exception as e:
                     logger.warning(f"Invalid server config for {name}: {e}")
                     continue
-            
+
             return HostConfiguration(servers=servers)
-            
+
         except Exception as e:
             logger.error(f"Failed to read Kiro configuration: {e}")
             return HostConfiguration(servers={})
-    
+
     def write_configuration(self, config: HostConfiguration, no_backup: bool = False) -> bool:
-        """Write configuration to Kiro with backup support."""
+        """Write configuration to Kiro with backup support using adapter-based serialization."""
         config_path_str = self.get_config_path()
         if not config_path_str:
             return False
-        
+
         config_path = Path(config_path_str)
-        
+
         try:
             # Ensure directory exists
             config_path.parent.mkdir(parents=True, exist_ok=True)
-            
+
             # Read existing configuration to preserve other settings
             existing_data = {}
             if config_path.exists():
                 with open(config_path, 'r', encoding='utf-8') as f:
                     existing_data = json.load(f)
-            
-            # Update MCP servers section
+
+            # Use adapter for serialization (includes validation and field filtering)
+            adapter = get_adapter(self.get_adapter_host_name())
             servers_data = {}
             for name, server_config in config.servers.items():
-                servers_data[name] = server_config.model_dump(exclude_unset=True)
-            
+                servers_data[name] = adapter.serialize(server_config)
+
             existing_data[self.get_config_key()] = servers_data
-            
+
             # Use atomic write with backup support
             backup_manager = MCPHostConfigBackupManager()
             atomic_ops = AtomicFileOperations()
-            
+
             atomic_ops.atomic_write_with_backup(
                 file_path=config_path,
                 data=existing_data,
@@ -499,9 +538,9 @@ class KiroHostStrategy(MCPHostStrategy):
                 hostname="kiro",
                 skip_backup=no_backup
             )
-            
+
             return True
-            
+
         except Exception as e:
             logger.error(f"Failed to write Kiro configuration: {e}")
             return False
@@ -510,40 +549,44 @@ class KiroHostStrategy(MCPHostStrategy):
 @register_host_strategy(MCPHostType.GEMINI)
 class GeminiHostStrategy(MCPHostStrategy):
     """Configuration strategy for Google Gemini CLI MCP integration."""
-    
+
+    def get_adapter_host_name(self) -> str:
+        """Return the adapter host name for Gemini."""
+        return "gemini"
+
     def get_config_path(self) -> Optional[Path]:
         """Get Gemini configuration path based on official documentation."""
         # Based on official Gemini CLI documentation: ~/.gemini/settings.json
         return Path.home() / ".gemini" / "settings.json"
-    
+
     def get_config_key(self) -> str:
         """Gemini uses 'mcpServers' key in settings.json."""
         return "mcpServers"
-    
+
     def is_host_available(self) -> bool:
         """Check if Gemini CLI is available."""
         # Check if Gemini CLI directory exists
         gemini_dir = Path.home() / ".gemini"
         return gemini_dir.exists()
-    
+
     def validate_server_config(self, server_config: MCPServerConfig) -> bool:
         """Gemini validation - supports both local and remote servers."""
         # Gemini CLI supports both command-based and URL-based servers
         return server_config.command is not None or server_config.url is not None
-    
+
     def read_configuration(self) -> HostConfiguration:
         """Read Gemini settings.json configuration."""
         config_path = self.get_config_path()
         if not config_path or not config_path.exists():
             return HostConfiguration()
-        
+
         try:
             with open(config_path, 'r') as f:
                 config_data = json.load(f)
-            
+
             # Extract MCP servers from Gemini configuration
             mcp_servers = config_data.get(self.get_config_key(), {})
-            
+
             # Convert to MCPServerConfig objects
             servers = {}
             for name, server_data in mcp_servers.items():
@@ -552,15 +595,15 @@ class GeminiHostStrategy(MCPHostStrategy):
                 except Exception as e:
                     logger.warning(f"Invalid server config for {name}: {e}")
                     continue
-            
+
             return HostConfiguration(servers=servers)
-            
+
         except Exception as e:
             logger.error(f"Failed to read Gemini configuration: {e}")
             return HostConfiguration()
-    
+
     def write_configuration(self, config: HostConfiguration, no_backup: bool = False) -> bool:
-        """Write Gemini settings.json configuration."""
+        """Write Gemini settings.json configuration using adapter-based serialization."""
         config_path = self.get_config_path()
         if not config_path:
             return False
@@ -578,14 +621,15 @@ class GeminiHostStrategy(MCPHostStrategy):
                 except Exception:
                     pass
 
-            # Convert MCPServerConfig objects to dict (REPLACE, don't merge)
+            # Use adapter for serialization (includes validation and field filtering)
+            adapter = get_adapter(self.get_adapter_host_name())
             servers_dict = {}
             for name, server_config in config.servers.items():
-                servers_dict[name] = server_config.model_dump(exclude_none=True)
+                servers_dict[name] = adapter.serialize(server_config)
 
             # Update configuration with new servers (preserves non-MCP settings)
             existing_config[self.get_config_key()] = servers_dict
-            
+
             # Write atomically with enhanced error handling
             temp_path = config_path.with_suffix('.tmp')
             try:
@@ -605,7 +649,7 @@ class GeminiHostStrategy(MCPHostStrategy):
                     temp_path.unlink()
                 logger.error(f"JSON serialization/verification failed: {json_error}")
                 raise
-            
+
         except Exception as e:
             logger.error(f"Failed to write Gemini configuration: {e}")
             return False
@@ -623,6 +667,10 @@ class CodexHostStrategy(MCPHostStrategy):
         self.config_format = "toml"
         self._preserved_features = {}  # Preserve [features] section
 
+    def get_adapter_host_name(self) -> str:
+        """Return the adapter host name for Codex."""
+        return "codex"
+
     def get_config_path(self) -> Optional[Path]:
         """Get Codex configuration path."""
         return Path.home() / ".codex" / "config.toml"
@@ -673,7 +721,7 @@ class CodexHostStrategy(MCPHostStrategy):
             return HostConfiguration(servers={})
 
     def write_configuration(self, config: HostConfiguration, no_backup: bool = False) -> bool:
-        """Write Codex TOML configuration file with backup support."""
+        """Write Codex TOML configuration file with backup support using adapter-based serialization."""
         config_path = self.get_config_path()
         if not config_path:
             return False
@@ -694,10 +742,13 @@ class CodexHostStrategy(MCPHostStrategy):
             if 'features' in existing_data:
                 self._preserved_features = existing_data['features']
 
-            # Convert servers to TOML structure
+            # Use adapter for serialization (includes validation and field filtering)
+            adapter = get_adapter(self.get_adapter_host_name())
             servers_data = {}
             for name, server_config in config.servers.items():
-                servers_data[name] = self._to_toml_server(server_config)
+                # Adapter serializes and filters fields, then apply TOML-specific transforms
+                serialized = adapter.serialize(server_config)
+                servers_data[name] = self._to_toml_server_from_dict(serialized)
 
             # Build final TOML structure
             final_data = {}
@@ -778,3 +829,20 @@ class CodexHostStrategy(MCPHostStrategy):
             data['http_headers'] = data.pop('headers')
 
         return data
+
+    def _to_toml_server_from_dict(self, data: Dict[str, Any]) -> Dict[str, Any]:
+        """Apply TOML-specific transformations to an already-serialized dict.
+
+        This is used after adapter serialization to apply Codex-specific field mappings.
+        Maps universal 'headers' field back to Codex-specific 'http_headers'.
+        """
+        result = dict(data)
+
+        # Remove 'name' field as it's the table key in TOML
+        result.pop('name', None)
+
+        # Map universal 'headers' to Codex 'http_headers' for TOML
+        if 'headers' in result:
+            result['http_headers'] = result.pop('headers')
+
+        return result

hatch/template_generator.py

@@ -73,7 +73,7 @@ if __name__ == \"__main__\":
 """
 
 
-def generate_metadata_json(package_name: str, description: str = ""):
+def generate_metadata_json(package_name: str, description: str = "") -> dict:
     """Generate the metadata JSON content for a template package.
 
     Args:

{hatch_xclam-0.7.1.dev3.dist-info → hatch_xclam-0.8.0.dev1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hatch-xclam
-Version: 0.7.1.dev3
+Version: 0.8.0.dev1
 Summary: Package manager for the Cracking Shells ecosystem
 Author: Cracking Shells Team
 Project-URL: Homepage, https://github.com/CrackingShells/Hatch
@@ -22,7 +22,8 @@ Provides-Extra: docs
 Requires-Dist: mkdocs>=1.4.0; extra == "docs"
 Requires-Dist: mkdocstrings[python]>=0.20.0; extra == "docs"
 Provides-Extra: dev
-Requires-Dist: wobble>=0.2.0; extra == "dev"
+Requires-Dist: cs-wobble>=0.2.0; extra == "dev"
+Requires-Dist: pytest>=8.0.0; extra == "dev"
 Dynamic: license-file
 
 # Hatch