hanary-mcp 0.2.1__tar.gz → 0.8.0__tar.gz

{hanary_mcp-0.2.1 → hanary_mcp-0.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hanary-mcp
-Version: 0.2.1
+Version: 0.8.0
 Summary: Hanary MCP Server - Task management for Claude Code
 Author: Hanary
 License: MIT
@@ -19,13 +19,13 @@ Description-Content-Type: text/markdown
 
 # Hanary MCP Server
 
-[Hanary](https://hanary.org) MCP Server for Claude Code - workspace-bound task management.
+[Hanary](https://hanary.org) MCP Server for Claude Code - squad-bound task management.
 
 ## Installation
 
 ```bash
 # Using uvx (recommended)
-uvx hanary-mcp --workspace my-project
+uvx hanary-mcp --squad my-project
 
 # Or install globally
 uv tool install hanary-mcp
@@ -42,7 +42,7 @@ Add to your project's `.mcp.json`:
   "mcpServers": {
     "hanary": {
       "command": "uvx",
-      "args": ["hanary-mcp", "--workspace", "your-workspace-slug"],
+      "args": ["hanary-mcp", "--squad", "your-squad-slug"],
       "env": {
         "HANARY_API_TOKEN": "${HANARY_API_TOKEN}"
       }
@@ -54,7 +54,7 @@ Add to your project's `.mcp.json`:
 Or add via CLI:
 
 ```bash
-claude mcp add hanary --transport stdio -- uvx hanary-mcp --workspace your-workspace-slug
+claude mcp add hanary --transport stdio -- uvx hanary-mcp --squad your-squad-slug
 ```
 
 ### Environment Variables
@@ -68,7 +68,7 @@ claude mcp add hanary --transport stdio -- uvx hanary-mcp --workspace your-works
 
 ### Task Management
 
-- `list_tasks` - List tasks in the workspace
+- `list_tasks` - List tasks in the squad
 - `create_task` - Create a new task
 - `update_task` - Update task title/description
 - `complete_task` - Mark task as completed
@@ -76,14 +76,14 @@ claude mcp add hanary --transport stdio -- uvx hanary-mcp --workspace your-works
 - `delete_task` - Soft delete a task
 - `get_top_task` - Get highest priority incomplete task
 
-### Workspace
+### Squad
 
-- `get_workspace` - Get workspace details
-- `list_workspace_members` - List workspace members
+- `get_squad` - Get squad details
+- `list_squad_members` - List squad members
 
 ### Messages
 
-- `list_messages` - List workspace messages
+- `list_messages` - List squad messages
 - `create_message` - Send a message
 
 ## Development
@@ -95,7 +95,7 @@ cd hanary-mcp
 uv sync
 
 # Run locally
-HANARY_API_TOKEN=your_token uv run hanary-mcp --workspace test
+HANARY_API_TOKEN=your_token uv run hanary-mcp --squad test
 ```
 
 ## License

{hanary_mcp-0.2.1 → hanary_mcp-0.8.0}/README.md

@@ -1,12 +1,12 @@
 # Hanary MCP Server
 
-[Hanary](https://hanary.org) MCP Server for Claude Code - workspace-bound task management.
+[Hanary](https://hanary.org) MCP Server for Claude Code - squad-bound task management.
 
 ## Installation
 
 ```bash
 # Using uvx (recommended)
-uvx hanary-mcp --workspace my-project
+uvx hanary-mcp --squad my-project
 
 # Or install globally
 uv tool install hanary-mcp
@@ -23,7 +23,7 @@ Add to your project's `.mcp.json`:
   "mcpServers": {
     "hanary": {
       "command": "uvx",
-      "args": ["hanary-mcp", "--workspace", "your-workspace-slug"],
+      "args": ["hanary-mcp", "--squad", "your-squad-slug"],
       "env": {
         "HANARY_API_TOKEN": "${HANARY_API_TOKEN}"
       }
@@ -35,7 +35,7 @@ Add to your project's `.mcp.json`:
 Or add via CLI:
 
 ```bash
-claude mcp add hanary --transport stdio -- uvx hanary-mcp --workspace your-workspace-slug
+claude mcp add hanary --transport stdio -- uvx hanary-mcp --squad your-squad-slug
 ```
 
 ### Environment Variables
@@ -49,7 +49,7 @@ claude mcp add hanary --transport stdio -- uvx hanary-mcp --workspace your-works
 
 ### Task Management
 
-- `list_tasks` - List tasks in the workspace
+- `list_tasks` - List tasks in the squad
 - `create_task` - Create a new task
 - `update_task` - Update task title/description
 - `complete_task` - Mark task as completed
@@ -57,14 +57,14 @@ claude mcp add hanary --transport stdio -- uvx hanary-mcp --workspace your-works
 - `delete_task` - Soft delete a task
 - `get_top_task` - Get highest priority incomplete task
 
-### Workspace
+### Squad
 
-- `get_workspace` - Get workspace details
-- `list_workspace_members` - List workspace members
+- `get_squad` - Get squad details
+- `list_squad_members` - List squad members
 
 ### Messages
 
-- `list_messages` - List workspace messages
+- `list_messages` - List squad messages
 - `create_message` - Send a message
 
 ## Development
@@ -76,7 +76,7 @@ cd hanary-mcp
 uv sync
 
 # Run locally
-HANARY_API_TOKEN=your_token uv run hanary-mcp --workspace test
+HANARY_API_TOKEN=your_token uv run hanary-mcp --squad test
 ```
 
 ## License

{hanary_mcp-0.2.1 → hanary_mcp-0.8.0}/example.mcp.json

@@ -2,7 +2,7 @@
   "mcpServers": {
     "hanary": {
       "command": "uvx",
-      "args": ["hanary-mcp", "--workspace", "your-workspace-slug"],
+      "args": ["hanary-mcp", "--squad", "your-squad-slug"],
       "env": {
         "HANARY_API_TOKEN": "${HANARY_API_TOKEN}"
       }

{hanary_mcp-0.2.1 → hanary_mcp-0.8.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "hanary-mcp"
-version = "0.2.1"
+version = "0.8.0"
 description = "Hanary MCP Server - Task management for Claude Code"
 readme = "README.md"
 requires-python = ">=3.10"

hanary_mcp-0.8.0/src/hanary_mcp/client.py

@@ -0,0 +1,211 @@
+"""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._squad_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_squad_id(self, squad_slug: str) -> int:
+        """Get squad ID from slug (cached)."""
+        if squad_slug in self._squad_id_cache:
+            return self._squad_id_cache[squad_slug]
+
+        result = await self._call_mcp("tools/call", {
+            "name": "get_squad",
+            "arguments": {"slug": squad_slug}
+        })
+
+        content = result.get("content", [])
+        if content:
+            data = json.loads(content[0].get("text", "{}"))
+            squad = data.get("squad", {})
+            squad_id = squad.get("id")
+            if squad_id:
+                self._squad_id_cache[squad_slug] = squad_id
+                return squad_id
+
+        raise Exception(f"Squad not found: {squad_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, squad_slug: Optional[str] = None, include_completed: bool = False
+    ) -> str:
+        args = {"include_completed": include_completed}
+        if squad_slug:
+            squad_id = await self._get_squad_id(squad_slug)
+            args["squad_id"] = str(squad_id)
+        return await self._call_tool("list_tasks", args)
+
+    async def create_task(
+        self,
+        title: str,
+        squad_slug: Optional[str] = None,
+        description: Optional[str] = None,
+        parent_id: Optional[str] = None,
+    ) -> str:
+        args = {"title": title}
+        if squad_slug:
+            squad_id = await self._get_squad_id(squad_slug)
+            args["squad_id"] = str(squad_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, squad_slug: Optional[str] = None) -> str:
+        args = {}
+        if squad_slug:
+            squad_id = await self._get_squad_id(squad_slug)
+            args["squad_id"] = str(squad_id)
+        return await self._call_tool("get_top_task", args)
+
+    async def start_task(self, task_id: str) -> str:
+        return await self._call_tool("start_task", {"task_id": task_id})
+
+    async def stop_task(self, task_id: str) -> str:
+        return await self._call_tool("stop_task", {"task_id": task_id})
+
+    async def reorder_task(self, task_id: str, new_rank: int) -> str:
+        return await self._call_tool("reorder_task", {
+            "task_id": task_id,
+            "new_rank": new_rank,
+        })
+
+    # Calibration methods (Self-Calibration feature)
+    async def get_weekly_stats(self) -> str:
+        return await self._call_tool("get_weekly_stats", {})
+
+    async def get_estimation_accuracy(self) -> str:
+        return await self._call_tool("get_estimation_accuracy", {})
+
+    async def suggest_duration(self, task_id: str) -> str:
+        return await self._call_tool("suggest_duration", {"task_id": task_id})
+
+    async def detect_overload(self) -> str:
+        return await self._call_tool("detect_overload", {})
+
+    async def detect_underload(self) -> str:
+        return await self._call_tool("detect_underload", {})
+
+    # Squad methods
+    async def get_squad(self, squad_slug: str) -> str:
+        return await self._call_tool("get_squad", {"slug": squad_slug})
+
+    async def list_squad_members(self, squad_slug: str) -> str:
+        squad_id = await self._get_squad_id(squad_slug)
+        return await self._call_tool("list_squad_members", {
+            "squad_id": str(squad_id),
+        })
+
+    # Message methods
+    async def list_messages(self, squad_slug: str, limit: int = 50) -> str:
+        squad_id = await self._get_squad_id(squad_slug)
+        return await self._call_tool("list_messages", {
+            "squad_id": str(squad_id),
+            "limit": limit,
+        })
+
+    async def create_message(self, squad_slug: str, content: str) -> str:
+        squad_id = await self._get_squad_id(squad_slug)
+        return await self._call_tool("create_message", {
+            "squad_id": str(squad_id),
+            "content": content,
+        })
+
+    # Session review methods (8시간 초과 자동 중지 세션 관리)
+    async def list_sessions_needing_review(self, squad_slug: Optional[str] = None) -> str:
+        args = {}
+        if squad_slug:
+            squad_id = await self._get_squad_id(squad_slug)
+            args["squad_id"] = str(squad_id)
+        return await self._call_tool("list_sessions_needing_review", args)
+
+    async def approve_session(self, session_id: str) -> str:
+        return await self._call_tool("approve_session", {"session_id": session_id})
+
+    async def review_session(self, session_id: str, ended_at: str) -> str:
+        return await self._call_tool("review_session", {
+            "session_id": session_id,
+            "ended_at": ended_at,
+        })
+
+    async def delete_session(self, session_id: str) -> str:
+        return await self._call_tool("delete_session", {"session_id": session_id})

hanary_mcp-0.8.0/src/hanary_mcp/server.py

@@ -0,0 +1,464 @@
+"""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(squad: str | None, client: HanaryClient) -> Server:
+    """Create and configure the MCP server."""
+    server = Server("hanary")
+
+    # Determine mode description
+    if squad:
+        task_scope = f"squad '{squad}'"
+    else:
+        task_scope = "personal tasks (including assigned squad 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": {}},
+            ),
+            Tool(
+                name="start_task",
+                description="Start time tracking for a task. Creates a new time session.",
+                inputSchema={
+                    "type": "object",
+                    "properties": {
+                        "task_id": {
+                            "type": "string",
+                            "description": "Task ID to start time tracking (required)",
+                        }
+                    },
+                    "required": ["task_id"],
+                },
+            ),
+            Tool(
+                name="stop_task",
+                description="Stop time tracking for a task. Ends the current time session.",
+                inputSchema={
+                    "type": "object",
+                    "properties": {
+                        "task_id": {
+                            "type": "string",
+                            "description": "Task ID to stop time tracking (required)",
+                        }
+                    },
+                    "required": ["task_id"],
+                },
+            ),
+            Tool(
+                name="reorder_task",
+                description="Change the order of a task among its siblings. Moves the task to the specified rank position.",
+                inputSchema={
+                    "type": "object",
+                    "properties": {
+                        "task_id": {
+                            "type": "string",
+                            "description": "Task ID to reorder (required)",
+                        },
+                        "new_rank": {
+                            "type": "integer",
+                            "description": "New rank position (0-based index among siblings, required)",
+                        },
+                    },
+                    "required": ["task_id", "new_rank"],
+                },
+            ),
+            # Calibration tools (Self-Calibration feature)
+            Tool(
+                name="get_weekly_stats",
+                description="Get weekly task completion statistics for the past 4 weeks. Returns weekly averages of time spent on tasks.",
+                inputSchema={"type": "object", "properties": {}},
+            ),
+            Tool(
+                name="get_estimation_accuracy",
+                description="Get estimation accuracy statistics. Returns the ratio of actual time spent vs estimated time. Ratio > 1.0 means underestimating, < 1.0 means overestimating.",
+                inputSchema={"type": "object", "properties": {}},
+            ),
+            Tool(
+                name="suggest_duration",
+                description="Get suggested duration for a task based on similar completed tasks. Useful for setting realistic time estimates.",
+                inputSchema={
+                    "type": "object",
+                    "properties": {
+                        "task_id": {
+                            "type": "string",
+                            "description": "Task ID to get suggestion for (required)",
+                        }
+                    },
+                    "required": ["task_id"],
+                },
+            ),
+            Tool(
+                name="detect_overload",
+                description="Detect overload signals. Checks for: tasks taking 2x longer than estimated, stale tasks (7+ days incomplete), low completion rate.",
+                inputSchema={"type": "object", "properties": {}},
+            ),
+            Tool(
+                name="detect_underload",
+                description="Detect underload signals. Checks if tasks are being completed in less than 50% of estimated time.",
+                inputSchema={"type": "object", "properties": {}},
+            ),
+            # Session review tools (8시간 초과 자동 중지 세션 관리)
+            Tool(
+                name="list_sessions_needing_review",
+                description="List time sessions that need review. These are sessions that were auto-stopped after 8+ hours and may need time correction.",
+                inputSchema={"type": "object", "properties": {}},
+            ),
+            Tool(
+                name="approve_session",
+                description="Approve an auto-stopped session. Keeps the recorded time as-is and removes the needs_review flag.",
+                inputSchema={
+                    "type": "object",
+                    "properties": {
+                        "session_id": {
+                            "type": "string",
+                            "description": "Session ID to approve (required)",
+                        }
+                    },
+                    "required": ["session_id"],
+                },
+            ),
+            Tool(
+                name="review_session",
+                description="Review and correct an auto-stopped session's end time.",
+                inputSchema={
+                    "type": "object",
+                    "properties": {
+                        "session_id": {
+                            "type": "string",
+                            "description": "Session ID to review (required)",
+                        },
+                        "ended_at": {
+                            "type": "string",
+                            "description": "Corrected end time in ISO 8601 format (required)",
+                        },
+                    },
+                    "required": ["session_id", "ended_at"],
+                },
+            ),
+            Tool(
+                name="delete_session",
+                description="Delete a time session. Also recalculates the task's total time spent.",
+                inputSchema={
+                    "type": "object",
+                    "properties": {
+                        "session_id": {
+                            "type": "string",
+                            "description": "Session ID to delete (required)",
+                        },
+                    },
+                    "required": ["session_id"],
+                },
+            ),
+        ]
+
+        # Add squad-only tools when squad is specified
+        if squad:
+            tools.extend([
+                Tool(
+                    name="get_squad",
+                    description="Get details of the current squad.",
+                    inputSchema={"type": "object", "properties": {}},
+                ),
+                Tool(
+                    name="list_squad_members",
+                    description="List members of the current squad.",
+                    inputSchema={"type": "object", "properties": {}},
+                ),
+                Tool(
+                    name="list_messages",
+                    description="List messages in the current squad.",
+                    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 squad.",
+                    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, squad, 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, squad: str | None, client: HanaryClient
+) -> str:
+    """Handle individual tool calls."""
+    # Task tools
+    if name == "list_tasks":
+        return await client.list_tasks(
+            squad_slug=squad,
+            include_completed=arguments.get("include_completed", False),
+        )
+
+    elif name == "create_task":
+        return await client.create_task(
+            title=arguments["title"],
+            squad_slug=squad,
+            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(squad_slug=squad)
+
+    elif name == "start_task":
+        return await client.start_task(task_id=arguments["task_id"])
+
+    elif name == "stop_task":
+        return await client.stop_task(task_id=arguments["task_id"])
+
+    elif name == "reorder_task":
+        return await client.reorder_task(
+            task_id=arguments["task_id"],
+            new_rank=arguments["new_rank"],
+        )
+
+    # Calibration tools
+    elif name == "get_weekly_stats":
+        return await client.get_weekly_stats()
+
+    elif name == "get_estimation_accuracy":
+        return await client.get_estimation_accuracy()
+
+    elif name == "suggest_duration":
+        return await client.suggest_duration(task_id=arguments["task_id"])
+
+    elif name == "detect_overload":
+        return await client.detect_overload()
+
+    elif name == "detect_underload":
+        return await client.detect_underload()
+
+    # Session review tools
+    elif name == "list_sessions_needing_review":
+        return await client.list_sessions_needing_review(squad_slug=squad)
+
+    elif name == "approve_session":
+        return await client.approve_session(session_id=arguments["session_id"])
+
+    elif name == "review_session":
+        return await client.review_session(
+            session_id=arguments["session_id"],
+            ended_at=arguments["ended_at"],
+        )
+
+    elif name == "delete_session":
+        return await client.delete_session(session_id=arguments["session_id"])
+
+    # Squad tools
+    elif name == "get_squad":
+        return await client.get_squad(squad_slug=squad)
+
+    elif name == "list_squad_members":
+        return await client.list_squad_members(squad_slug=squad)
+
+    # Message tools
+    elif name == "list_messages":
+        return await client.list_messages(
+            squad_slug=squad,
+            limit=arguments.get("limit", 50),
+        )
+
+    elif name == "create_message":
+        return await client.create_message(
+            squad_slug=squad,
+            content=arguments["content"],
+        )
+
+    else:
+        raise ValueError(f"Unknown tool: {name}")
+
+
+async def run_server(squad: 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(squad, 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(
+        "--squad",
+        "-s",
+        default=None,
+        help="Squad 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.squad, api_token, args.api_url))
+
+
+if __name__ == "__main__":
+    main()

hanary_mcp-0.2.1/src/hanary_mcp/client.py

@@ -1,163 +0,0 @@
-"""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

@@ -1,287 +0,0 @@
-"""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()