hanary-mcp 0.2.1__tar.gz

hanary_mcp-0.2.1/.gitignore

@@ -0,0 +1,41 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# Virtual environments
+.venv/
+venv/
+ENV/
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+
+# Testing
+.pytest_cache/
+.coverage
+htmlcov/
+
+# uv
+.uv/
+uv.lock

hanary_mcp-0.2.1/PKG-INFO

@@ -0,0 +1,103 @@
+Metadata-Version: 2.4
+Name: hanary-mcp
+Version: 0.2.1
+Summary: Hanary MCP Server - Task management for Claude Code
+Author: Hanary
+License: MIT
+Keywords: claude,hanary,mcp,task-management
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.10
+Requires-Dist: mcp>=1.0.0
+Requires-Dist: requests>=2.32.5
+Description-Content-Type: text/markdown
+
+# Hanary MCP Server
+
+[Hanary](https://hanary.org) MCP Server for Claude Code - workspace-bound task management.
+
+## Installation
+
+```bash
+# Using uvx (recommended)
+uvx hanary-mcp --workspace my-project
+
+# Or install globally
+uv tool install hanary-mcp
+```
+
+## Configuration
+
+### Claude Code Setup
+
+Add to your project's `.mcp.json`:
+
+```json
+{
+  "mcpServers": {
+    "hanary": {
+      "command": "uvx",
+      "args": ["hanary-mcp", "--workspace", "your-workspace-slug"],
+      "env": {
+        "HANARY_API_TOKEN": "${HANARY_API_TOKEN}"
+      }
+    }
+  }
+}
+```
+
+Or add via CLI:
+
+```bash
+claude mcp add hanary --transport stdio -- uvx hanary-mcp --workspace your-workspace-slug
+```
+
+### Environment Variables
+
+| Variable | Required | Description |
+|----------|----------|-------------|
+| `HANARY_API_TOKEN` | Yes | Your Hanary API token |
+| `HANARY_API_URL` | No | API URL (default: https://hanary.org) |
+
+## Available Tools
+
+### Task Management
+
+- `list_tasks` - List tasks in the workspace
+- `create_task` - Create a new task
+- `update_task` - Update task title/description
+- `complete_task` - Mark task as completed
+- `uncomplete_task` - Mark task as incomplete
+- `delete_task` - Soft delete a task
+- `get_top_task` - Get highest priority incomplete task
+
+### Workspace
+
+- `get_workspace` - Get workspace details
+- `list_workspace_members` - List workspace members
+
+### Messages
+
+- `list_messages` - List workspace messages
+- `create_message` - Send a message
+
+## Development
+
+```bash
+# Clone and install
+git clone https://github.com/hanary/hanary-mcp.git
+cd hanary-mcp
+uv sync
+
+# Run locally
+HANARY_API_TOKEN=your_token uv run hanary-mcp --workspace test
+```
+
+## License
+
+MIT

hanary_mcp-0.2.1/README.md

@@ -0,0 +1,84 @@
+# Hanary MCP Server
+
+[Hanary](https://hanary.org) MCP Server for Claude Code - workspace-bound task management.
+
+## Installation
+
+```bash
+# Using uvx (recommended)
+uvx hanary-mcp --workspace my-project
+
+# Or install globally
+uv tool install hanary-mcp
+```
+
+## Configuration
+
+### Claude Code Setup
+
+Add to your project's `.mcp.json`:
+
+```json
+{
+  "mcpServers": {
+    "hanary": {
+      "command": "uvx",
+      "args": ["hanary-mcp", "--workspace", "your-workspace-slug"],
+      "env": {
+        "HANARY_API_TOKEN": "${HANARY_API_TOKEN}"
+      }
+    }
+  }
+}
+```
+
+Or add via CLI:
+
+```bash
+claude mcp add hanary --transport stdio -- uvx hanary-mcp --workspace your-workspace-slug
+```
+
+### Environment Variables
+
+| Variable | Required | Description |
+|----------|----------|-------------|
+| `HANARY_API_TOKEN` | Yes | Your Hanary API token |
+| `HANARY_API_URL` | No | API URL (default: https://hanary.org) |
+
+## Available Tools
+
+### Task Management
+
+- `list_tasks` - List tasks in the workspace
+- `create_task` - Create a new task
+- `update_task` - Update task title/description
+- `complete_task` - Mark task as completed
+- `uncomplete_task` - Mark task as incomplete
+- `delete_task` - Soft delete a task
+- `get_top_task` - Get highest priority incomplete task
+
+### Workspace
+
+- `get_workspace` - Get workspace details
+- `list_workspace_members` - List workspace members
+
+### Messages
+
+- `list_messages` - List workspace messages
+- `create_message` - Send a message
+
+## Development
+
+```bash
+# Clone and install
+git clone https://github.com/hanary/hanary-mcp.git
+cd hanary-mcp
+uv sync
+
+# Run locally
+HANARY_API_TOKEN=your_token uv run hanary-mcp --workspace test
+```
+
+## License
+
+MIT

hanary_mcp-0.2.1/example.mcp.json

@@ -0,0 +1,11 @@
+{
+  "mcpServers": {
+    "hanary": {
+      "command": "uvx",
+      "args": ["hanary-mcp", "--workspace", "your-workspace-slug"],
+      "env": {
+        "HANARY_API_TOKEN": "${HANARY_API_TOKEN}"
+      }
+    }
+  }
+}

hanary_mcp-0.2.1/pyproject.toml

@@ -0,0 +1,32 @@
+[project]
+name = "hanary-mcp"
+version = "0.2.1"
+description = "Hanary MCP Server - Task management for Claude Code"
+readme = "README.md"
+requires-python = ">=3.10"
+license = { text = "MIT" }
+authors = [{ name = "Hanary" }]
+keywords = ["mcp", "hanary", "claude", "task-management"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+]
+dependencies = [
+    "mcp>=1.0.0",
+    "requests>=2.32.5",
+]
+
+[project.scripts]
+hanary-mcp = "hanary_mcp:main"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/hanary_mcp"]

hanary_mcp-0.2.1/src/hanary_mcp/__init__.py

@@ -0,0 +1,5 @@
+"""Hanary MCP Server - Task management for Claude Code."""
+
+from .server import main
+
+__all__ = ["main"]

hanary_mcp-0.2.1/src/hanary_mcp/client.py

@@ -0,0 +1,163 @@
+"""Hanary API Client for MCP Server."""
+
+import json
+from typing import Optional
+
+import requests
+
+
+class HanaryClient:
+    """Client for Hanary HTTP MCP API."""
+
+    def __init__(self, api_token: str, api_url: str = "https://hanary.org"):
+        self.api_url = api_url.rstrip("/")
+        self.api_token = api_token
+        self._session: Optional[requests.Session] = None
+        self._workspace_id_cache: dict[str, int] = {}
+
+    def _get_session(self) -> requests.Session:
+        if self._session is None:
+            self._session = requests.Session()
+            self._session.headers.update({
+                "Authorization": f"Bearer {self.api_token}",
+                "Content-Type": "application/json",
+                "User-Agent": "curl/8.7.1",
+            })
+        return self._session
+
+    async def _call_mcp(self, method: str, params: dict = None) -> dict:
+        """Call the Hanary MCP endpoint."""
+        session = self._get_session()
+
+        request_body = {
+            "jsonrpc": "2.0",
+            "id": 1,
+            "method": method,
+            "params": params or {},
+        }
+
+        response = session.post(f"{self.api_url}/mcp", json=request_body)
+        response.raise_for_status()
+
+        result = response.json()
+
+        if "error" in result:
+            raise Exception(result["error"].get("message", "Unknown error"))
+
+        return result.get("result", {})
+
+    async def _get_workspace_id(self, workspace_slug: str) -> int:
+        """Get workspace ID from slug (cached)."""
+        if workspace_slug in self._workspace_id_cache:
+            return self._workspace_id_cache[workspace_slug]
+
+        result = await self._call_mcp("tools/call", {
+            "name": "get_workspace",
+            "arguments": {"slug": workspace_slug}
+        })
+
+        content = result.get("content", [])
+        if content:
+            data = json.loads(content[0].get("text", "{}"))
+            workspace = data.get("workspace", {})
+            workspace_id = workspace.get("id")
+            if workspace_id:
+                self._workspace_id_cache[workspace_slug] = workspace_id
+                return workspace_id
+
+        raise Exception(f"Workspace not found: {workspace_slug}")
+
+    async def _call_tool(self, name: str, arguments: dict) -> str:
+        """Call a tool and return the result as string."""
+        result = await self._call_mcp("tools/call", {
+            "name": name,
+            "arguments": arguments,
+        })
+
+        content = result.get("content", [])
+        if content:
+            return content[0].get("text", "{}")
+        return "{}"
+
+    # Task methods
+    async def list_tasks(
+        self, workspace_slug: Optional[str] = None, include_completed: bool = False
+    ) -> str:
+        args = {"include_completed": include_completed}
+        if workspace_slug:
+            workspace_id = await self._get_workspace_id(workspace_slug)
+            args["workspace_id"] = str(workspace_id)
+        return await self._call_tool("list_tasks", args)
+
+    async def create_task(
+        self,
+        title: str,
+        workspace_slug: Optional[str] = None,
+        description: Optional[str] = None,
+        parent_id: Optional[str] = None,
+    ) -> str:
+        args = {"title": title}
+        if workspace_slug:
+            workspace_id = await self._get_workspace_id(workspace_slug)
+            args["workspace_id"] = str(workspace_id)
+        if description:
+            args["description"] = description
+        if parent_id:
+            args["parent_id"] = parent_id
+
+        return await self._call_tool("create_task", args)
+
+    async def update_task(
+        self,
+        task_id: str,
+        title: Optional[str] = None,
+        description: Optional[str] = None,
+    ) -> str:
+        args = {"task_id": task_id}
+        if title:
+            args["title"] = title
+        if description:
+            args["description"] = description
+
+        return await self._call_tool("update_task", args)
+
+    async def complete_task(self, task_id: str) -> str:
+        return await self._call_tool("complete_task", {"task_id": task_id})
+
+    async def uncomplete_task(self, task_id: str) -> str:
+        return await self._call_tool("uncomplete_task", {"task_id": task_id})
+
+    async def delete_task(self, task_id: str) -> str:
+        return await self._call_tool("delete_task", {"task_id": task_id})
+
+    async def get_top_task(self, workspace_slug: Optional[str] = None) -> str:
+        args = {}
+        if workspace_slug:
+            workspace_id = await self._get_workspace_id(workspace_slug)
+            args["workspace_id"] = str(workspace_id)
+        return await self._call_tool("get_top_task", args)
+
+    # Workspace methods
+    async def get_workspace(self, workspace_slug: str) -> str:
+        return await self._call_tool("get_workspace", {"slug": workspace_slug})
+
+    async def list_workspace_members(self, workspace_slug: str) -> str:
+        workspace_id = await self._get_workspace_id(workspace_slug)
+        return await self._call_tool("list_workspace_members", {
+            "workspace_id": str(workspace_id),
+        })
+
+    # Message methods
+    async def list_messages(self, workspace_slug: str, limit: int = 50) -> str:
+        workspace_id = await self._get_workspace_id(workspace_slug)
+        return await self._call_tool("list_messages", {
+            "workspace_id": str(workspace_id),
+            "limit": limit,
+        })
+
+    async def create_message(self, workspace_slug: str, content: str) -> str:
+        workspace_id = await self._get_workspace_id(workspace_slug)
+        return await self._call_tool("create_message", {
+            "workspace_id": str(workspace_id),
+            "content": content,
+        })

hanary_mcp-0.2.1/src/hanary_mcp/server.py

@@ -0,0 +1,287 @@
+"""Hanary MCP Server implementation."""
+
+import argparse
+import os
+import sys
+
+from mcp.server import Server
+from mcp.server.stdio import stdio_server
+from mcp.types import Tool, TextContent
+
+from .client import HanaryClient
+
+
+def create_server(workspace: str | None, client: HanaryClient) -> Server:
+    """Create and configure the MCP server."""
+    server = Server("hanary")
+
+    # Determine mode description
+    if workspace:
+        task_scope = f"workspace '{workspace}'"
+    else:
+        task_scope = "personal tasks (including assigned workspace tasks)"
+
+    @server.list_tools()
+    async def list_tools() -> list[Tool]:
+        tools = [
+            Tool(
+                name="list_tasks",
+                description=f"List tasks for {task_scope}.",
+                inputSchema={
+                    "type": "object",
+                    "properties": {
+                        "include_completed": {
+                            "type": "boolean",
+                            "description": "Include completed tasks (default: false)",
+                        }
+                    },
+                },
+            ),
+            Tool(
+                name="create_task",
+                description=f"Create a new task in {task_scope}.",
+                inputSchema={
+                    "type": "object",
+                    "properties": {
+                        "title": {"type": "string", "description": "Task title (required)"},
+                        "description": {
+                            "type": "string",
+                            "description": "Task description (optional)",
+                        },
+                        "parent_id": {
+                            "type": "string",
+                            "description": "Parent task ID for subtask (optional)",
+                        },
+                    },
+                    "required": ["title"],
+                },
+            ),
+            Tool(
+                name="update_task",
+                description="Update an existing task's title or description.",
+                inputSchema={
+                    "type": "object",
+                    "properties": {
+                        "task_id": {"type": "string", "description": "Task ID (required)"},
+                        "title": {"type": "string", "description": "New title (optional)"},
+                        "description": {
+                            "type": "string",
+                            "description": "New description (optional)",
+                        },
+                    },
+                    "required": ["task_id"],
+                },
+            ),
+            Tool(
+                name="complete_task",
+                description="Mark a task as completed.",
+                inputSchema={
+                    "type": "object",
+                    "properties": {
+                        "task_id": {
+                            "type": "string",
+                            "description": "Task ID to complete (required)",
+                        }
+                    },
+                    "required": ["task_id"],
+                },
+            ),
+            Tool(
+                name="uncomplete_task",
+                description="Mark a completed task as incomplete.",
+                inputSchema={
+                    "type": "object",
+                    "properties": {
+                        "task_id": {
+                            "type": "string",
+                            "description": "Task ID to uncomplete (required)",
+                        }
+                    },
+                    "required": ["task_id"],
+                },
+            ),
+            Tool(
+                name="delete_task",
+                description="Soft delete a task.",
+                inputSchema={
+                    "type": "object",
+                    "properties": {
+                        "task_id": {
+                            "type": "string",
+                            "description": "Task ID to delete (required)",
+                        }
+                    },
+                    "required": ["task_id"],
+                },
+            ),
+            Tool(
+                name="get_top_task",
+                description="Get the highest priority incomplete task. Returns the deepest uncompleted task along with its ancestor chain.",
+                inputSchema={"type": "object", "properties": {}},
+            ),
+        ]
+
+        # Add workspace-only tools when workspace is specified
+        if workspace:
+            tools.extend([
+                Tool(
+                    name="get_workspace",
+                    description="Get details of the current workspace.",
+                    inputSchema={"type": "object", "properties": {}},
+                ),
+                Tool(
+                    name="list_workspace_members",
+                    description="List members of the current workspace.",
+                    inputSchema={"type": "object", "properties": {}},
+                ),
+                Tool(
+                    name="list_messages",
+                    description="List messages in the current workspace.",
+                    inputSchema={
+                        "type": "object",
+                        "properties": {
+                            "limit": {
+                                "type": "integer",
+                                "description": "Number of messages to retrieve (default: 50)",
+                            }
+                        },
+                    },
+                ),
+                Tool(
+                    name="create_message",
+                    description="Send a message to the current workspace.",
+                    inputSchema={
+                        "type": "object",
+                        "properties": {
+                            "content": {
+                                "type": "string",
+                                "description": "Message content (required)",
+                            }
+                        },
+                        "required": ["content"],
+                    },
+                ),
+            ])
+
+        return tools
+
+    @server.call_tool()
+    async def call_tool(name: str, arguments: dict) -> list[TextContent]:
+        try:
+            result = await handle_tool_call(name, arguments, workspace, client)
+            return [TextContent(type="text", text=result)]
+        except Exception as e:
+            return [TextContent(type="text", text=f"Error: {str(e)}")]
+
+    return server
+
+
+async def handle_tool_call(
+    name: str, arguments: dict, workspace: str | None, client: HanaryClient
+) -> str:
+    """Handle individual tool calls."""
+    # Task tools
+    if name == "list_tasks":
+        return await client.list_tasks(
+            workspace_slug=workspace,
+            include_completed=arguments.get("include_completed", False),
+        )
+
+    elif name == "create_task":
+        return await client.create_task(
+            title=arguments["title"],
+            workspace_slug=workspace,
+            description=arguments.get("description"),
+            parent_id=arguments.get("parent_id"),
+        )
+
+    elif name == "update_task":
+        return await client.update_task(
+            task_id=arguments["task_id"],
+            title=arguments.get("title"),
+            description=arguments.get("description"),
+        )
+
+    elif name == "complete_task":
+        return await client.complete_task(task_id=arguments["task_id"])
+
+    elif name == "uncomplete_task":
+        return await client.uncomplete_task(task_id=arguments["task_id"])
+
+    elif name == "delete_task":
+        return await client.delete_task(task_id=arguments["task_id"])
+
+    elif name == "get_top_task":
+        return await client.get_top_task(workspace_slug=workspace)
+
+    # Workspace tools
+    elif name == "get_workspace":
+        return await client.get_workspace(workspace_slug=workspace)
+
+    elif name == "list_workspace_members":
+        return await client.list_workspace_members(workspace_slug=workspace)
+
+    # Message tools
+    elif name == "list_messages":
+        return await client.list_messages(
+            workspace_slug=workspace,
+            limit=arguments.get("limit", 50),
+        )
+
+    elif name == "create_message":
+        return await client.create_message(
+            workspace_slug=workspace,
+            content=arguments["content"],
+        )
+
+    else:
+        raise ValueError(f"Unknown tool: {name}")
+
+
+async def run_server(workspace: str | None, api_token: str, api_url: str):
+    """Run the MCP server."""
+    client = HanaryClient(api_token=api_token, api_url=api_url)
+    server = create_server(workspace, client)
+
+    async with stdio_server() as (read_stream, write_stream):
+        await server.run(read_stream, write_stream, server.create_initialization_options())
+
+
+def main():
+    """Main entry point."""
+    parser = argparse.ArgumentParser(
+        description="Hanary MCP Server - Task management for Claude Code"
+    )
+    parser.add_argument(
+        "--workspace",
+        "-w",
+        default=None,
+        help="Workspace slug to bind to. If not specified, manages personal tasks.",
+    )
+    parser.add_argument(
+        "--token",
+        "-t",
+        default=os.environ.get("HANARY_API_TOKEN"),
+        help="Hanary API token (or set HANARY_API_TOKEN env var)",
+    )
+    parser.add_argument(
+        "--api-url",
+        default=os.environ.get("HANARY_API_URL", "https://hanary.org"),
+        help="Hanary API URL (default: https://hanary.org)",
+    )
+
+    args = parser.parse_args()
+
+    # Get API token from argument or environment
+    api_token = args.token
+    if not api_token:
+        print("Error: --token argument or HANARY_API_TOKEN environment variable is required", file=sys.stderr)
+        sys.exit(1)
+
+    import asyncio
+
+    asyncio.run(run_server(args.workspace, api_token, args.api_url))
+
+
+if __name__ == "__main__":
+    main()