ctrlcode 0.1.0__py3-none-any.whl

ctrlcode/tools/registry.py

@@ -0,0 +1,193 @@
+"""Tool registry for managing MCP servers and tools."""
+
+from typing import Any, Optional, Callable
+import logging
+from dataclasses import dataclass
+
+from .mcp import MCPClient, MCPTool
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class BuiltinTool:
+    """Built-in tool definition."""
+
+    name: str
+    description: str
+    input_schema: dict[str, Any]
+    function: Callable
+
+
+class ToolRegistry:
+    """Registry for MCP and built-in tools."""
+
+    def __init__(self):
+        """Initialize tool registry."""
+        self.clients: dict[str, MCPClient] = {}
+        self.mcp_tools: dict[str, MCPTool] = {}  # tool_name -> MCPTool
+        self.builtin_tools: dict[str, BuiltinTool] = {}  # tool_name -> BuiltinTool
+
+    async def add_server(self, server_config: dict[str, Any]) -> None:
+        """
+        Add and start an MCP server.
+
+        Args:
+            server_config: Server configuration
+        """
+        server_name = server_config.get("name", "unknown")
+
+        try:
+            client = MCPClient(server_config)
+            await client.start()
+
+            # List tools
+            tools = await client.list_tools()
+            logger.info(f"Server '{server_name}' provides {len(tools)} tools")
+
+            # Register tools
+            for tool in tools:
+                if tool.name in self.mcp_tools or tool.name in self.builtin_tools:
+                    logger.warning(f"Tool '{tool.name}' already registered, skipping")
+                else:
+                    self.mcp_tools[tool.name] = tool
+
+            # Store client
+            self.clients[server_name] = client
+
+        except Exception as e:
+            logger.error(f"Failed to start server '{server_name}': {e}")
+
+    def register_builtin(
+        self,
+        name: str,
+        description: str,
+        input_schema: dict[str, Any],
+        function: Callable,
+    ) -> None:
+        """
+        Register a built-in tool.
+
+        Args:
+            name: Tool name
+            description: Tool description
+            input_schema: JSON schema for tool inputs
+            function: Callable that implements the tool
+        """
+        if name in self.mcp_tools or name in self.builtin_tools:
+            logger.warning(f"Tool '{name}' already registered, skipping")
+            return
+
+        tool = BuiltinTool(
+            name=name,
+            description=description,
+            input_schema=input_schema,
+            function=function,
+        )
+
+        self.builtin_tools[name] = tool
+        logger.info(f"Registered built-in tool: {name}")
+
+    async def remove_server(self, server_name: str) -> None:
+        """
+        Remove and stop an MCP server.
+
+        Args:
+            server_name: Name of server to remove
+        """
+        if server_name in self.clients:
+            client = self.clients[server_name]
+            await client.stop()
+            del self.clients[server_name]
+
+            # Remove tools from this server
+            self.mcp_tools = {
+                name: tool
+                for name, tool in self.mcp_tools.items()
+                if tool.server_name != server_name
+            }
+
+    def get_tool(self, tool_name: str) -> Optional[MCPTool | BuiltinTool]:
+        """
+        Get tool by name (MCP or built-in).
+
+        Args:
+            tool_name: Name of tool
+
+        Returns:
+            Tool or None if not found
+        """
+        return self.mcp_tools.get(tool_name) or self.builtin_tools.get(tool_name)
+
+    def is_builtin(self, tool_name: str) -> bool:
+        """Check if tool is built-in."""
+        return tool_name in self.builtin_tools
+
+    def list_tools(self) -> list[MCPTool | BuiltinTool]:
+        """
+        List all available tools (MCP and built-in).
+
+        Returns:
+            List of all registered tools
+        """
+        return list(self.mcp_tools.values()) + list(self.builtin_tools.values())
+
+    def get_client(self, server_name: str) -> Optional[MCPClient]:
+        """
+        Get MCP client by server name.
+
+        Args:
+            server_name: Server name
+
+        Returns:
+            Client or None if not found
+        """
+        return self.clients.get(server_name)
+
+    def get_tool_definitions(self) -> list[dict[str, Any]]:
+        """
+        Get tool definitions in provider format (both MCP and built-in).
+
+        Returns:
+            List of tool definitions for LLM providers
+        """
+        definitions = []
+
+        # MCP tools
+        for tool in self.mcp_tools.values():
+            definitions.append({
+                "name": tool.name,
+                "description": tool.description,
+                "input_schema": tool.input_schema,
+            })
+
+        # Built-in tools
+        for tool in self.builtin_tools.values():
+            definitions.append({
+                "name": tool.name,
+                "description": tool.description,
+                "input_schema": tool.input_schema,
+            })
+
+        return definitions
+
+    def get_tool_definitions_filtered(self, allowed_tools: list[str]) -> list[dict[str, Any]]:
+        """
+        Get tool definitions filtered by allowed tool names.
+
+        Args:
+            allowed_tools: List of tool names to include
+
+        Returns:
+            Filtered list of tool definitions
+        """
+        all_tools = self.get_tool_definitions()
+        return [tool for tool in all_tools if tool["name"] in allowed_tools]
+
+    async def close_all(self) -> None:
+        """Close all MCP clients."""
+        for client in self.clients.values():
+            await client.stop()
+        self.clients.clear()
+        self.mcp_tools.clear()
+        self.builtin_tools.clear()

