claude-cad 0.1.0__py3-none-any.whl

claude_cad/server.py

@@ -0,0 +1,505 @@
+#!/usr/bin/env python3
+"""
+Claude CAD MCP Server
+
+This server implements the Model Context Protocol (MCP) for 3D modeling
+capabilities using CadQuery.
+"""
+
+import os
+import json
+import tempfile
+import uuid
+import shutil
+from pathlib import Path
+from typing import Dict, List, Optional, Any, Union
+
+# MCP SDK imports
+# The import structure has changed - adjust based on the error
+from mcp.server import Server
+# Import StdioTransport instead of StdioServerTransport
+from mcp.transports.stdio import StdioTransport
+from mcp.types import (
+    CallToolRequestSchema,
+    ListToolsRequestSchema,
+    ListResourcesRequestSchema,
+    ReadResourceRequestSchema,
+    ErrorCode,
+    McpError,
+)
+
+# CadQuery imports
+import cadquery as cq
+
+from . import model_generator
+from . import utils
+
+class ClaudeCADServer:
+    """MCP Server implementation for 3D modeling with CadQuery."""
+    
+    def __init__(self):
+        """Initialize the CAD MCP server."""
+        self.server = Server(
+            {
+                "name": "claude_cad",
+                "version": "0.1.0",
+            },
+            {
+                "capabilities": {
+                    "resources": {},
+                    "tools": {},
+                }
+            }
+        )
+        
+        # Create a temp directory for storing generated models
+        self.temp_dir = Path(tempfile.mkdtemp())
+        
+        # Dictionary to store created models
+        self.models: Dict[str, Dict[str, Any]] = {}
+        
+        # Set up request handlers
+        self.setup_handlers()
+        self.setup_error_handling()
+
+    def setup_error_handling(self) -> None:
+        """Configure error handling for the server."""
+        self.server.onerror = lambda error: print(f"[MCP Error] {error}", flush=True)
+        
+    def setup_handlers(self) -> None:
+        """Register all request handlers for the server."""
+        self.setup_resource_handlers()
+        self.setup_tool_handlers()
+        
+    def setup_resource_handlers(self) -> None:
+        """Set up handlers for resource-related requests."""
+        
+        # Handler for listing available models as resources
+        self.server.setRequestHandler(
+            ListResourcesRequestSchema,
+            self.handle_list_resources
+        )
+        
+        # Handler for reading model content
+        self.server.setRequestHandler(
+            ReadResourceRequestSchema,
+            self.handle_read_resource
+        )
+        
+    def setup_tool_handlers(self) -> None:
+        """Set up handlers for tool-related requests."""
+        
+        # Handler for listing available CAD tools
+        self.server.setRequestHandler(
+            ListToolsRequestSchema,
+            self.handle_list_tools
+        )
+        
+        # Handler for calling CAD tools
+        self.server.setRequestHandler(
+            CallToolRequestSchema,
+            self.handle_call_tool
+        )
+        
+    async def handle_list_resources(self, request: Any) -> Dict[str, List[Dict[str, str]]]:
+        """Handle the resources/list request to provide available 3D models.
+        
+        Returns:
+            A dictionary containing the list of available models as resources.
+        """
+        return {
+            "resources": [
+                {
+                    "uri": f"model://{model_id}",
+                    "name": model_info.get("name", f"Model {model_id}"),
+                    "mimeType": "model/step",
+                    "description": model_info.get("description", "A 3D model created with CadQuery")
+                }
+                for model_id, model_info in self.models.items()
+            ]
+        }
+        
+    async def handle_read_resource(self, request: Any) -> Dict[str, List[Dict[str, str]]]:
+        """Handle the resources/read request to provide model data.
+        
+        Args:
+            request: The MCP request object containing the resource URI.
+            
+        Returns:
+            A dictionary containing the model data.
+            
+        Raises:
+            McpError: If the requested model is not found.
+        """
+        url = utils.parse_resource_uri(request.params.uri)
+        model_id = url.path.lstrip('/')
+        
+        if model_id not in self.models:
+            raise McpError(
+                ErrorCode.InvalidRequest,
+                f"Model {model_id} not found"
+            )
+            
+        model_info = self.models[model_id]
+        
+        # Return metadata about the model
+        return {
+            "contents": [
+                {
+                    "uri": request.params.uri,
+                    "mimeType": "application/json",
+                    "text": json.dumps(model_info, indent=2)
+                }
+            ]
+        }
+        
+    async def handle_list_tools(self, request: Any) -> Dict[str, List[Dict[str, Any]]]:
+        """Handle the tools/list request to provide available CAD tools.
+        
+        Returns:
+            A dictionary containing the list of available CAD tools.
+        """
+        return {
+            "tools": [
+                {
+                    "name": "create_primitive",
+                    "description": "Create a primitive 3D shape",
+                    "inputSchema": {
+                        "type": "object",
+                        "properties": {
+                            "shape_type": {
+                                "type": "string",
+                                "description": "Type of primitive shape (box, sphere, cylinder, cone)",
+                                "enum": ["box", "sphere", "cylinder", "cone"]
+                            },
+                            "parameters": {
+                                "type": "object",
+                                "description": "Parameters for the primitive shape"
+                            },
+                            "name": {
+                                "type": "string",
+                                "description": "Name of the model"
+                            },
+                            "description": {
+                                "type": "string",
+                                "description": "Description of the model"
+                            }
+                        },
+                        "required": ["shape_type", "parameters"]
+                    }
+                },
+                {
+                    "name": "create_model_from_text",
+                    "description": "Create a 3D model from a text description using CadQuery",
+                    "inputSchema": {
+                        "type": "object",
+                        "properties": {
+                            "description": {
+                                "type": "string",
+                                "description": "Natural language description of the 3D model to create"
+                            },
+                            "name": {
+                                "type": "string",
+                                "description": "Name of the model"
+                            },
+                            "format": {
+                                "type": "string",
+                                "description": "Export format (step, stl)",
+                                "enum": ["step", "stl"],
+                                "default": "step"
+                            }
+                        },
+                        "required": ["description"]
+                    }
+                },
+                {
+                    "name": "execute_cadquery_script",
+                    "description": "Execute custom CadQuery Python code to create a 3D model",
+                    "inputSchema": {
+                        "type": "object",
+                        "properties": {
+                            "code": {
+                                "type": "string",
+                                "description": "Python code using CadQuery to create a model"
+                            },
+                            "name": {
+                                "type": "string",
+                                "description": "Name of the model"
+                            },
+                            "description": {
+                                "type": "string",
+                                "description": "Description of the model"
+                            },
+                            "format": {
+                                "type": "string",
+                                "description": "Export format (step, stl)",
+                                "enum": ["step", "stl"],
+                                "default": "step"
+                            }
+                        },
+                        "required": ["code"]
+                    }
+                }
+            ]
+        }
+        
+    async def handle_call_tool(self, request: Any) -> Dict[str, List[Dict[str, str]]]:
+        """Handle the tools/call request to execute a CAD tool.
+        
+        Args:
+            request: The MCP request object containing the tool name and arguments.
+            
+        Returns:
+            A dictionary containing the result of the tool execution.
+            
+        Raises:
+            McpError: If the requested tool is not found or if there's an error executing it.
+        """
+        tool_name = request.params.name
+        args = request.params.arguments or {}
+        
+        try:
+            if tool_name == "create_primitive":
+                return await self._handle_create_primitive(args)
+            elif tool_name == "create_model_from_text":
+                return await self._handle_create_model_from_text(args)
+            elif tool_name == "execute_cadquery_script":
+                return await self._handle_execute_cadquery_script(args)
+            else:
+                raise McpError(
+                    ErrorCode.MethodNotFound,
+                    f"Unknown tool: {tool_name}"
+                )
+        except Exception as e:
+            if isinstance(e, McpError):
+                raise
+            raise McpError(
+                ErrorCode.InternalError,
+                f"Error executing {tool_name}: {str(e)}"
+            )
+    
+    async def _handle_create_primitive(self, args: Dict[str, Any]) -> Dict[str, List[Dict[str, str]]]:
+        """Handle the create_primitive tool request.
+        
+        Args:
+            args: The tool arguments containing the primitive shape details.
+            
+        Returns:
+            A dictionary containing the result of the primitive creation.
+        """
+        shape_type = args.get("shape_type")
+        parameters = args.get("parameters", {})
+        name = args.get("name", f"Primitive {shape_type.capitalize()}")
+        description = args.get("description", f"A {shape_type} created with CadQuery")
+        
+        # Generate the model using CadQuery
+        try:
+            model = model_generator.create_primitive(shape_type, parameters)
+            
+            # Save the model and store metadata
+            model_id = self._save_model(model, name, description)
+            
+            # Return success message with model information
+            return {
+                "content": [
+                    {
+                        "type": "text",
+                        "text": f"Created {shape_type} model with ID: {model_id}\n"
+                               f"You can access this model as a resource with URI: model://{model_id}"
+                    }
+                ]
+            }
+        except Exception as e:
+            raise McpError(
+                ErrorCode.InternalError,
+                f"Error creating primitive: {str(e)}"
+            )
+    
+    async def _handle_create_model_from_text(self, args: Dict[str, Any]) -> Dict[str, List[Dict[str, str]]]:
+        """Handle the create_model_from_text tool request.
+        
+        Args:
+            args: The tool arguments containing the text description of the model.
+            
+        Returns:
+            A dictionary containing the result of the model creation.
+        """
+        description = args.get("description")
+        name = args.get("name", "Text-generated Model")
+        format_type = args.get("format", "step")
+        
+        if not description:
+            raise McpError(
+                ErrorCode.InvalidParams,
+                "Model description is required"
+            )
+        
+        try:
+            # Generate model from text description
+            model, code = model_generator.create_from_text(description)
+            
+            # Save the model
+            model_id = self._save_model(model, name, description, code, format_type)
+            
+            # Return success message with model information and generated code
+            return {
+                "content": [
+                    {
+                        "type": "text",
+                        "text": f"Created model from description with ID: {model_id}\n"
+                               f"You can access this model as a resource with URI: model://{model_id}\n\n"
+                               f"Generated CadQuery code:\n```python\n{code}\n```"
+                    }
+                ]
+            }
+        except Exception as e:
+            raise McpError(
+                ErrorCode.InternalError,
+                f"Error creating model from text: {str(e)}"
+            )
+    
+    async def _handle_execute_cadquery_script(self, args: Dict[str, Any]) -> Dict[str, List[Dict[str, str]]]:
+        """Handle the execute_cadquery_script tool request.
+        
+        Args:
+            args: The tool arguments containing the CadQuery Python code.
+            
+        Returns:
+            A dictionary containing the result of the script execution.
+        """
+        code = args.get("code")
+        name = args.get("name", "Custom CadQuery Model")
+        description = args.get("description", "A model created with custom CadQuery code")
+        format_type = args.get("format", "step")
+        
+        if not code:
+            raise McpError(
+                ErrorCode.InvalidParams,
+                "CadQuery code is required"
+            )
+        
+        try:
+            # Execute the CadQuery script
+            model = model_generator.execute_script(code)
+            
+            # Save the model
+            model_id = self._save_model(model, name, description, code, format_type)
+            
+            # Return success message with model information
+            return {
+                "content": [
+                    {
+                        "type": "text",
+                        "text": f"Successfully executed CadQuery code and created model with ID: {model_id}\n"
+                               f"You can access this model as a resource with URI: model://{model_id}"
+                    }
+                ]
+            }
+        except Exception as e:
+            raise McpError(
+                ErrorCode.InternalError,
+                f"Error executing CadQuery script: {str(e)}"
+            )
+    
+    def _save_model(self, 
+                   model: cq.Workplane, 
+                   name: str, 
+                   description: str, 
+                   code: Optional[str] = None,
+                   format_type: str = "step") -> str:
+        """Save a CadQuery model to disk and store its metadata.
+        
+        Args:
+            model: The CadQuery Workplane object.
+            name: The name of the model.
+            description: The description of the model.
+            code: The CadQuery code used to generate the model (optional).
+            format_type: The export format (step, stl).
+            
+        Returns:
+            The generated model ID.
+        """
+        model_id = str(uuid.uuid4())
+        model_dir = self.temp_dir / model_id
+        model_dir.mkdir(exist_ok=True)
+        
+        # Export the model in the requested format
+        if format_type.lower() == "stl":
+            file_path = model_dir / f"{model_id}.stl"
+            model.exportStl(str(file_path))
+            mime_type = "model/stl"
+        else:  # Default to STEP
+            file_path = model_dir / f"{model_id}.step"
+            model.exportStep(str(file_path))
+            mime_type = "model/step"
+        
+        # Store model metadata
+        self.models[model_id] = {
+            "id": model_id,
+            "name": name,
+            "description": description,
+            "file_path": str(file_path),
+            "mime_type": mime_type,
+            "format": format_type,
+            "code": code
+        }
+        
+        return model_id
+    
+    async def run(self) -> None:
+        """Start the CAD MCP server."""
+        # Use StdioTransport instead of StdioServerTransport
+        transport = StdioTransport()
+        await self.server.connect(transport)
+        print("Claude CAD MCP server running", flush=True)
+    
+    async def cleanup(self) -> None:
+        """Clean up resources used by the server."""
+        try:
+            # Remove temporary directory
+            shutil.rmtree(self.temp_dir, ignore_errors=True)
+        except Exception as e:
+            print(f"Error during cleanup: {e}", flush=True)
+        
+        # Close the server connection
+        await self.server.close()
+
+
+def main() -> None:
+    """Entry point for the Claude CAD MCP server."""
+    import asyncio
+    import signal
+    import sys
+    
+    # Create and run the server
+    server = ClaudeCADServer()
+    
+    # Set up signal handlers
+    loop = asyncio.get_event_loop()
+    
+    for sig in [signal.SIGINT, signal.SIGTERM]:
+        loop.add_signal_handler(sig, lambda: asyncio.create_task(shutdown(server, loop)))
+    
+    try:
+        loop.run_until_complete(server.run())
+        loop.run_forever()
+    except Exception as e:
+        print(f"Server error: {e}", flush=True)
+        sys.exit(1)
+
+
+async def shutdown(server: ClaudeCADServer, loop: asyncio.AbstractEventLoop) -> None:
+    """Gracefully shut down the server."""
+    print("Shutting down server...", flush=True)
+    await server.cleanup()
+    tasks = [t for t in asyncio.all_tasks() if t is not asyncio.current_task()]
+    
+    for task in tasks:
+        task.cancel()
+    
+    await asyncio.gather(*tasks, return_exceptions=True)
+    loop.stop()
+
+
+if __name__ == "__main__":
+    main()

