foodforthought-cli 0.1.1__py3-none-any.whl

ate/mcp_server.py

@@ -0,0 +1,514 @@
+#!/usr/bin/env python3
+"""
+FoodforThought MCP Server - Model Context Protocol server for Cursor IDE
+Exposes FoodforThought CLI capabilities as MCP tools
+
+Installation:
+    pip install -r requirements-mcp.txt
+
+Usage:
+    python -m ate.mcp_server
+
+Or configure in Cursor's mcp.json:
+    {
+      "mcpServers": {
+        "foodforthought": {
+          "command": "python",
+          "args": ["-m", "ate.mcp_server"],
+          "env": {
+            "ATE_API_URL": "https://kindly.fyi/api",
+            "ATE_API_KEY": "${env:ATE_API_KEY}"
+          }
+        }
+      }
+    }
+"""
+
+import asyncio
+import json
+import os
+import sys
+from typing import Any, Dict, List, Optional
+
+# Import the existing CLI client
+from ate.cli import ATEClient
+
+# MCP SDK imports - using standard MCP Python SDK pattern
+try:
+    from mcp.server import Server
+    from mcp.server.stdio import stdio_server
+    from mcp.types import (
+        Tool,
+        TextContent,
+        Resource,
+        Prompt,
+        PromptArgument,
+    )
+except ImportError:
+    try:
+        # Alternative import path for some MCP SDK versions
+        from mcp import Server, stdio_server
+        from mcp.types import Tool, TextContent, Resource, Prompt, PromptArgument
+    except ImportError:
+        # Fallback if MCP SDK not available - provide helpful error
+        print(
+            "Error: MCP SDK not installed. Install with: pip install mcp",
+            file=sys.stderr,
+        )
+        sys.exit(1)
+
+# Initialize MCP server
+server = Server("foodforthought")
+
+# Initialize ATE client
+client = ATEClient()
+
+
+@server.list_tools()
+async def list_tools() -> List[Tool]:
+    """List all available MCP tools"""
+    return [
+        Tool(
+            name="ate_init",
+            description="Initialize a new FoodforThought repository",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "name": {
+                        "type": "string",
+                        "description": "Repository name",
+                    },
+                    "description": {
+                        "type": "string",
+                        "description": "Repository description",
+                    },
+                    "visibility": {
+                        "type": "string",
+                        "enum": ["public", "private"],
+                        "description": "Repository visibility",
+                        "default": "public",
+                    },
+                },
+                "required": ["name"],
+            },
+        ),
+        Tool(
+            name="ate_clone",
+            description="Clone a FoodforThought repository to local directory",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "repo_id": {
+                        "type": "string",
+                        "description": "Repository ID to clone",
+                    },
+                    "target_dir": {
+                        "type": "string",
+                        "description": "Target directory (optional)",
+                    },
+                },
+                "required": ["repo_id"],
+            },
+        ),
+        Tool(
+            name="ate_list_repositories",
+            description="List available FoodforThought repositories",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "search": {
+                        "type": "string",
+                        "description": "Search query",
+                    },
+                    "robot_model": {
+                        "type": "string",
+                        "description": "Filter by robot model",
+                    },
+                    "limit": {
+                        "type": "number",
+                        "description": "Maximum number of results",
+                        "default": 20,
+                    },
+                },
+            },
+        ),
+        Tool(
+            name="ate_list_robots",
+            description="List available robot profiles",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "search": {
+                        "type": "string",
+                        "description": "Search query",
+                    },
+                    "category": {
+                        "type": "string",
+                        "description": "Filter by category",
+                    },
+                    "limit": {
+                        "type": "number",
+                        "description": "Maximum number of results",
+                        "default": 20,
+                    },
+                },
+            },
+        ),
+        Tool(
+            name="ate_compatibility",
+            description="Check skill compatibility between two robot models",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "source_robot_id": {
+                        "type": "string",
+                        "description": "Source robot ID",
+                    },
+                    "target_robot_id": {
+                        "type": "string",
+                        "description": "Target robot ID",
+                    },
+                    "repository_id": {
+                        "type": "string",
+                        "description": "Repository ID to check compatibility for",
+                    },
+                },
+                "required": ["source_robot_id", "target_robot_id", "repository_id"],
+            },
+        ),
+        Tool(
+            name="ate_adapt",
+            description="Generate adaptation plan for transferring skills between robots",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "source_robot_id": {
+                        "type": "string",
+                        "description": "Source robot ID",
+                    },
+                    "target_robot_id": {
+                        "type": "string",
+                        "description": "Target robot ID",
+                    },
+                    "repository_id": {
+                        "type": "string",
+                        "description": "Repository ID to adapt",
+                    },
+                    "analyze_only": {
+                        "type": "boolean",
+                        "description": "Only show compatibility analysis",
+                        "default": False,
+                    },
+                },
+                "required": ["source_robot_id", "target_robot_id", "repository_id"],
+            },
+        ),
+        Tool(
+            name="ate_get_repository",
+            description="Get details of a specific repository",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "repo_id": {
+                        "type": "string",
+                        "description": "Repository ID",
+                    },
+                },
+                "required": ["repo_id"],
+            },
+        ),
+        Tool(
+            name="ate_get_robot",
+            description="Get details of a specific robot profile",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "robot_id": {
+                        "type": "string",
+                        "description": "Robot profile ID",
+                    },
+                },
+                "required": ["robot_id"],
+            },
+        ),
+    ]
+
+
+@server.call_tool()
+async def call_tool(name: str, arguments: Dict[str, Any]) -> List[TextContent]:
+    """Handle tool calls"""
+    try:
+        if name == "ate_init":
+            result = client.init(
+                arguments["name"],
+                arguments.get("description", ""),
+                arguments.get("visibility", "public"),
+            )
+            return [
+                TextContent(
+                    type="text",
+                    text=f"Repository created successfully!\nID: {result['repository']['id']}\nName: {result['repository']['name']}",
+                )
+            ]
+
+        elif name == "ate_clone":
+            client.clone(
+                arguments["repo_id"], arguments.get("target_dir")
+            )
+            return [
+                TextContent(
+                    type="text",
+                    text=f"Repository cloned successfully to {arguments.get('target_dir', 'current directory')}",
+                )
+            ]
+
+        elif name == "ate_list_repositories":
+            # Build query params
+            params = {}
+            if arguments.get("search"):
+                params["search"] = arguments["search"]
+            if arguments.get("robot_model"):
+                params["robotModel"] = arguments["robot_model"]
+            params["limit"] = arguments.get("limit", 20)
+
+            # Make API request
+            response = client._request("GET", "/repositories", params=params)
+            repos = response.get("repositories", [])
+
+            result_text = f"Found {len(repos)} repositories:\n\n"
+            for repo in repos[:10]:  # Limit to first 10
+                result_text += f"- {repo['name']} (ID: {repo['id']})\n"
+                if repo.get("description"):
+                    result_text += f"  {repo['description'][:100]}...\n"
+
+            return [TextContent(type="text", text=result_text)]
+
+        elif name == "ate_list_robots":
+            # Build query params
+            params = {}
+            if arguments.get("search"):
+                params["search"] = arguments["search"]
+            if arguments.get("category"):
+                params["category"] = arguments["category"]
+            params["limit"] = arguments.get("limit", 20)
+
+            # Make API request
+            response = client._request("GET", "/robots/profiles", params=params)
+            robots = response.get("profiles", [])
+
+            result_text = f"Found {len(robots)} robot profiles:\n\n"
+            for robot in robots[:10]:  # Limit to first 10
+                result_text += f"- {robot['modelName']} by {robot['manufacturer']} (ID: {robot['id']})\n"
+                if robot.get("description"):
+                    result_text += f"  {robot['description'][:100]}...\n"
+
+            return [TextContent(type="text", text=result_text)]
+
+        elif name == "ate_compatibility":
+            response = client._request(
+                "POST",
+                "/skills/compatibility",
+                json={
+                    "sourceRobotId": arguments["source_robot_id"],
+                    "targetRobotId": arguments["target_robot_id"],
+                    "repositoryId": arguments["repository_id"],
+                },
+            )
+            compatibility = response.get("compatibility", {})
+            score = compatibility.get("overallScore", 0) * 100
+
+            result_text = f"Compatibility Score: {score:.1f}%\n"
+            result_text += f"Adaptation Type: {compatibility.get('adaptationType', 'unknown')}\n"
+            result_text += f"Estimated Effort: {compatibility.get('estimatedEffort', 'unknown')}\n"
+
+            return [TextContent(type="text", text=result_text)]
+
+        elif name == "ate_adapt":
+            response = client._request(
+                "POST",
+                "/skills/adapt",
+                json={
+                    "sourceRobotId": arguments["source_robot_id"],
+                    "targetRobotId": arguments["target_robot_id"],
+                    "repositoryId": arguments["repository_id"],
+                },
+            )
+            plan = response.get("adaptationPlan", {})
+            compatibility = response.get("compatibility", {})
+
+            result_text = "Adaptation Plan:\n\n"
+            result_text += f"Overview: {plan.get('overview', 'No overview available')}\n\n"
+
+            if compatibility:
+                result_text += f"Compatibility Score: {compatibility.get('overallScore', 0) * 100:.1f}%\n"
+                result_text += f"Adaptation Type: {compatibility.get('adaptationType', 'unknown')}\n"
+
+            return [TextContent(type="text", text=result_text)]
+
+        elif name == "ate_get_repository":
+            response = client._request("GET", f"/repositories/{arguments['repo_id']}")
+            repo = response.get("repository", {})
+
+            result_text = f"Repository: {repo.get('name', 'Unknown')}\n"
+            result_text += f"ID: {repo.get('id', 'Unknown')}\n"
+            result_text += f"Description: {repo.get('description', 'No description')}\n"
+            result_text += f"Visibility: {repo.get('visibility', 'unknown')}\n"
+
+            return [TextContent(type="text", text=result_text)]
+
+        elif name == "ate_get_robot":
+            response = client._request("GET", f"/robots/profiles/{arguments['robot_id']}")
+            robot = response.get("profile", {})
+
+            result_text = f"Robot: {robot.get('modelName', 'Unknown')}\n"
+            result_text += f"Manufacturer: {robot.get('manufacturer', 'Unknown')}\n"
+            result_text += f"Category: {robot.get('category', 'Unknown')}\n"
+            result_text += f"Description: {robot.get('description', 'No description')}\n"
+
+            return [TextContent(type="text", text=result_text)]
+
+        else:
+            return [
+                TextContent(
+                    type="text",
+                    text=f"Unknown tool: {name}",
+                )
+            ]
+
+    except Exception as e:
+        return [
+            TextContent(
+                type="text",
+                text=f"Error executing tool {name}: {str(e)}",
+            )
+        ]
+
+
+@server.list_resources()
+async def list_resources() -> List[Resource]:
+    """List available resources"""
+    return [
+        Resource(
+            uri="repository://*",
+            name="Repository",
+            description="Access FoodforThought repository details",
+            mimeType="application/json",
+        ),
+        Resource(
+            uri="robot://*",
+            name="Robot Profile",
+            description="Access robot profile details",
+            mimeType="application/json",
+        ),
+    ]
+
+
+@server.read_resource()
+async def read_resource(uri: str) -> str:
+    """Read a resource"""
+    if uri.startswith("repository://"):
+        repo_id = uri.replace("repository://", "")
+        response = client._request("GET", f"/repositories/{repo_id}")
+        return json.dumps(response.get("repository", {}), indent=2)
+    elif uri.startswith("robot://"):
+        robot_id = uri.replace("robot://", "")
+        response = client._request("GET", f"/robots/profiles/{robot_id}")
+        return json.dumps(response.get("profile", {}), indent=2)
+    else:
+        raise ValueError(f"Unknown resource URI: {uri}")
+
+
+@server.list_prompts()
+async def list_prompts() -> List[Prompt]:
+    """List available prompts"""
+    return [
+        Prompt(
+            name="create_skill",
+            description="Guided workflow for creating a new robot skill repository",
+            arguments=[
+                PromptArgument(
+                    name="robot_model",
+                    description="Target robot model",
+                    required=True,
+                ),
+                PromptArgument(
+                    name="task_description",
+                    description="Description of the skill/task",
+                    required=True,
+                ),
+            ],
+        ),
+        Prompt(
+            name="adapt_skill",
+            description="Guided workflow for adapting a skill between robots",
+            arguments=[
+                PromptArgument(
+                    name="source_robot",
+                    description="Source robot model",
+                    required=True,
+                ),
+                PromptArgument(
+                    name="target_robot",
+                    description="Target robot model",
+                    required=True,
+                ),
+                PromptArgument(
+                    name="repository_id",
+                    description="Repository ID to adapt",
+                    required=True,
+                ),
+            ],
+        ),
+    ]
+
+
+@server.get_prompt()
+async def get_prompt(name: str, arguments: Dict[str, Any]) -> List[TextContent]:
+    """Get prompt content"""
+    if name == "create_skill":
+        return [
+            TextContent(
+                type="text",
+                text=f"""Create a new robot skill for {arguments.get('robot_model', 'your robot')}:
+
+1. Initialize repository: Use ate_init with a descriptive name
+2. Add your skill files (code, configs, documentation)
+3. Commit changes: Use ate_commit with a meaningful message
+4. Push to FoodforThought: Use ate_push
+
+Task: {arguments.get('task_description', 'Not specified')}
+""",
+            )
+        ]
+    elif name == "adapt_skill":
+        return [
+            TextContent(
+                type="text",
+                text=f"""Adapt skill from {arguments.get('source_robot')} to {arguments.get('target_robot')}:
+
+1. Check compatibility: Use ate_compatibility to see if adaptation is feasible
+2. Generate adaptation plan: Use ate_adapt to get detailed adaptation instructions
+3. Review the plan and apply necessary changes
+4. Test the adapted skill
+
+Repository ID: {arguments.get('repository_id')}
+""",
+            )
+        ]
+    else:
+        return [TextContent(type="text", text=f"Unknown prompt: {name}")]
+
+
+async def main():
+    """Main entry point for MCP server"""
+    # Run the server using stdio transport
+    # stdio_server() returns (stdin, stdout) streams
+    stdin, stdout = stdio_server()
+    await server.run(
+        stdin, stdout, server.create_initialization_options()
+    )
+
+
+if __name__ == "__main__":
+    asyncio.run(main())
+

