fix(vscode): update configuration format from settings.json to mcp.json

- Change file paths from settings.json to mcp.json across all platforms
- Update configuration key from 'mcp.servers' to direct 'servers' access
- Simplify file structure to use direct servers object instead of nested structure
- Update method documentation and comments to reflect new format
- Preserve existing atomic write operations and error handling
- Maintain non-MCP settings preservation functionality

This change separates MCP configuration from VS Code settings, providing
cleaner organization and reduced conflicts with VS Code's settings management.

Author: LittleCoinCoin

hatch/mcp_host_config/strategies.py

@@ -298,35 +298,35 @@ def is_host_available(self) -> bool:
 
 @register_host_strategy(MCPHostType.VSCODE)
 class VSCodeHostStrategy(MCPHostStrategy):
-    """Configuration strategy for VS Code MCP extension with user-wide settings support."""
+    """Configuration strategy for VS Code MCP extension with user-wide mcp support."""
 
     def get_config_path(self) -> Optional[Path]:
-        """Get VS Code user settings configuration path (cross-platform)."""
+        """Get VS Code user mcp configuration path (cross-platform)."""
         try:
             system = platform.system()
             if system == "Windows":
-                # Windows: %APPDATA%\Code\User\settings.json
+                # Windows: %APPDATA%\Code\User\mcp.json
                 appdata = Path.home() / "AppData" / "Roaming"
-                return appdata / "Code" / "User" / "settings.json"
+                return appdata / "Code" / "User" / "mcp.json"
             elif system == "Darwin":  # macOS
-                # macOS: $HOME/Library/Application Support/Code/User/settings.json
-                return Path.home() / "Library" / "Application Support" / "Code" / "User" / "settings.json"
+                # macOS: $HOME/Library/Application Support/Code/User/mcp.json
+                return Path.home() / "Library" / "Application Support" / "Code" / "User" / "mcp.json"
             elif system == "Linux":
-                # Linux: $HOME/.config/Code/User/settings.json
-                return Path.home() / ".config" / "Code" / "User" / "settings.json"
+                # Linux: $HOME/.config/Code/User/mcp.json
+                return Path.home() / ".config" / "Code" / "User" / "mcp.json"
             else:
                 logger.warning(f"Unsupported platform for VS Code: {system}")
                 return None
         except Exception as e:
-            logger.error(f"Failed to determine VS Code user settings path: {e}")
+            logger.error(f"Failed to determine VS Code user mcp path: {e}")
             return None
 
     def get_config_key(self) -> str:
-        """VS Code uses nested configuration structure."""
-        return "mcp.servers"  # VS Code specific nested key
+        """VS Code uses direct servers configuration structure."""
+        return "servers"  # VS Code specific direct key
 
     def is_host_available(self) -> bool:
-        """Check if VS Code is installed by checking for user settings directory."""
+        """Check if VS Code is installed by checking for user directory."""
         try:
             config_path = self.get_config_path()
             if not config_path:
@@ -343,18 +343,18 @@ def validate_server_config(self, server_config: MCPServerConfig) -> bool:
         return server_config.command is not None or server_config.url is not None
 
     def read_configuration(self) -> HostConfiguration:
-        """Read VS Code settings.json configuration."""
+        """Read VS Code mcp.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 nested structure
-            mcp_servers = config_data.get("mcp", {}).get("servers", {})
-            
+
+            # Extract MCP servers from direct structure
+            mcp_servers = config_data.get(self.get_config_key(), {})
+
             # Convert to MCPServerConfig objects
             servers = {}
             for name, server_data in mcp_servers.items():
@@ -363,50 +363,48 @@ def read_configuration(self) -> HostConfiguration:
                 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 VS Code configuration: {e}")
             return HostConfiguration()
 
     def write_configuration(self, config: HostConfiguration, no_backup: bool = False) -> bool:
-        """Write VS Code settings.json configuration."""
+        """Write VS Code mcp.json configuration."""
         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
+
+            # Read existing configuration to preserve non-MCP settings
             existing_config = {}
             if config_path.exists():
                 try:
                     with open(config_path, 'r') as f:
                         existing_config = json.load(f)
                 except Exception:
                     pass
-            
+
             # Convert MCPServerConfig objects to dict
             servers_dict = {}
             for name, server_config in config.servers.items():
                 servers_dict[name] = server_config.model_dump(exclude_none=True)
-            
-            # Update nested configuration structure
-            if "mcp" not in existing_config:
-                existing_config["mcp"] = {}
-            existing_config["mcp"]["servers"] = servers_dict
-            
+
+            # Update configuration with new servers (preserves non-MCP settings)
+            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 VS Code configuration: {e}")
             return False