Remove: Delete mcp and cursor_pybullet_mcp implementation

mcp/cursor_pybullet/README.md

@@ -1,103 +0,0 @@
-# Cursor-PyBullet MCP
-
-A Model-Controller-Provider (MCP) for connecting Cursor with PyBullet physics simulation.
-
-## Features
-
-- Connect to PyBullet physics server
-- Create and control robots
-- Run physics simulations
-- Capture visualization frames
-- Monitor robot state
-- Apply control signals
-
-## Installation
-
-```bash
-pip install -e .
-```
-
-## Usage
-
-```python
-from cursor_pybullet_mcp import CursorPyBulletMCP
-
-# Create MCP instance
-mcp = CursorPyBulletMCP()
-
-# Connect to PyBullet
-if mcp.connect():
-    try:
-        # Create ground
-        mcp.create_ground()
-        
-        # Create robot
-        robot_specs = {
-            "body": {
-                "dimensions": [1.0, 0.5, 0.3],
-                "mass": 10.0
-            },
-            "wheels": [
-                {
-                    "position": [0.5, 0.3, 0.15],
-                    "radius": 0.1,
-                    "width": 0.05
-                },
-                {
-                    "position": [0.5, -0.3, 0.15],
-                    "radius": 0.1,
-                    "width": 0.05
-                },
-                {
-                    "position": [-0.5, 0.3, 0.15],
-                    "radius": 0.1,
-                    "width": 0.05
-                },
-                {
-                    "position": [-0.5, -0.3, 0.15],
-                    "radius": 0.1,
-                    "width": 0.05
-                }
-            ]
-        }
-        mcp.create_robot(robot_specs)
-        
-        # Setup camera
-        mcp.setup_camera()
-        
-        # Run simulation
-        frames = mcp.run_simulation(duration_sec=5)
-        print(f"Captured {len(frames)} frames")
-        
-    finally:
-        # Always disconnect
-        mcp.disconnect()
-```
-
-## Configuration
-
-The MCP can be configured using a JSON file:
-
-```json
-{
-    "physics": {
-        "gravity": [0, 0, -9.81],
-        "timestep": 1.0/240.0,
-        "max_steps": 1000
-    },
-    "camera": {
-        "width": 640,
-        "height": 480,
-        "fov": 60,
-        "near": 0.1,
-        "far": 100.0,
-        "position": [2, 2, 2],
-        "target": [0, 0, 0],
-        "up": [0, 0, 1]
-    }
-}
-```
-
-## License
-
-MIT License 

mcp/cursor_pybullet/__init__.py

@@ -1,4 +0,0 @@
-from .mcp import CursorPyBulletMCP
-
-__version__ = "1.0.0"
-__all__ = ["CursorPyBulletMCP"] 

mcp/cursor_pybullet/config.json