foodforthought_cli-0.1.1.dist-info/METADATA

@@ -0,0 +1,151 @@
+Metadata-Version: 2.4
+Name: foodforthought-cli
+Version: 0.1.1
+Summary: CLI tool for FoodforThought robotics repository platform - manage robot skills and data
+Home-page: https://kindly.fyi/foodforthought
+Author: Kindly Robotics
+Author-email: hello@kindly.fyi
+Project-URL: Homepage, https://kindly.fyi
+Project-URL: Documentation, https://kindly.fyi/foodforthought/cli
+Project-URL: Source, https://github.com/kindlyrobotics/monorepo
+Project-URL: Bug Tracker, https://github.com/kindlyrobotics/monorepo/issues
+Keywords: robotics,robot-skills,machine-learning,data-management,cli
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Software Development :: Version Control
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: requests>=2.28.0
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: project-url
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# FoodforThought CLI
+
+GitHub-like CLI tool for the FoodforThought robotics repository platform.
+
+## Installation
+
+```bash
+pip install foodforthought-cli
+```
+
+Or install from source:
+
+```bash
+cd foodforthought-cli
+pip install -e .
+```
+
+## Configuration
+
+Set environment variables:
+
+```bash
+export ATE_API_URL="https://kindly.fyi/api"
+export ATE_API_KEY="your-api-key-here"
+```
+
+## Usage
+
+### Initialize a repository
+
+```bash
+ate init my-robot-skill -d "A skill for my robot" -v public
+```
+
+### Clone a repository
+
+```bash
+ate clone <repository-id>
+```
+
+### Create a commit
+
+```bash
+ate commit -m "Add new control algorithm"
+```
+
+### Push to remote
+
+```bash
+ate push -b main
+```
+
+### Deploy to robot
+
+```bash
+ate deploy unitree-r1
+```
+
+## Commands
+
+### Repository Management
+- `ate init <name>` - Initialize a new repository
+- `ate clone <repo-id>` - Clone a repository
+- `ate commit -m <message>` - Create a commit
+- `ate push [-b <branch>]` - Push commits to remote
+
+### Skill Pipeline
+- `ate pull <skill-id> [--robot <robot>] [--format json|rlds|lerobot] [--output ./data]` - Pull skill data for training
+- `ate upload <video-path> --robot <robot> --task <task> [--project <id>]` - Upload demonstrations for labeling
+- `ate check-transfer --from <source-robot> --to <target-robot> [--skill <id>]` - Check skill transfer compatibility
+- `ate labeling-status <job-id>` - Check labeling job status
+
+### Deployment & Testing
+- `ate deploy <robot-type>` - Deploy to a robot (e.g., unitree-r1)
+- `ate test [-e gazebo|mujoco|pybullet|webots] [-r robot]` - Test skills in simulation
+- `ate benchmark [-t speed|accuracy|robustness|efficiency|all]` - Run performance benchmarks
+- `ate adapt <source-robot> <target-robot>` - Adapt skills between robots
+
+### Safety & Validation
+- `ate validate [-c collision|speed|workspace|force|all]` - Validate safety and compliance
+- `ate stream [start|stop|status] [-s sensors...]` - Stream sensor data
+
+## Cursor IDE Integration (MCP)
+
+FoodforThought CLI supports Model Context Protocol (MCP) for integration with Cursor IDE.
+
+### Installation
+
+1. Install MCP dependencies:
+   ```bash
+   pip install -r requirements-mcp.txt
+   ```
+
+2. Get your MCP configuration from the [FoodforThought homepage](https://kindly.fyi/foodforthought)
+
+3. Place `mcp.json` in `~/.cursor/mcp.json` (global) or `.cursor/mcp.json` (project)
+
+4. Set your `ATE_API_KEY` environment variable
+
+5. Restart Cursor
+
+### Available MCP Tools
+
+- `ate_init` - Initialize a new repository
+- `ate_clone` - Clone a repository
+- `ate_list_repositories` - List available repositories
+- `ate_list_robots` - List robot profiles
+- `ate_compatibility` - Check skill compatibility between robots
+- `ate_adapt` - Generate adaptation plans for skills
+
+See the [MCP documentation](https://cursor.com/docs/context/mcp) for more information.
+

foodforthought_cli-0.1.1.dist-info/RECORD

@@ -0,0 +1,8 @@
+ate/__init__.py,sha256=GcVHEGyItqo9e3uAgF6cvKZOXJKHgj0-AnRJi-oC00g,105
+ate/cli.py,sha256=GzSb2CwWj629JuBsT5SO-yp9HT5pAxD0A-7c_3Mi_Mc,33831
+ate/mcp_server.py,sha256=O77UKrRS-PigEAftmlG8y57mw6pZOA5OTrt2C-aKgyU,17814
+foodforthought_cli-0.1.1.dist-info/METADATA,sha256=tQ78BUHETRDkw3KWEC6XmOySwRhehofv5WeOLzoCezk,4353
+foodforthought_cli-0.1.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+foodforthought_cli-0.1.1.dist-info/entry_points.txt,sha256=JSxWuXCbGllyHqVJpomP_BDlXYpiNglM9Mo6bEmQK1A,37
+foodforthought_cli-0.1.1.dist-info/top_level.txt,sha256=dlAru-z7a6fWHgnrMWcQhKc8D4eSTXSpFLIUoWZwDlE,4
+foodforthought_cli-0.1.1.dist-info/RECORD,,

foodforthought_cli-0.1.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

foodforthought_cli-0.1.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+ate = ate.cli:main

foodforthought_cli-0.1.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+ate