claude_cad/utils.py

@@ -0,0 +1,86 @@
+"""
+Utility functions for Claude CAD.
+
+This module contains helper functions used throughout the Claude CAD package.
+"""
+
+import os
+import tempfile
+from pathlib import Path
+from typing import Dict, Any, Union
+from urllib.parse import urlparse
+
+
+def parse_resource_uri(uri: str) -> Any:
+    """Parse a resource URI into its components.
+    
+    Args:
+        uri: The resource URI to parse (e.g., 'model://123456').
+        
+    Returns:
+        A parsed URL object.
+    """
+    return urlparse(uri)
+
+
+def get_temp_file_path(suffix: str = '') -> Path:
+    """Create a temporary file path with the given suffix.
+    
+    Args:
+        suffix: File extension with dot (e.g., '.step').
+        
+    Returns:
+        Path object representing a temporary file path.
+    """
+    fd, path = tempfile.mkstemp(suffix=suffix)
+    os.close(fd)
+    return Path(path)
+
+
+def ensure_directory_exists(directory_path: Union[str, Path]) -> Path:
+    """Ensure that a directory exists, creating it if necessary.
+    
+    Args:
+        directory_path: Path to the directory to create.
+        
+    Returns:
+        Path object representing the directory.
+    """
+    path = Path(directory_path)
+    path.mkdir(parents=True, exist_ok=True)
+    return path
+
+
+def supported_export_formats() -> Dict[str, Dict[str, Any]]:
+    """Get a dictionary of supported export formats.
+    
+    Returns:
+        A dictionary mapping format names to their properties.
+    """
+    return {
+        "step": {
+            "extension": ".step",
+            "mime_type": "model/step",
+            "description": "STEP File Format (ISO 10303)",
+        },
+        "stl": {
+            "extension": ".stl",
+            "mime_type": "model/stl",
+            "description": "STL File Format (Standard Triangle Language)",
+        },
+        "dxf": {
+            "extension": ".dxf",
+            "mime_type": "application/dxf",
+            "description": "DXF File Format (Drawing Exchange Format)",
+        },
+        "svg": {
+            "extension": ".svg",
+            "mime_type": "image/svg+xml",
+            "description": "SVG File Format (Scalable Vector Graphics)",
+        },
+        "gltf": {
+            "extension": ".gltf",
+            "mime_type": "model/gltf+json",
+            "description": "glTF File Format (GL Transmission Format)",
+        },
+    }