@@ -1,176 +0,0 @@
-{
-    "name": "Cursor-PyBullet MCP",
-    "version": "1.0.0",
-    "description": "Model-Controller-Provider for connecting Cursor with PyBullet physics simulation",
-    "type": "python",
-    "entry_point": "cursor_pybullet_mcp.py",
-    "dependencies": {
-        "pybullet": "3.2.5",
-        "numpy": "1.24.3",
-        "Pillow": "10.0.0"
-    },
-    "config": {
-        "physics": {
-            "gravity": [0, 0, -9.81],
-            "timestep": 1.0/240.0,
-            "max_steps": 1000
-        },
-        "camera": {
-            "width": 640,
-            "height": 480,
-            "fov": 60,
-            "near": 0.1,
-            "far": 100.0,
-            "position": [2, 2, 2],
-            "target": [0, 0, 0],
-            "up": [0, 0, 1]
-        },
-        "robot": {
-            "default_body": {
-                "dimensions": [1.0, 0.5, 0.3],
-                "mass": 10.0,
-                "color": [0.8, 0.2, 0.2, 1.0]
-            },
-            "default_wheel": {
-                "radius": 0.1,
-                "width": 0.05,
-                "mass": 1.0,
-                "color": [0.2, 0.2, 0.2, 1.0]
-            }
-        },
-        "simulation": {
-            "capture_interval": 100,
-            "default_duration": 7
-        }
-    },
-    "commands": {
-        "connect": {
-            "description": "Connect to PyBullet physics server",
-            "returns": "boolean"
-        },
-        "disconnect": {
-            "description": "Disconnect from PyBullet physics server",
-            "returns": "void"
-        },
-        "create_ground": {
-            "description": "Create a ground plane",
-            "returns": "boolean"
-        },
-        "create_robot": {
-            "description": "Create a robot from specifications",
-            "parameters": {
-                "body": {
-                    "dimensions": "array[3]",
-                    "mass": "float"
-                },
-                "wheels": "array of wheel specifications"
-            },
-            "returns": "boolean"
-        },
-        "run_simulation": {
-            "description": "Run the simulation and capture frames",
-            "parameters": {
-                "duration_sec": "float",
-                "capture_interval": "integer"
-            },
-            "returns": "array of base64 encoded frames"
-        },
-        "get_robot_state": {
-            "description": "Get current state of the robot",
-            "returns": {
-                "position": "array[3]",
-                "orientation": "array[4]",
-                "linear_velocity": "array[3]",
-                "angular_velocity": "array[3]"
-            }
-        },
-        "apply_control": {
-            "description": "Apply control signals to the robot",
-            "parameters": {
-                "wheel_velocities": "array of float"
-            },
-            "returns": "boolean"
-        }
-    },
-    "events": {
-        "simulation_started": {
-            "description": "Emitted when simulation starts",
-            "data": {
-                "timestamp": "string",
-                "config": "object"
-            }
-        },
-        "simulation_step": {
-            "description": "Emitted on each simulation step",
-            "data": {
-                "step": "integer",
-                "total_steps": "integer",
-                "robot_state": "object"
-            }
-        },
-        "frame_captured": {
-            "description": "Emitted when a frame is captured",
-            "data": {
-                "step": "integer",
-                "frame": "string (base64)"
-            }
-        },
-        "simulation_ended": {
-            "description": "Emitted when simulation ends",
-            "data": {
-                "timestamp": "string",
-                "total_frames": "integer",
-                "final_state": "object"
-            }
-        },
-        "error": {
-            "description": "Emitted when an error occurs",
-            "data": {
-                "error": "string",
-                "timestamp": "string",
-                "context": "object"
-            }
-        }
-    },
-    "examples": {
-        "basic_usage": {
-            "description": "Basic example of using the MCP",
-            "code": {
-                "connect": true,
-                "create_ground": true,
-                "create_robot": {
-                    "body": {
-                        "dimensions": [1.0, 0.5, 0.3],
-                        "mass": 10.0
-                    },
-                    "wheels": [
-                        {
-                            "position": [0.5, 0.3, 0.15],
-                            "radius": 0.1,
-                            "width": 0.05
-                        },
-                        {
-                            "position": [0.5, -0.3, 0.15],
-                            "radius": 0.1,
-                            "width": 0.05
-                        },
-                        {
-                            "position": [-0.5, 0.3, 0.15],
-                            "radius": 0.1,
-                            "width": 0.05
-                        },
-                        {
-                            "position": [-0.5, -0.3, 0.15],
-                            "radius": 0.1,
-                            "width": 0.05
-                        }
-                    ]
-                },
-                "run_simulation": {
-                    "duration_sec": 5,
-                    "capture_interval": 100
-                }
-            }
-        }
-    }
-} 

mcp/cursor_pybullet/mcp.py