ctrlcode/tools/todo.py

@@ -0,0 +1,291 @@
+"""Built-in todo list tools for task management."""
+
+import json
+import fcntl
+import uuid
+from pathlib import Path
+from time import time
+from typing import Any
+
+
+class TodoTools:
+    """Built-in tools for managing todo lists."""
+
+    def __init__(self, data_dir: str | Path):
+        """
+        Initialize todo tools.
+
+        Args:
+            data_dir: Data directory for storing todos
+        """
+        self.data_dir = Path(data_dir)
+        self.todos_dir = self.data_dir / "todos"
+        self.todos_dir.mkdir(parents=True, exist_ok=True)
+
+    def _get_todo_file(self, session_id: str | None) -> Path:
+        """Get path to todo file for session."""
+        if session_id:
+            return self.todos_dir / f"{session_id}.json"
+        return self.todos_dir / "global.json"
+
+    def _read_todos(self, file_path: Path) -> list[dict]:
+        """Read todos from file with locking."""
+        if not file_path.exists():
+            return []
+
+        try:
+            with open(file_path, "r") as f:
+                fcntl.flock(f.fileno(), fcntl.LOCK_SH)
+                try:
+                    data = json.load(f)
+                    return data if isinstance(data, list) else []
+                finally:
+                    fcntl.flock(f.fileno(), fcntl.LOCK_UN)
+        except (json.JSONDecodeError, IOError):
+            return []
+
+    def _write_todos(self, file_path: Path, todos: list[dict]) -> None:
+        """Write todos to file atomically with locking."""
+        temp_path = file_path.with_suffix(".tmp")
+
+        try:
+            # Write to temp file with exclusive lock
+            with open(temp_path, "w") as f:
+                fcntl.flock(f.fileno(), fcntl.LOCK_EX)
+                try:
+                    json.dump(todos, f, indent=2)
+                    f.flush()
+                finally:
+                    fcntl.flock(f.fileno(), fcntl.LOCK_UN)
+
+            # Atomic rename
+            temp_path.replace(file_path)
+        except Exception as e:
+            if temp_path.exists():
+                temp_path.unlink()
+            raise e
+
+    def todo_write(
+        self, items: list[dict[str, Any]], session_id: str | None = None
+    ) -> dict[str, Any]:
+        """
+        Create or append todo items.
+
+        Args:
+            items: List of todo items with 'content' and optional 'activeForm', 'priority', 'status'
+            session_id: Optional session ID for session-specific todos
+
+        Returns:
+            Dict with success status and created todos
+        """
+        try:
+            file_path = self._get_todo_file(session_id)
+            todos = self._read_todos(file_path)
+            current_time = time()
+
+            created = []
+            for item in items:
+                if not item.get("content"):
+                    continue
+
+                todo = {
+                    "id": str(uuid.uuid4()),
+                    "content": item["content"],
+                    "status": item.get("status", "pending"),
+                    "activeForm": item.get("activeForm", item["content"]),
+                    "priority": item.get("priority", "medium"),
+                    "created_at": current_time,
+                    "updated_at": current_time,
+                }
+                todos.append(todo)
+                created.append(todo)
+
+            self._write_todos(file_path, todos)
+            return {"success": True, "todos": created, "error": None}
+
+        except Exception as e:
+            return {"success": False, "todos": [], "error": str(e)}
+
+    def todo_list(
+        self, session_id: str | None = None, status: str | None = None
+    ) -> dict[str, Any]:
+        """
+        List todo items with optional filtering.
+
+        Args:
+            session_id: Optional session ID for session-specific todos
+            status: Optional status filter (pending, in_progress, completed)
+
+        Returns:
+            Dict with success status and todos list
+        """
+        try:
+            file_path = self._get_todo_file(session_id)
+            todos = self._read_todos(file_path)
+
+            if status:
+                todos = [t for t in todos if t.get("status") == status]
+
+            return {"success": True, "todos": todos, "error": None}
+
+        except Exception as e:
+            return {"success": False, "todos": [], "error": str(e)}
+
+    def todo_update(
+        self,
+        id: str,
+        status: str | None = None,
+        content: str | None = None,
+        activeForm: str | None = None,
+        priority: str | None = None,
+        session_id: str | None = None,
+    ) -> dict[str, Any]:
+        """
+        Update an existing todo item.
+
+        Args:
+            id: UUID of the todo to update
+            status: New status (pending, in_progress, completed)
+            content: New content
+            activeForm: Present continuous form shown when in progress
+            priority: New priority (high, medium, low)
+            session_id: Optional session ID for session-specific todos
+
+        Returns:
+            Dict with success status and updated todo
+        """
+        try:
+            file_path = self._get_todo_file(session_id)
+            todos = self._read_todos(file_path)
+
+            todo_found = None
+            for todo in todos:
+                if todo.get("id") == id:
+                    todo_found = todo
+                    if status is not None:
+                        todo["status"] = status
+                    if content is not None:
+                        todo["content"] = content
+                    if activeForm is not None:
+                        todo["activeForm"] = activeForm
+                    if priority is not None:
+                        todo["priority"] = priority
+                    todo["updated_at"] = time()
+                    break
+
+            if not todo_found:
+                return {
+                    "success": False,
+                    "todos": [],
+                    "error": f"Todo with id '{id}' not found",
+                }
+
+            self._write_todos(file_path, todos)
+            return {"success": True, "todos": [todo_found], "error": None}
+
+        except Exception as e:
+            return {"success": False, "todos": [], "error": str(e)}
+
+
+# Tool schemas for LLM providers (Anthropic/OpenAI format)
+TODO_TOOL_SCHEMAS = [
+    {
+        "name": "todo_write",
+        "description": "Create or append todo items for task tracking. Use this when planning work or breaking down complex tasks.",
+        "input_schema": {
+            "type": "object",
+            "properties": {
+                "items": {
+                    "type": "array",
+                    "description": "List of todo items to create",
+                    "items": {
+                        "type": "object",
+                        "properties": {
+                            "content": {
+                                "type": "string",
+                                "description": "Task description (brief, actionable)",
+                            },
+                            "activeForm": {
+                                "type": "string",
+                                "description": "Present continuous form shown when in progress (e.g., 'Running tests')",
+                            },
+                            "priority": {
+                                "type": "string",
+                                "description": "Task priority",
+                                "enum": ["high", "medium", "low"],
+                                "default": "medium",
+                            },
+                            "status": {
+                                "type": "string",
+                                "description": "Initial status",
+                                "enum": ["pending", "in_progress", "completed"],
+                                "default": "pending",
+                            },
+                        },
+                        "required": ["content"],
+                    },
+                },
+                "session_id": {
+                    "type": "string",
+                    "description": "Optional session ID for session-specific todos",
+                },
+            },
+            "required": ["items"],
+        },
+    },
+    {
+        "name": "todo_list",
+        "description": "List todos with optional filtering by status. Use this to check what tasks are pending or track progress.",
+        "input_schema": {
+            "type": "object",
+            "properties": {
+                "session_id": {
+                    "type": "string",
+                    "description": "Optional session ID for session-specific todos",
+                },
+                "status": {
+                    "type": "string",
+                    "description": "Filter by status",
+                    "enum": ["pending", "in_progress", "completed"],
+                },
+            },
+            "required": [],
+        },
+    },
+    {
+        "name": "todo_update",
+        "description": "Update an existing todo item. Use this to mark tasks as in progress or completed, or modify task details.",
+        "input_schema": {
+            "type": "object",
+            "properties": {
+                "id": {
+                    "type": "string",
+                    "description": "UUID of the todo to update",
+                },
+                "status": {
+                    "type": "string",
+                    "description": "New status",
+                    "enum": ["pending", "in_progress", "completed"],
+                },
+                "content": {
+                    "type": "string",
+                    "description": "New task description",
+                },
+                "activeForm": {
+                    "type": "string",
+                    "description": "Present continuous form shown when in progress (e.g., 'Running tests')",
+                },
+                "priority": {
+                    "type": "string",
+                    "description": "New priority",
+                    "enum": ["high", "medium", "low"],
+                },
+                "session_id": {
+                    "type": "string",
+                    "description": "Optional session ID for session-specific todos",
+                },
+            },
+            "required": ["id"],
+        },
+    },
+]