rhinomcp 0.1.1.1__tar.gz → 0.1.1.3__tar.gz

{rhinomcp-0.1.1.1 → rhinomcp-0.1.1.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rhinomcp
-Version: 0.1.1.1
+Version: 0.1.1.3
 Summary: Rhino integration through the Model Context Protocol
 Author-email: Jingcheng Chen <mail@jchen.ch>
 License: MIT

{rhinomcp-0.1.1.1 → rhinomcp-0.1.1.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "rhinomcp"
-version = "0.1.1.1"
+version = "0.1.1.3"
 description = "Rhino integration through the Model Context Protocol"
 readme = "README.md"
 requires-python = ">=3.10"

rhinomcp-0.1.1.3/src/rhinomcp/__init__.py

@@ -0,0 +1,19 @@
+"""Rhino integration through the Model Context Protocol."""
+
+__version__ = "0.1.0"
+
+# Expose key classes and functions for easier imports
+from .server import RhinoConnection, get_rhino_connection, mcp, logger
+
+from .prompts.assert_creation_strategy import asset_creation_strategy
+from .prompts.assert_query_strategy import assert_query_strategy
+
+from .tools.create_object import create_object
+from .tools.create_objects import create_objects
+from .tools.delete_object import delete_object
+from .tools.get_document_info import get_document_info
+from .tools.get_object_info import get_object_info
+from .tools.get_selected_objects_info import get_selected_objects_info
+from .tools.modify_object import modify_object
+from .tools.execute_rhinoscript_python_code import execute_rhinoscript_python_code
+

rhinomcp-0.1.1.3/src/rhinomcp/prompts/assert_creation_strategy.py

@@ -0,0 +1,21 @@
+from rhinomcp.server import mcp
+
+
+@mcp.prompt()
+def asset_creation_strategy() -> str:
+    """Defines the preferred strategy for creating assets in Rhino"""
+    return """When creating 3D content in Rhino, always start by checking if integrations are available:
+
+    0. Before anything, always check the document from get_document_info()
+    1. Please ALWAYS try to create the objects using the tool execute_rhinoscript_python_code() first.
+    2. If there are multiple objects, use the method create_objects() to create multiple objects at once. Do not attempt to create them one by one if they are more than 10.
+    3. When including an object into document, ALWAYS make sure that the name of the object is meanful.
+    4. Try to include as many objects as possible accurately and efficiently. If the command is not able to include
+       so many data, try to create the objects in batches.
+
+    When creating rhinoscript python code:
+    - do not hallucinate, only use the syntax that is supported by rhinoscriptsyntax or Rhino,Geometry.
+    - document the code that you are writing.
+    - when creating objects, ALWAYS make sure that the name of the object is meanful.
+    - double check the code if any of the code is not correct, and fix it.
+    """

rhinomcp-0.1.1.3/src/rhinomcp/prompts/assert_query_strategy.py

@@ -0,0 +1,10 @@
+from rhinomcp.server import mcp
+
+
+@mcp.prompt()
+def assert_query_strategy() -> str:
+    """Defines the preferred strategy for querying Object or Objects in Rhino"""
+    return """When querying Object or Objects in Rhino:
+    - if the id of the object is known, use the id to query the object.
+    - if the id is not known, use the name of the object to query the object.
+    """

{rhinomcp-0.1.1.1 → rhinomcp-0.1.1.3}/src/rhinomcp/server.py

@@ -12,6 +12,7 @@ from pathlib import Path
 import base64
 from urllib.parse import urlparse
 
+
 # Configure logging
 logging.basicConfig(level=logging.INFO, 
                     format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
@@ -21,7 +22,7 @@ logger = logging.getLogger("RhinoMCPServer")
 class RhinoConnection:
     host: str
     port: int
-    sock: socket.socket = None  # Changed from 'socket' to 'sock' to avoid naming conflict
+    sock: socket.socket | None = None  # Changed from 'socket' to 'sock' to avoid naming conflict
     
     def connect(self) -> bool:
         """Connect to the Rhino addon socket server"""
@@ -104,7 +105,7 @@ class RhinoConnection:
         else:
             raise Exception("No data received")
 
-    def send_command(self, command_type: str, params: Dict[str, Any] = None) -> Dict[str, Any]:
+    def send_command(self, command_type: str, params: Dict[str, Any] = {}) -> Dict[str, Any]:
         """Send a command to Rhino and return the response"""
         if not self.sock and not self.connect():
             raise ConnectionError("Not connected to Rhino")
@@ -117,6 +118,9 @@ class RhinoConnection:
         try:
             # Log the command being sent
             logger.info(f"Sending command: {command_type} with params: {params}")
+
+            if self.sock is None:
+                raise Exception("Socket is not connected")
             
             # Send the command
             self.sock.sendall(json.dumps(command).encode('utf-8'))
@@ -150,7 +154,7 @@ class RhinoConnection:
         except json.JSONDecodeError as e:
             logger.error(f"Invalid JSON response from Rhino: {str(e)}")
             # Try to log what was received
-            if 'response_data' in locals() and response_data:
+            if 'response_data' in locals() and response_data: # type: ignore
                 logger.error(f"Raw response (first 200 bytes): {response_data[:200]}")
             raise Exception(f"Invalid response from Rhino: {str(e)}")
         except Exception as e:
@@ -200,28 +204,10 @@ mcp = FastMCP(
 
 # Global connection for resources (since resources can't access context)
 _rhino_connection = None
-_polyhaven_enabled = False  # Add this global variable
 
 def get_rhino_connection():
     """Get or create a persistent Rhino connection"""
-    global _rhino_connection, _polyhaven_enabled  # Add _polyhaven_enabled to globals
-    
-    # If we have an existing connection, check if it's still valid
-    if _rhino_connection is not None:
-        try:
-            # First check if PolyHaven is enabled by sending a ping command
-            result = _rhino_connection.send_command("get_polyhaven_status")
-            # Store the PolyHaven status globally
-            _polyhaven_enabled = result.get("enabled", False)
-            return _rhino_connection
-        except Exception as e:
-            # Connection is dead, close it and create a new one
-            logger.warning(f"Existing connection is no longer valid: {str(e)}")
-            try:
-                _rhino_connection.disconnect()
-            except:
-                pass
-            _rhino_connection = None
+    global _rhino_connection
     
     # Create a new connection if needed
     if _rhino_connection is None:
@@ -234,198 +220,7 @@ def get_rhino_connection():
     
     return _rhino_connection
 
-
-@mcp.tool()
-def get_scene_info(ctx: Context) -> str:
-    """Get detailed information about the current Rhino scene"""
-    try:
-        rhino = get_rhino_connection()
-        result = rhino.send_command("get_scene_info")
-        
-        # Just return the JSON representation of what Rhino sent us
-        return json.dumps(result, indent=2)
-    except Exception as e:
-        logger.error(f"Error getting scene info from Rhino: {str(e)}")
-        return f"Error getting scene info: {str(e)}"
-
-@mcp.tool()
-def get_object_info(ctx: Context, object_name: str) -> str:
-    """
-    Get detailed information about a specific object in the Rhino scene.
-    
-    Parameters:
-    - object_name: The name of the object to get information about
-    """
-    try:
-        rhino = get_rhino_connection()
-        result = rhino.send_command("get_object_info", {"name": object_name})
-        
-        # Just return the JSON representation of what Rhino sent us
-        return json.dumps(result, indent=2)
-    except Exception as e:
-        logger.error(f"Error getting object info from Rhino: {str(e)}")
-        return f"Error getting object info: {str(e)}"
-
-
-
-@mcp.tool()
-def create_object(
-    ctx: Context,
-    type: str = "CUBE",
-    name: str = None,
-    location: List[float] = None,
-    rotation: List[float] = None,
-    scale: List[float] = None,
-    # Torus-specific parameters
-    align: str = "WORLD",
-    major_segments: int = 48,
-    minor_segments: int = 12,
-    mode: str = "MAJOR_MINOR",
-    major_radius: float = 1.0,
-    minor_radius: float = 0.25,
-    abso_major_rad: float = 1.25,
-    abso_minor_rad: float = 0.75,
-    generate_uvs: bool = True
-) -> str:
-    """
-    Create a new object in the Rhino scene.
-    
-    Parameters:
-    - type: Object type (CUBE, SPHERE, CYLINDER, PLANE, CONE, TORUS, EMPTY, CAMERA, LIGHT)
-    - name: Optional name for the object
-    - location: Optional [x, y, z] location coordinates
-    - rotation: Optional [x, y, z] rotation in radians
-    - scale: Optional [x, y, z] scale factors (not used for TORUS)
-    
-    Torus-specific parameters (only used when type == "TORUS"):
-    - align: How to align the torus ('WORLD', 'VIEW', or 'CURSOR')
-    - major_segments: Number of segments for the main ring
-    - minor_segments: Number of segments for the cross-section
-    - mode: Dimension mode ('MAJOR_MINOR' or 'EXT_INT')
-    - major_radius: Radius from the origin to the center of the cross sections
-    - minor_radius: Radius of the torus' cross section
-    - abso_major_rad: Total exterior radius of the torus
-    - abso_minor_rad: Total interior radius of the torus
-    - generate_uvs: Whether to generate a default UV map
-    
-    Returns:
-    A message indicating the created object name.
-    """
-    try:
-        # Get the global connection
-        rhino = get_rhino_connection()
-        
-        # Set default values for missing parameters
-        loc = location or [0, 0, 0]
-        rot = rotation or [0, 0, 0]
-        sc = scale or [1, 1, 1]
-        
-        params = {
-            "type": type,
-            "location": loc,
-            "rotation": rot,
-        }
-        
-        if name:
-            params["name"] = name
-
-        if type == "TORUS":
-            # For torus, the scale is not used.
-            params.update({
-                "align": align,
-                "major_segments": major_segments,
-                "minor_segments": minor_segments,
-                "mode": mode,
-                "major_radius": major_radius,
-                "minor_radius": minor_radius,
-                "abso_major_rad": abso_major_rad,
-                "abso_minor_rad": abso_minor_rad,
-                "generate_uvs": generate_uvs
-            })
-            result = rhino.send_command("create_object", params)
-            return f"Created {type} object: {result['name']}"
-        else:
-            # For non-torus objects, include scale
-            params["scale"] = sc
-            result = rhino.send_command("create_object", params)
-            return f"Created {type} object: {result['name']}"
-    except Exception as e:
-        logger.error(f"Error creating object: {str(e)}")
-        return f"Error creating object: {str(e)}"
-
-@mcp.tool()
-def modify_object(
-    ctx: Context,
-    name: str,
-    location: List[float] = None,
-    rotation: List[float] = None,
-    scale: List[float] = None,
-    visible: bool = None
-) -> str:
-    """
-    Modify an existing object in the Rhino scene.
-    
-    Parameters:
-    - name: Name of the object to modify
-    - location: Optional [x, y, z] location coordinates
-    - rotation: Optional [x, y, z] rotation in radians
-    - scale: Optional [x, y, z] scale factors
-    - visible: Optional boolean to set visibility
-    """
-    try:
-        # Get the global connection
-        rhino = get_rhino_connection()
-        
-        params = {"name": name}
-        
-        if location is not None:
-            params["location"] = location
-        if rotation is not None:
-            params["rotation"] = rotation
-        if scale is not None:
-            params["scale"] = scale
-        if visible is not None:
-            params["visible"] = visible
-            
-        result = rhino.send_command("modify_object", params)
-        return f"Modified object: {result['name']}"
-    except Exception as e:
-        logger.error(f"Error modifying object: {str(e)}")
-        return f"Error modifying object: {str(e)}"
-
-@mcp.tool()
-def delete_object(ctx: Context, name: str) -> str:
-    """
-    Delete an object from the Rhino scene.
-    
-    Parameters:
-    - name: Name of the object to delete
-    """
-    try:
-        # Get the global connection
-        rhino = get_rhino_connection()
-        
-        result = rhino.send_command("delete_object", {"name": name})
-        return f"Deleted object: {name}"
-    except Exception as e:
-        logger.error(f"Error deleting object: {str(e)}")
-        return f"Error deleting object: {str(e)}"
-
-@mcp.prompt()
-def asset_creation_strategy() -> str:
-    """Defines the preferred strategy for creating assets in Rhino"""
-    return """When creating 3D content in Rhino, always start by checking if integrations are available:
-
-    0. Before anything, always check the scene from get_scene_info()
-    1. Use the method create_object() for basic primitives (CUBE, SPHERE, etc.)
-    2. When including an object into scene, ALWAYS make sure that the name of the object is meanful.
-    3. After giving the tool location/scale/rotation information (via create_object() and modify_object()),
-       double check the related object's location, scale, rotation, and world_bounding_box using get_object_info(),
-       so that the object is in the desired location.
-    """
-
 # Main execution
-
 def main():
     """Run the MCP server"""
     mcp.run()

rhinomcp-0.1.1.3/src/rhinomcp/tools/create_object.py

@@ -0,0 +1,77 @@
+from mcp.server.fastmcp import Context
+import json
+from rhinomcp.server import get_rhino_connection, mcp, logger
+from typing import Any, List, Dict
+
+@mcp.tool()
+def create_object(
+    ctx: Context,
+    type: str = "BOX",
+    name: str = None,
+    color: List[int]= None,
+    params: Dict[str, Any] = {},
+    translation: List[float]= None,
+    rotation: List[float]= None,
+    scale: List[float]= None,
+) -> str:
+    """
+    Create a new object in the Rhino document.
+    
+    Parameters:
+    - type: Object type ("BOX", "SPHERE")
+    - name: Optional name for the object
+    - color: Optional [r, g, b] color values (0-255) for the object
+    - params: Type-specific parameters dictionary (see documentation for each type)
+    - translation: Optional [x, y, z] translation vector
+    - rotation: Optional [x, y, z] rotation in radians
+    - scale: Optional [x, y, z] scale factors
+
+    The params dictionary is type-specific.
+    For BOX, the params dictionary should contain the following keys:
+    - width: Width of the box along X axis of the object
+    - length: Length of the box along Y axis of the object
+    - height: Height of the box along Z axis of the object
+    
+    Returns:
+    A message indicating the created object name.
+    
+    Examples of params:
+    - BOX: {"width": 1.0, "length": 1.0, "height": 1.0}
+    - SPHERE: {"radius": 1.0}
+    """
+    try:
+        # Get the global connection
+        rhino = get_rhino_connection()
+        # Set default values for missing parameters
+        trans = translation or [0, 0, 0]
+        rot = rotation or [0, 0, 0]
+        sc = scale or [1, 1, 1]
+        
+        command_params = {
+            "type": type,
+            "translation": trans,
+            "rotation": rot,
+            "scale": sc
+        }
+
+        if name: command_params["name"] = name
+        if color: command_params["color"] = color
+
+        # Create the object
+        result = {}
+        if (type == "BOX"):
+            command_params["width"] = params["width"]
+            command_params["length"] = params["length"]
+            command_params["height"] = params["height"]
+            result = rhino.send_command("create_object", command_params)
+        elif (type == "SPHERE"):
+            result = rhino.send_command("create_object", command_params)
+        # elif (type == "CYLINDER"):
+        #     result = rhino.send_command("create_cylinder", command_params)
+            
+        
+        return f"Created {type} object: {result['name']}"
+    except Exception as e:
+        logger.error(f"Error creating object: {str(e)}")
+        return f"Error creating object: {str(e)}"
+ 

rhinomcp-0.1.1.3/src/rhinomcp/tools/create_objects.py

@@ -0,0 +1,56 @@
+from mcp.server.fastmcp import Context
+import json
+from rhinomcp.server import get_rhino_connection, mcp, logger
+from typing import Any, List, Dict
+
+
+@mcp.tool()
+def create_objects(
+    ctx: Context,
+    objects: List[Dict[str, Any]]
+) -> str:
+    """
+    Create multiple objects at once in the Rhino document.
+    
+    Parameters:
+    - objects: A list of dictionaries, each containing the parameters for a single object
+
+    Each object should have the following keys:
+    - type: Object type ("BOX")
+    - name: Optional name for the object
+    - color: Optional [r, g, b] color values (0-255) for the object
+    - params: Type-specific parameters dictionary (see documentation for each type)
+    - translation: Optional [x, y, z] translation vector
+    - rotation: Optional [x, y, z] rotation in radians
+    - scale: Optional [x, y, z] scale factors
+
+    Returns:
+    A message indicating the created objects.
+    
+    Examples of params:
+    [
+        {
+            "type": "BOX",
+            "name": "Box 1",
+            "color": [255, 0, 0],
+            "params": {"width": 1.0, "length": 1.0, "height": 1.0},
+            "translation": [0, 0, 0],
+            "rotation": [0, 0, 0],
+            "scale": [1, 1, 1]
+        }
+    ]
+    """
+    try:
+        # Get the global connection
+        rhino = get_rhino_connection()
+        command_params = {}
+        for obj in objects:
+            command_params[obj["name"]] = obj
+        result = rhino.send_command("create_objects", command_params)
+  
+        
+        return f"Created {len(result)} objects"
+    except Exception as e:
+        logger.error(f"Error creating object: {str(e)}")
+        return f"Error creating object: {str(e)}"
+

rhinomcp-0.1.1.3/src/rhinomcp/tools/delete_object.py

@@ -0,0 +1,25 @@
+from mcp.server.fastmcp import Context
+import json
+from rhinomcp.server import get_rhino_connection, mcp, logger
+from typing import Any, List, Dict
+
+
+
+@mcp.tool()
+def delete_object(ctx: Context, id: str = None, name: str = None) -> str:
+    """
+    Delete an object from the Rhino document.
+    
+    Parameters:
+    - id: The id of the object to delete
+    - name: The name of the object to delete
+    """
+    try:
+        # Get the global connection
+        rhino = get_rhino_connection()
+        
+        result = rhino.send_command("delete_object", {"id": id, "name": name})
+        return f"Deleted object: {result['name']}"
+    except Exception as e:
+        logger.error(f"Error deleting object: {str(e)}")
+        return f"Error deleting object: {str(e)}"

rhinomcp-0.1.1.3/src/rhinomcp/tools/execute_rhinoscript_python_code.py

@@ -0,0 +1,54 @@
+from mcp.server.fastmcp import Context
+import json
+from rhinomcp.server import get_rhino_connection, mcp, logger
+from typing import Any, List, Dict
+
+
+@mcp.tool()
+def execute_rhinoscript_python_code(ctx: Context, code: str) -> str:
+    """
+    Execute arbitrary RhinoScript code in Rhino.
+    
+    Parameters:
+    - code: The RhinoScript code to execute
+
+    References:
+
+    AddBox(corners)
+        Adds a box shaped polysurface to the document
+    Parameters:
+        corners ([point, point, point ,point, point, point ,point,point]) 8 points that define the corners of the box. Points need to
+        be in counter-clockwise order starting with the bottom rectangle of the box
+    Returns:
+        guid: identifier of the new object on success
+    Example:
+        import rhinoscriptsyntax as rs
+        box = rs.GetBox()
+        if box: rs.AddBox(box)
+
+    AddSphere(center_or_plane, radius)
+        Add a spherical surface to the document
+    Parameters:
+        center_or_plane (point|plane): center point of the sphere. If a plane is input,
+        the origin of the plane will be the center of the sphere
+        radius (number): radius of the sphere in the current model units
+    Returns:
+        guid: identifier of the new object on success
+        None: on error
+    Example:
+        import rhinoscriptsyntax as rs
+        radius = 2
+        center = rs.GetPoint("Center of sphere")
+        if center: rs.AddSphere(center, radius)
+
+
+    """
+    try:
+        # Get the global connection
+        rhino = get_rhino_connection()
+        
+        result = rhino.send_command("execute_rhinoscript_python_code", {"code": code})
+        return f"Code executed successfully: {result.get('result', '')}"
+    except Exception as e:
+        logger.error(f"Error executing code: {str(e)}")
+        return f"Error executing code: {str(e)}"

rhinomcp-0.1.1.3/src/rhinomcp/tools/get_document_info.py

@@ -0,0 +1,16 @@
+from mcp.server.fastmcp import Context
+import json
+from rhinomcp import get_rhino_connection, mcp, logger
+
+@mcp.tool()
+def get_document_info(ctx: Context) -> str:
+    """Get detailed information about the current Rhino document"""
+    try:
+        rhino = get_rhino_connection()
+        result = rhino.send_command("get_document_info")
+        
+        # Just return the JSON representation of what Rhino sent us
+        return json.dumps(result, indent=2)
+    except Exception as e:
+        logger.error(f"Error getting document info from Rhino: {str(e)}")
+        return f"Error getting document info: {str(e)}"

rhinomcp-0.1.1.3/src/rhinomcp/tools/get_object_info.py

@@ -0,0 +1,24 @@
+from mcp.server.fastmcp import Context
+import json
+from rhinomcp import get_rhino_connection, mcp, logger
+
+@mcp.tool()
+def get_object_info(ctx: Context, id: str = None, name: str = None) -> str:
+    """
+    Get detailed information about a specific object in the Rhino document.
+    You can either provide the id or the object_name of the object to get information about.
+    If both are provided, the id will be used.
+    
+    Parameters:
+    - id: The id of the object to get information about
+    - name: The name of the object to get information about
+    """
+    try:
+        rhino = get_rhino_connection()
+        result = rhino.send_command("get_object_info", {"id": id, "name": name})
+        
+        # Just return the JSON representation of what Rhino sent us
+        return json.dumps(result, indent=2)
+    except Exception as e:
+        logger.error(f"Error getting object info from Rhino: {str(e)}")
+        return f"Error getting object info: {str(e)}"

rhinomcp-0.1.1.3/src/rhinomcp/tools/get_selected_objects_info.py

@@ -0,0 +1,15 @@
+from mcp.server.fastmcp import Context
+import json
+from rhinomcp import get_rhino_connection, mcp, logger
+
+@mcp.tool()
+def get_selected_objects_info(ctx: Context) -> str:
+    """Get detailed information about the currently selected objects in Rhino"""
+    try:
+        rhino = get_rhino_connection()
+        result = rhino.send_command("get_selected_objects_info")
+        return json.dumps(result, indent=2)
+    except Exception as e:
+        logger.error(f"Error getting selected objects from Rhino: {str(e)}")
+        return f"Error getting selected objects: {str(e)}"
+

rhinomcp-0.1.1.3/src/rhinomcp/tools/modify_object.py

@@ -0,0 +1,59 @@
+from mcp.server.fastmcp import Context
+import json
+from rhinomcp.server import get_rhino_connection, mcp, logger
+from typing import Any, List, Dict
+
+
+@mcp.tool()
+def modify_object(
+    ctx: Context,
+    id: str = None,
+    name: str = None,
+    new_name: str = None,
+    new_color: List[int] = None,
+    translation: List[float] = None,
+    rotation: List[float] = None,
+    scale: List[float] = None,
+    visible: bool = None
+) -> str:
+    """
+    Modify an existing object in the Rhino document.
+    
+    Parameters:
+    - id: The id of the object to modify
+    - name: The name of the object to modify
+    - new_name: Optional new name for the object
+    - new_color: Optional [r, g, b] color values (0-255) for the object
+    - translation: Optional [x, y, z] translation vector
+    - rotation: Optional [x, y, z] rotation in radians
+    - scale: Optional [x, y, z] scale factors
+    - visible: Optional boolean to set visibility
+    """
+    try:
+        # Get the global connection
+        rhino = get_rhino_connection()
+        
+        params : Dict[str, Any] = {}
+        
+        if id is not None:
+            params["id"] = id
+        if name is not None:
+            params["name"] = name
+        if new_name is not None:
+            params["new_name"] = new_name
+        if new_color is not None:
+            params["new_color"] = new_color
+        if translation is not None:
+            params["translation"] = translation
+        if rotation is not None:
+            params["rotation"] = rotation
+        if scale is not None:
+            params["scale"] = scale
+        if visible is not None:
+            params["visible"] = visible
+            
+        result = rhino.send_command("modify_object", params)
+        return f"Modified object: {result['name']}"
+    except Exception as e:
+        logger.error(f"Error modifying object: {str(e)}")
+        return f"Error modifying object: {str(e)}"

{rhinomcp-0.1.1.1 → rhinomcp-0.1.1.3}/src/rhinomcp.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rhinomcp
-Version: 0.1.1.1
+Version: 0.1.1.3
 Summary: Rhino integration through the Model Context Protocol
 Author-email: Jingcheng Chen <mail@jchen.ch>
 License: MIT

rhinomcp-0.1.1.3/src/rhinomcp.egg-info/SOURCES.txt

@@ -0,0 +1,20 @@
+README.md
+pyproject.toml
+src/rhinomcp/__init__.py
+src/rhinomcp/server.py
+src/rhinomcp.egg-info/PKG-INFO
+src/rhinomcp.egg-info/SOURCES.txt
+src/rhinomcp.egg-info/dependency_links.txt
+src/rhinomcp.egg-info/entry_points.txt
+src/rhinomcp.egg-info/requires.txt
+src/rhinomcp.egg-info/top_level.txt
+src/rhinomcp/prompts/assert_creation_strategy.py
+src/rhinomcp/prompts/assert_query_strategy.py
+src/rhinomcp/tools/create_object.py
+src/rhinomcp/tools/create_objects.py
+src/rhinomcp/tools/delete_object.py
+src/rhinomcp/tools/execute_rhinoscript_python_code.py
+src/rhinomcp/tools/get_document_info.py
+src/rhinomcp/tools/get_object_info.py
+src/rhinomcp/tools/get_selected_objects_info.py
+src/rhinomcp/tools/modify_object.py

rhinomcp-0.1.1.1/src/rhinomcp/__init__.py

@@ -1,6 +0,0 @@
-"""Rhino integration through the Model Context Protocol."""
-
-__version__ = "0.1.0"
-
-# Expose key classes and functions for easier imports
-from .server import RhinoConnection, get_rhino_connection

rhinomcp-0.1.1.1/src/rhinomcp.egg-info/SOURCES.txt

@@ -1,10 +0,0 @@
-README.md
-pyproject.toml
-src/rhinomcp/__init__.py
-src/rhinomcp/server.py
-src/rhinomcp.egg-info/PKG-INFO
-src/rhinomcp.egg-info/SOURCES.txt
-src/rhinomcp.egg-info/dependency_links.txt
-src/rhinomcp.egg-info/entry_points.txt
-src/rhinomcp.egg-info/requires.txt
-src/rhinomcp.egg-info/top_level.txt