@@ -1,248 +0,0 @@
-import pybullet as p
-import pybullet_data
-import numpy as np
-import json
-import base64
-import io
-from PIL import Image
-import time
-import os
-from typing import Dict, List, Optional, Union, Any
-
-class CursorPyBulletMCP:
-    """Cursor-PyBullet MCP implementation"""
-    
-    def __init__(self, config_path: Optional[str] = None):
-        """Initialize the MCP with optional config file"""
-        self.physics_client = None
-        self.robot_id = None
-        self.wheel_ids = []
-        self.joint_ids = []
-        self.config = self._load_config(config_path)
-        self.camera_setup = self.config.get("camera", {
-            'width': 640,
-            'height': 480,
-            'fov': 60,
-            'near': 0.1,
-            'far': 100.0
-        })
-        
-    def _load_config(self, config_path: Optional[str]) -> Dict:
-        """Load configuration from file or use defaults"""
-        if config_path and os.path.exists(config_path):
-            with open(config_path, 'r') as f:
-                return json.load(f)
-        return {
-            "physics": {
-                "gravity": [0, 0, -9.81],
-                "timestep": 1.0/240.0,
-                "max_steps": 1000
-            },
-            "camera": {
-                "width": 640,
-                "height": 480,
-                "fov": 60,
-                "near": 0.1,
-                "far": 100.0,
-                "position": [2, 2, 2],
-                "target": [0, 0, 0],
-                "up": [0, 0, 1]
-            }
-        }
-        
-    def connect(self) -> bool:
-        """Connect to PyBullet physics server"""
-        try:
-            self.physics_client = p.connect(p.DIRECT)
-            p.setAdditionalSearchPath(pybullet_data.getDataPath())
-            p.setGravity(*self.config["physics"]["gravity"])
-            p.setRealTimeSimulation(0)
-            print("✅ Connected to PyBullet physics server")
-            return True
-        except Exception as e:
-            print(f"❌ Failed to connect to PyBullet: {str(e)}")
-            return False
-
-    def disconnect(self) -> None:
-        """Disconnect from PyBullet physics server"""
-        if self.physics_client is not None:
-            p.disconnect(self.physics_client)
-            print("✅ Disconnected from PyBullet physics server")
-
-    def create_ground(self) -> bool:
-        """Create a ground plane"""
-        try:
-            ground_id = p.createCollisionShape(p.GEOM_PLANE)
-            p.createMultiBody(0, ground_id)
-            print("✅ Created ground plane")
-            return True
-        except Exception as e:
-            print(f"❌ Failed to create ground: {str(e)}")
-            return False
-
-    def create_robot(self, robot_specs: Dict) -> bool:
-        """Create a robot from specifications"""
-        try:
-            # Create body
-            body_specs = robot_specs["body"]
-            body_collision = p.createCollisionShape(
-                p.GEOM_BOX,
-                halfExtents=[d/2 for d in body_specs["dimensions"]]
-            )
-            body_visual = p.createVisualShape(
-                p.GEOM_BOX,
-                halfExtents=[d/2 for d in body_specs["dimensions"]],
-                rgbaColor=body_specs.get("color", [0.8, 0.2, 0.2, 1])
-            )
-            self.robot_id = p.createMultiBody(
-                baseMass=body_specs["mass"],
-                baseCollisionShapeIndex=body_collision,
-                baseVisualShapeIndex=body_visual,
-                basePosition=[0, 0, body_specs["dimensions"][2]/2]
-            )
-
-            # Create wheels
-            self.wheel_ids = []
-            self.joint_ids = []
-            for i, wheel_spec in enumerate(robot_specs["wheels"]):
-                pos_x, pos_y, pos_z = wheel_spec["position"]
-                
-                # Create wheel
-                wheel_collision = p.createCollisionShape(
-                    p.GEOM_CYLINDER,
-                    radius=float(wheel_spec["radius"]),
-                    height=float(wheel_spec["width"])
-                )
-                wheel_visual = p.createVisualShape(
-                    p.GEOM_CYLINDER,
-                    radius=float(wheel_spec["radius"]),
-                    length=float(wheel_spec["width"]),
-                    rgbaColor=wheel_spec.get("color", [0.2, 0.2, 0.2, 1])
-                )
-                wheel_id = p.createMultiBody(
-                    baseMass=wheel_spec.get("mass", 1.0),
-                    baseCollisionShapeIndex=wheel_collision,
-                    baseVisualShapeIndex=wheel_visual,
-                    basePosition=[float(pos_x), float(pos_y), float(pos_z)]
-                )
-                self.wheel_ids.append(wheel_id)
-
-                # Create joint
-                joint_id = p.createConstraint(
-                    self.robot_id,
-                    wheel_id,
-                    p.JOINT_POINT2POINT,
-                    [0, 0, 0],
-                    [float(pos_x), float(pos_y), float(pos_z)],
-                    [0, 0, 0]
-                )
-                self.joint_ids.append(joint_id)
-
-            print(f"✅ Created robot with {len(self.wheel_ids)} wheels")
-            return True
-        except Exception as e:
-            print(f"❌ Failed to create robot: {str(e)}")
-            return False
-
-    def setup_camera(self) -> bool:
-        """Setup camera for visualization"""
-        try:
-            camera_config = self.config["camera"]
-            self.view_matrix = p.computeViewMatrix(
-                cameraEyePosition=camera_config["position"],
-                cameraTargetPosition=camera_config["target"],
-                cameraUpVector=camera_config["up"]
-            )
-            self.proj_matrix = p.computeProjectionMatrixFOV(
-                fov=camera_config["fov"],
-                aspect=float(camera_config["width"]) / camera_config["height"],
-                nearVal=camera_config["near"],
-                farVal=camera_config["far"]
-            )
-            print("✅ Camera setup completed")
-            return True
-        except Exception as e:
-            print(f"❌ Failed to setup camera: {str(e)}")
-            return False
-
-    def capture_frame(self) -> Optional[str]:
-        """Capture a frame from the simulation"""
-        try:
-            camera_config = self.config["camera"]
-            _, _, rgb, _, _ = p.getCameraImage(
-                width=camera_config["width"],
-                height=camera_config["height"],
-                viewMatrix=self.view_matrix,
-                projectionMatrix=self.proj_matrix,
-                renderer=p.ER_BULLET_HARDWARE_OPENGL
-            )
-            
-            # Convert to base64
-            img = Image.fromarray(rgb)
-            buffered = io.BytesIO()
-            img.save(buffered, format="PNG")
-            return base64.b64encode(buffered.getvalue()).decode()
-        except Exception as e:
-            print(f"❌ Failed to capture frame: {str(e)}")
-            return None
-
-    def run_simulation(self, duration_sec: float = 7, capture_interval: int = 100) -> List[str]:
-        """Run the simulation and capture frames"""
-        try:
-            frames = []
-            num_steps = int(duration_sec * 240)  # 240 Hz simulation
-            
-            for step in range(num_steps):
-                p.stepSimulation()
-                
-                if step % capture_interval == 0:
-                    frame = self.capture_frame()
-                    if frame:
-                        frames.append(frame)
-                        print(f"Captured frame at step {step}/{num_steps}")
-                
-                if step % 100 == 0:
-                    print(f"Simulation step {step}/{num_steps}")
-            
-            return frames
-        except Exception as e:
-            print(f"❌ Simulation failed: {str(e)}")
-            return []
-
-    def get_robot_state(self) -> Optional[Dict[str, Any]]:
-        """Get current state of the robot"""
-        try:
-            if self.robot_id is None:
-                return None
-                
-            pos, quat = p.getBasePositionAndOrientation(self.robot_id)
-            vel, ang_vel = p.getBaseVelocity(self.robot_id)
-            
-            return {
-                "position": pos,
-                "orientation": quat,
-                "linear_velocity": vel,
-                "angular_velocity": ang_vel
-            }
-        except Exception as e:
-            print(f"❌ Failed to get robot state: {str(e)}")
-            return None
-
-    def apply_control(self, wheel_velocities: List[float]) -> bool:
-        """Apply control signals to the robot"""
-        try:
-            if len(wheel_velocities) != len(self.wheel_ids):
-                raise ValueError("Number of wheel velocities must match number of wheels")
-                
-            for wheel_id, velocity in zip(self.wheel_ids, wheel_velocities):
-                p.setJointMotorControl2(
-                    wheel_id,
-                    0,  # joint index
-                    p.VELOCITY_CONTROL,
-                    targetVelocity=velocity,
-                    force=100
-                )
-            return True
-        except Exception as e:
-            print(f"❌ Failed to apply control: {str(e)}")
-            return False 

mcp/cursor_pybullet/record_simulation.py

@@ -1,105 +0,0 @@
-import cv2
-import numpy as np
-import base64
-from io import BytesIO
-from PIL import Image
-import time
-from mcp import CursorPyBulletMCP
-
-def base64_to_frame(base64_string):
-    """Convert base64 string to numpy array for OpenCV"""
-    img_data = base64.b64decode(base64_string)
-    img = Image.open(BytesIO(img_data))
-    return cv2.cvtColor(np.array(img), cv2.COLOR_RGB2BGR)
-
-def main():
-    # Create MCP instance
-    mcp = CursorPyBulletMCP()
-    
-    # Connect to PyBullet
-    if not mcp.connect():
-        print("Failed to connect to PyBullet")
-        return
-    
-    try:
-        # Create ground
-        if not mcp.create_ground():
-            print("Failed to create ground")
-            return
-            
-        # Create robot
-        robot_specs = {
-            "body": {
-                "dimensions": [1.0, 0.5, 0.3],
-                "mass": 10.0,
-                "color": [0.8, 0.2, 0.2, 1.0]  # Red color
-            },
-            "wheels": [
-                {
-                    "position": [0.5, 0.3, 0.15],
-                    "radius": 0.1,
-                    "width": 0.05,
-                    "color": [0.2, 0.2, 0.2, 1.0],  # Dark gray
-                    "mass": 1.0
-                },
-                {
-                    "position": [0.5, -0.3, 0.15],
-                    "radius": 0.1,
-                    "width": 0.05,
-                    "color": [0.2, 0.2, 0.2, 1.0],
-                    "mass": 1.0
-                },
-                {
-                    "position": [-0.5, 0.3, 0.15],
-                    "radius": 0.1,
-                    "width": 0.05,
-                    "color": [0.2, 0.2, 0.2, 1.0],
-                    "mass": 1.0
-                },
-                {
-                    "position": [-0.5, -0.3, 0.15],
-                    "radius": 0.1,
-                    "width": 0.05,
-                    "color": [0.2, 0.2, 0.2, 1.0],
-                    "mass": 1.0
-                }
-            ]
-        }
-        
-        if not mcp.create_robot(robot_specs):
-            print("Failed to create robot")
-            return
-            
-        # Setup camera
-        if not mcp.setup_camera():
-            print("Failed to setup camera")
-            return
-            
-        # Get camera settings
-        width = mcp.config["camera"]["width"]
-        height = mcp.config["camera"]["height"]
-        
-        # Setup video writer
-        fourcc = cv2.VideoWriter_fourcc(*'mp4v')
-        out = cv2.VideoWriter('simulation.mp4', fourcc, 30.0, (width, height))
-        
-        # Run simulation with more frequent frame capture
-        print("Starting simulation recording...")
-        frames = mcp.run_simulation(duration_sec=10, capture_interval=10)  # Capture every 10 steps
-        
-        # Convert frames to video
-        for i, frame_base64 in enumerate(frames):
-            frame = base64_to_frame(frame_base64)
-            out.write(frame)
-            print(f"Processed frame {i+1}/{len(frames)}")
-        
-        # Release video writer
-        out.release()
-        print("✅ Video saved as 'simulation.mp4'")
-        
-    finally:
-        # Always disconnect
-        mcp.disconnect()
-
-if __name__ == "__main__":
-    main() 

mcp/cursor_pybullet/setup.py

@@ -1,25 +0,0 @@
-from setuptools import setup, find_packages
-
-setup(
-    name="cursor_pybullet_mcp",
-    version="1.0.0",
-    packages=find_packages(),
-    install_requires=[
-        "pybullet>=3.2.5",
-        "numpy>=1.24.3",
-        "Pillow>=10.0.0",
-        "opencv-python>=4.8.0"
-    ],
-    author="Your Name",
-    author_email="your.email@example.com",
-    description="Cursor-PyBullet MCP for robot simulation",
-    long_description=open("README.md").read(),
-    long_description_content_type="text/markdown",
-    url="https://github.com/yourusername/cursor_pybullet_mcp",
-    classifiers=[
-        "Programming Language :: Python :: 3",
-        "License :: OSI Approved :: MIT License",
-        "Operating System :: OS Independent",
-    ],
-    python_requires=">=3.7",
-)