skydeckai-code 0.1.40__tar.gz → 0.1.41__tar.gz

{skydeckai_code-0.1.40 → skydeckai_code-0.1.41}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: skydeckai-code
-Version: 0.1.40
-Summary: This MCP server provides a comprehensive set of tools for AI-driven Development workflows including file operations, code analysis, multi-language execution, web content fetching with HTML-to-markdown conversion, multi-engine web search, code content searching, and system information retrieval.
+Version: 0.1.41
+Summary: This MCP server provides a comprehensive set of tools for AI-driven Development workflows including file operations, code analysis, multi-language execution, web content fetching with HTML-to-markdown conversion, multi-engine web search, code content searching, persistent task management, and system information retrieval.
 Project-URL: Homepage, https://github.com/skydeckai/skydeckai-code
 Project-URL: Repository, https://github.com/skydeckai/skydeckai-code
 Project-URL: Documentation, https://github.com/skydeckai/skydeckai-code/blob/main/README.md
@@ -87,7 +87,7 @@ If you're using MseeP AI Helper app, you can search for "SkyDeckAI Code" and ins
 -   Screenshot and screen context tools
 -   Image handling tools
 
-## Available Tools (26)
+## Available Tools (29)
 
 | Category         | Tool Name                  | Description                                  |
 | ---------------- | -------------------------- | -------------------------------------------- |
@@ -117,6 +117,9 @@ If you're using MseeP AI Helper app, you can search for "SkyDeckAI Code" and ins
 | **System**       | `get_system_info`          | Get detailed system information              |
 | **Utility**      | `batch_tools`              | Run multiple tool operations together        |
 |                  | `think`                    | Document reasoning without making changes    |
+| **Todo**         | `todo_read`                | Read current workspace todo list             |
+|                  | `todo_write`               | Replace entire todo list with validation     |
+|                  | `todo_update`              | Update specific todo item by ID              |
 
 ## Detailed Tool Documentation
 
@@ -614,6 +617,111 @@ This tool executes arbitrary shell commands on your system. Always:
 4. Be aware of potential system impacts
 5. Monitor execution output
 
+### Todo Tools
+
+The todo tools provide sequential task management capabilities for workspace-first development workflows. Tasks are executed in order without priority systems, ensuring structured progress through development phases.
+
+#### todo_read
+
+Read the current todo list for the workspace.
+
+```json
+{}
+```
+
+**Returns:**
+```json
+{
+  "todos": [
+    {
+      "id": "abc123",
+      "content": "Implement user authentication",
+      "status": "in_progress",
+      "metadata": {
+        "custom_key": "custom_value"
+      },
+      "created_at": "2023-10-01T10:00:00Z",
+      "updated_at": "2023-10-01T11:30:00Z"
+    }
+  ],
+  "count": 1,
+  "workspace": "/path/to/workspace"
+}
+```
+
+#### todo_write
+
+Replace the entire todo list for sequential execution workflow. Tasks are executed in array order, building upon previous work.
+
+```json
+{
+  "todos": [
+    {
+      "id": "task1",
+      "content": "Set up database schema",
+      "status": "pending"
+    },
+    {
+      "id": "task2", 
+      "content": "Create API endpoints",
+      "status": "pending",
+      "metadata": {
+        "custom_key": "custom_value"
+      }
+    }
+  ]
+}
+```
+
+**Sequential Workflow Rules:**
+- Each todo must have unique ID
+- Only one task can be "in_progress" at a time (sequential execution)
+- Tasks execute in array order - no priority system
+- Required fields: id, content, status
+- Status values: "pending", "in_progress", "completed"
+- Workspace-first: Todo management is mandatory for all workspace operations
+
+#### todo_update
+
+Update a specific todo item by ID for sequential workflow progression.
+
+```json
+{
+  "todo_id": "task1",
+  "updates": {
+    "status": "in_progress",
+    "metadata": {
+        "new_key": "new_value"
+    }
+  }
+}
+```
+
+**Returns:**
+```json
+{
+  "success": true,
+  "updated_todo": {
+    "id": "task1",
+    "content": "Set up database schema",
+    "status": "in_progress",
+    "updated_at": "2023-10-01T12:00:00Z",
+    "metadata": {
+        "new_key": "new_value"
+    }
+  },
+  "counts": {
+    "pending": 1,
+    "in_progress": 1,
+    "completed": 0,
+    "total": 2
+  },
+  "workspace": "/path/to/workspace"
+}
+```
+
+The todo system maintains separate sequential task lists for each workspace, enforcing mandatory usage for all workspace operations. Tasks execute in order, building upon previous work without priority-based scheduling.
+
 ## Configuration
 
 Configuration file: `~/.skydeckai_code/config.json`

{skydeckai_code-0.1.40 → skydeckai_code-0.1.41}/README.md

@@ -52,7 +52,7 @@ If you're using MseeP AI Helper app, you can search for "SkyDeckAI Code" and ins
 -   Screenshot and screen context tools
 -   Image handling tools
 
-## Available Tools (26)
+## Available Tools (29)
 
 | Category         | Tool Name                  | Description                                  |
 | ---------------- | -------------------------- | -------------------------------------------- |
@@ -82,6 +82,9 @@ If you're using MseeP AI Helper app, you can search for "SkyDeckAI Code" and ins
 | **System**       | `get_system_info`          | Get detailed system information              |
 | **Utility**      | `batch_tools`              | Run multiple tool operations together        |
 |                  | `think`                    | Document reasoning without making changes    |
+| **Todo**         | `todo_read`                | Read current workspace todo list             |
+|                  | `todo_write`               | Replace entire todo list with validation     |
+|                  | `todo_update`              | Update specific todo item by ID              |
 
 ## Detailed Tool Documentation
 
@@ -579,6 +582,111 @@ This tool executes arbitrary shell commands on your system. Always:
 4. Be aware of potential system impacts
 5. Monitor execution output
 
+### Todo Tools
+
+The todo tools provide sequential task management capabilities for workspace-first development workflows. Tasks are executed in order without priority systems, ensuring structured progress through development phases.
+
+#### todo_read
+
+Read the current todo list for the workspace.
+
+```json
+{}
+```
+
+**Returns:**
+```json
+{
+  "todos": [
+    {
+      "id": "abc123",
+      "content": "Implement user authentication",
+      "status": "in_progress",
+      "metadata": {
+        "custom_key": "custom_value"
+      },
+      "created_at": "2023-10-01T10:00:00Z",
+      "updated_at": "2023-10-01T11:30:00Z"
+    }
+  ],
+  "count": 1,
+  "workspace": "/path/to/workspace"
+}
+```
+
+#### todo_write
+
+Replace the entire todo list for sequential execution workflow. Tasks are executed in array order, building upon previous work.
+
+```json
+{
+  "todos": [
+    {
+      "id": "task1",
+      "content": "Set up database schema",
+      "status": "pending"
+    },
+    {
+      "id": "task2", 
+      "content": "Create API endpoints",
+      "status": "pending",
+      "metadata": {
+        "custom_key": "custom_value"
+      }
+    }
+  ]
+}
+```
+
+**Sequential Workflow Rules:**
+- Each todo must have unique ID
+- Only one task can be "in_progress" at a time (sequential execution)
+- Tasks execute in array order - no priority system
+- Required fields: id, content, status
+- Status values: "pending", "in_progress", "completed"
+- Workspace-first: Todo management is mandatory for all workspace operations
+
+#### todo_update
+
+Update a specific todo item by ID for sequential workflow progression.
+
+```json
+{
+  "todo_id": "task1",
+  "updates": {
+    "status": "in_progress",
+    "metadata": {
+        "new_key": "new_value"
+    }
+  }
+}
+```
+
+**Returns:**
+```json
+{
+  "success": true,
+  "updated_todo": {
+    "id": "task1",
+    "content": "Set up database schema",
+    "status": "in_progress",
+    "updated_at": "2023-10-01T12:00:00Z",
+    "metadata": {
+        "new_key": "new_value"
+    }
+  },
+  "counts": {
+    "pending": 1,
+    "in_progress": 1,
+    "completed": 0,
+    "total": 2
+  },
+  "workspace": "/path/to/workspace"
+}
+```
+
+The todo system maintains separate sequential task lists for each workspace, enforcing mandatory usage for all workspace operations. Tasks execute in order, building upon previous work without priority-based scheduling.
+
 ## Configuration
 
 Configuration file: `~/.skydeckai_code/config.json`

{skydeckai_code-0.1.40 → skydeckai_code-0.1.41}/pyproject.toml

@@ -1,7 +1,7 @@
 [project]
 name = "skydeckai-code"
-version = "0.1.40"
-description = "This MCP server provides a comprehensive set of tools for AI-driven Development workflows including file operations, code analysis, multi-language execution, web content fetching with HTML-to-markdown conversion, multi-engine web search, code content searching, and system information retrieval."
+version = "0.1.41"
+description = "This MCP server provides a comprehensive set of tools for AI-driven Development workflows including file operations, code analysis, multi-language execution, web content fetching with HTML-to-markdown conversion, multi-engine web search, code content searching, persistent task management, and system information retrieval."
 readme = "README.md"
 requires-python = ">=3.11"
 authors = [{name = "SkyDeck.ai", email = "support@skydeck.ai"}]

{skydeckai_code-0.1.40 → skydeckai_code-0.1.41}/src/aidd/tools/__init__.py

@@ -47,6 +47,14 @@ from .screenshot_tool import (
     handle_capture_screenshot,
 )
 from .system_tools import get_system_info_tool, handle_get_system_info
+from .todo_tools import (
+    todo_read_tool,
+    todo_write_tool,
+    todo_update_tool,
+    handle_todo_read,
+    handle_todo_write,
+    handle_todo_update,
+)
 from .web_tools import web_fetch_tool, handle_web_fetch, web_search_tool, handle_web_search
 
 # Export all tools definitions
@@ -82,6 +90,10 @@ TOOL_DEFINITIONS = [
     web_search_tool(),
     # System tools
     get_system_info_tool(),
+    # Todo tools
+    todo_read_tool(),
+    todo_write_tool(),
+    todo_update_tool(),
 ]
 
 # Export all handlers
@@ -116,4 +128,8 @@ TOOL_HANDLERS = {
     # Web handlers
     "web_fetch": handle_web_fetch,
     "web_search": handle_web_search,
+    # Todo handlers
+    "todo_read": handle_todo_read,
+    "todo_write": handle_todo_write,
+    "todo_update": handle_todo_update,
 }

skydeckai_code-0.1.41/src/aidd/tools/todo_store.py

@@ -0,0 +1,257 @@
+from .state import state
+from datetime import datetime
+from pathlib import Path
+from typing import Any, Dict, List
+import json
+
+
+class TodoStore:
+    """Manages todo persistence and operations."""
+
+    def __init__(self):
+        self._cached_store = None
+        self._last_workspace = None
+
+    @property
+    def workspace_path(self) -> Path:
+        """Get the current workspace directory."""
+        return Path(state.allowed_directory)
+
+    @property
+    def todos_file_path(self) -> Path:
+        """Get the path to the global todos file."""
+        return state.config_dir / "todos.json"
+
+    def _detect_workspace_change(self) -> bool:
+        """Check if workspace has changed since last access."""
+        current_workspace = str(self.workspace_path)
+        if self._last_workspace != current_workspace:
+            self._last_workspace = current_workspace
+            self._cached_store = None
+            return True
+        return False
+
+    def _load_store(self) -> Dict[str, Any]:
+        """Load todos from file with caching."""
+        self._detect_workspace_change()
+
+        if self._cached_store is not None:
+            return self._cached_store
+
+        workspace_key = str(self.workspace_path)
+
+        if not self.todos_file_path.exists():
+            self._cached_store = {"lastModified": datetime.now().isoformat(), "todos": []}
+            return self._cached_store
+
+        try:
+            with open(self.todos_file_path, "r", encoding="utf-8") as f:
+                global_data = json.load(f)
+                workspace_data = global_data.get(workspace_key, {})
+                self._cached_store = {"lastModified": workspace_data.get("lastModified", datetime.now().isoformat()), "todos": workspace_data.get("todos", [])}
+                return self._cached_store
+        except (json.JSONDecodeError, IOError, OSError):
+            # Return empty store if file is corrupted
+            self._cached_store = {"lastModified": datetime.now().isoformat(), "todos": []}
+            return self._cached_store
+
+    def _save_store(self, store: Dict[str, Any]) -> None:
+        """Save todos to file atomically."""
+        # Ensure the ~/.skydeckai-code directory exists
+        self.todos_file_path.parent.mkdir(exist_ok=True)
+
+        workspace_key = str(self.workspace_path)
+
+        # Load existing global data
+        global_data = {}
+        if self.todos_file_path.exists():
+            try:
+                with open(self.todos_file_path, "r", encoding="utf-8") as f:
+                    global_data = json.load(f)
+            except (json.JSONDecodeError, IOError, OSError):
+                global_data = {}
+
+        # Update the workspace data
+        global_data[workspace_key] = store
+
+        # Write to temporary file first (atomic write)
+        temp_path = self.todos_file_path.with_suffix(".json.tmp")
+
+        try:
+            with open(temp_path, "w", encoding="utf-8") as f:
+                json.dump(global_data, f, indent=2, ensure_ascii=False)
+
+            # Atomic rename
+            temp_path.replace(self.todos_file_path)
+
+            # Update cache
+            self._cached_store = store
+
+        except Exception:
+            # Clean up temp file if something went wrong
+            if temp_path.exists():
+                temp_path.unlink()
+            raise
+
+    def _add_to_gitignore(self) -> None:
+        """No longer needed since todos are stored in ~/.skydeckai-code/todo.json"""
+        pass
+
+    def read_todos(self) -> List[Dict[str, Any]]:
+        """Read all todos from storage."""
+        store = self._load_store()
+        return store["todos"]
+
+    def write_todos(self, todos: List[Dict[str, Any]]) -> int:
+        """Write todos to storage with validation."""
+        # Validate todos
+        self._validate_todos(todos)
+
+        # Process todos (add timestamps, etc.)
+        processed_todos = []
+        current_time = datetime.now().isoformat()
+
+        for todo in todos:
+            processed_todo = dict(todo)
+
+            # Ensure required fields have defaults
+            processed_todo.setdefault("id", self._generate_id())
+            processed_todo.setdefault("status", "pending")
+            processed_todo.setdefault("created_at", current_time)
+            processed_todo["updated_at"] = current_time
+
+            processed_todos.append(processed_todo)
+
+        # Create new store
+        new_store = {"lastModified": current_time, "todos": processed_todos}
+
+        # Save to file
+        self._save_store(new_store)
+
+        return len(processed_todos)
+
+    def update_todo(self, todo_id: str, updates: Dict[str, Any]) -> Dict[str, Any]:
+        """Update a specific todo by ID."""
+        store = self._load_store()
+        todos = store["todos"]
+
+        # Find the todo to update
+        todo_index = None
+        original_todo = None
+        for i, todo in enumerate(todos):
+            if todo["id"] == todo_id:
+                todo_index = i
+                original_todo = todo
+                break
+
+        if todo_index is None or original_todo is None:
+            raise ValueError(f"Todo with ID '{todo_id}' not found")
+
+        # Check if status is changing to completed
+        original_status = original_todo["status"]
+        new_status = updates.get("status", original_status)
+        is_completing = original_status != "completed" and new_status == "completed"
+
+        # Create updated todo
+        updated_todo = dict(todos[todo_index])
+        updated_todo.update(updates)
+        updated_todo["updated_at"] = datetime.now().isoformat()
+
+        # Replace the todo in the list
+        updated_todos = todos.copy()
+        updated_todos[todo_index] = updated_todo
+
+        # Validate the entire list with the update
+        self._validate_todos(updated_todos)
+
+        # Save updated list
+        new_store = {"lastModified": datetime.now().isoformat(), "todos": updated_todos}
+        self._save_store(new_store)
+
+        # Return status counts
+        pending_count = sum(1 for t in updated_todos if t["status"] == "pending")
+        in_progress_count = sum(1 for t in updated_todos if t["status"] == "in_progress")
+        completed_count = sum(1 for t in updated_todos if t["status"] == "completed")
+
+        result = {"updated_todo": updated_todo, "counts": {"pending": pending_count, "in_progress": in_progress_count, "completed": completed_count, "total": len(updated_todos)}}
+
+        # If a todo was just completed, find and include the next pending todo
+        if is_completing:
+            next_todo = self._find_next_pending_todo(updated_todos, todo_index)
+            if next_todo:
+                result["next_todo"] = next_todo
+            else:
+                result["next_todo"] = None
+                result["message"] = "All todos completed! No more pending tasks."
+
+        return result
+
+    def _find_next_pending_todo(self, todos: List[Dict[str, Any]], completed_index: int) -> Dict[str, Any] | None:
+        """Find the next pending todo after the completed one in sequential order."""
+        # Look for the next pending todo starting from the position after the completed one
+        for i in range(completed_index + 1, len(todos)):
+            if todos[i]["status"] == "pending":
+                return todos[i]
+        
+        # If no pending todo found after the completed one, look from the beginning
+        # This handles cases where todos might be reordered or the completed one wasn't the first in-progress
+        for i in range(completed_index):
+            if todos[i]["status"] == "pending":
+                return todos[i]
+        
+        # No pending todos found
+        return None
+
+    def _validate_todos(self, todos: List[Dict[str, Any]]) -> None:
+        """Validate todos according to business rules."""
+        if not isinstance(todos, list):
+            raise ValueError("Todos must be a list")
+
+        # Check for required fields and collect IDs
+        required_fields = {"id", "content", "status"}
+        seen_ids = set()
+        in_progress_count = 0
+
+        for i, todo in enumerate(todos):
+            if not isinstance(todo, dict):
+                raise ValueError(f"Todo at index {i} must be a dictionary")
+
+            # Check required fields
+            missing_fields = required_fields - set(todo.keys())
+            if missing_fields:
+                raise ValueError(f"Todo at index {i} missing required fields: {missing_fields}")
+
+            # Validate ID uniqueness
+            todo_id = todo["id"]
+            if not isinstance(todo_id, str) or not todo_id.strip():
+                raise ValueError(f"Todo at index {i} must have a non-empty string ID")
+
+            if todo_id in seen_ids:
+                raise ValueError(f"Duplicate todo ID found: {todo_id}")
+            seen_ids.add(todo_id)
+
+            # Validate status
+            if todo["status"] not in ["pending", "in_progress", "completed"]:
+                raise ValueError(f"Todo at index {i} has invalid status: {todo['status']}")
+
+            if todo["status"] == "in_progress":
+                in_progress_count += 1
+
+
+            # Validate content
+            if not isinstance(todo["content"], str) or not todo["content"].strip():
+                raise ValueError(f"Todo at index {i} must have non-empty content")
+
+        # Business rule: only one task can be in progress
+        if in_progress_count > 1:
+            raise ValueError("Only one task can be in_progress at a time")
+
+    def _generate_id(self) -> str:
+        """Generate a unique ID for a todo."""
+        import uuid
+
+        return str(uuid.uuid4())[:8]
+
+
+# Global todo store instance
+todo_store = TodoStore()

skydeckai_code-0.1.41/src/aidd/tools/todo_tools.py

@@ -0,0 +1,157 @@
+import json
+from .todo_store import todo_store
+from mcp.types import TextContent
+
+
+def todo_read_tool():
+    """Define the todo_read tool."""
+    return {
+        "name": "todo_read",
+        "description": "Read the current task list from the workspace-specific todo storage. "
+        "MANDATORY: This tool MUST be called FIRST before ANY workspace operations including file reads, code analysis, development tasks, project creation, or directory manipulation. "
+        "WORKSPACE-FIRST RULE: Every LLM interaction with workspaces, directories, projects, or repositories requires todo management. "
+        "WHEN TO USE: Always when starting workspace operations - check task status, review pending/completed work, understand project context, pick up previous progress. "
+        "Essential for: Project initialization, code development, file operations, debugging, testing, deployment, refactoring. "
+        "WHEN NOT TO USE: Pure informational queries unrelated to workspace development. "
+        "RETURNS: Sequential task list with status and metadata. Tasks execute in order - no priority system. "
+        "Each workspace maintains isolated todo lists for project organization. "
+        "CRITICAL: Bypassing this tool for workspace operations violates mandatory protocol. "
+        "EXAMPLES: \n- Creating new projects: Read todos to check existing project structure tasks\n- Code development: Check current development phase and next sequential steps\n- File modifications: Understand task context before making changes\n- Project analysis: Review completed analysis and next investigation steps",
+        "inputSchema": {
+            "type": "object",
+            "properties": {},
+            "required": [],
+        },
+    }
+
+
+def todo_write_tool():
+    """Define the todo_write tool."""
+    return {
+        "name": "todo_write",
+        "description": "Update the entire task list (complete replacement) for the current workspace. "
+        "MANDATORY: This tool MUST be called when planning, adding, or reorganizing tasks during ANY workspace operations. "
+        "WORKSPACE-FIRST RULE: All workspace development requires structured task management through sequential execution. "
+        "WHEN TO USE: Task planning for new projects, adding development phases, reorganizing workflow, batch status updates. "
+        "Sequential execution model: Tasks are completed in order, building upon previous work. No priority system - order determines execution. "
+        "Essential for: Project planning, development workflows, feature implementation, debugging sequences, deployment phases. "
+        "WHEN NOT TO USE: Single task updates (use todo_update), pure reading (use todo_read). "
+        "RETURNS: Success status and task count. Enforces sequential execution (only one in-progress task). "
+        "CRITICAL: Sequential task management is mandatory for all workspace development activities. "
+        "EXAMPLES: \n- New project setup: Create sequential tasks for initialization, structure, dependencies\n- Feature development: Plan design, implementation, testing, documentation phases\n- Bug fixing: Create investigation, fix, test, validation sequence\n- Code refactoring: Plan analysis, changes, testing, cleanup steps",
+        "inputSchema": {
+            "type": "object",
+            "properties": {
+                "todos": {
+                    "type": "array",
+                    "description": "Complete list of todo items to replace the current list for sequential execution. Each todo must contain id, content, and status fields. Tasks execute in array order.",
+                    "items": {
+                        "type": "object",
+                        "properties": {
+                            "id": {"type": "string", "description": "Unique identifier for the task. Must be unique across all todos."},
+                            "content": {"type": "string", "description": "Task description or content. Cannot be empty."},
+                            "status": {"type": "string", "enum": ["pending", "in_progress", "completed"], "description": "Current status of the task. Only one task can be 'in_progress' at a time."},
+                            "metadata": {"type": "object", "description": "Optional additional data for the task.", "additionalProperties": True},
+                        },
+                        "required": ["id", "content", "status"],
+                        "additionalProperties": True,
+                    },
+                }
+            },
+            "required": ["todos"],
+        },
+    }
+
+
+def todo_update_tool():
+    """Define the todo_update tool."""
+    return {
+        "name": "todo_update",
+        "description": "Update a specific todo item by ID for sequential workflow management. "
+        "MANDATORY: This tool MUST be called when progressing through tasks during workspace operations. "
+        "WORKSPACE-FIRST RULE: Task progress updates are required for all workspace development activities. "
+        "WHEN TO USE: Mark tasks in-progress when starting, completed when finished, update content for clarification. "
+        "Sequential workflow: Progress through tasks in order, maintaining single active task constraint. "
+        "Essential for: Task status transitions, progress tracking, workflow advancement, content updates. "
+        "WHEN NOT TO USE: Multiple task updates (use todo_write), adding new tasks (use todo_write). "
+        "RETURNS: Updated todo with status counts showing workflow progress. "
+        "Enforces sequential execution - only one task can be in-progress at any time. "
+        "CRITICAL: Sequential progress tracking is mandatory for workspace development workflows. "
+        "EXAMPLES: \n- Starting work: Update task from 'pending' to 'in_progress'\n- Completing work: Update task from 'in_progress' to 'completed'\n- Task refinement: Update content for better clarity\n- Workflow progression: Move to next sequential task",
+        "inputSchema": {
+            "type": "object",
+            "properties": {
+                "todo_id": {"type": "string", "description": "The unique ID of the todo to update."},
+                "updates": {
+                    "type": "object",
+                    "description": "Fields to update in the todo for sequential workflow. Can include content, status, or metadata.",
+                    "properties": {
+                        "content": {"type": "string", "description": "New task description or content."},
+                        "status": {"type": "string", "enum": ["pending", "in_progress", "completed"], "description": "New status of the task."},
+                        "metadata": {"type": "object", "description": "Additional data for the task.", "additionalProperties": True},
+                    },
+                    "additionalProperties": True,
+                },
+            },
+            "required": ["todo_id", "updates"],
+        },
+    }
+
+
+async def handle_todo_read(arguments: dict) -> list[TextContent]:
+    """Handle reading todos from storage."""
+    try:
+        todos = todo_store.read_todos()
+
+        result = {"todos": todos, "count": len(todos), "workspace": str(todo_store.workspace_path)}
+
+        return [TextContent(type="text", text=json.dumps(result, indent=2))]
+
+    except Exception as e:
+        error_result = {"error": {"code": "READ_ERROR", "message": f"Failed to read todos: {str(e)}"}}
+        return [TextContent(type="text", text=json.dumps(error_result, indent=2))]
+
+
+async def handle_todo_write(arguments: dict) -> list[TextContent]:
+    """Handle writing todos to storage."""
+    try:
+        todos = arguments.get("todos", [])
+
+        if not isinstance(todos, list):
+            raise ValueError("Todos must be provided as a list")
+
+        count = todo_store.write_todos(todos)
+
+        result = {"success": True, "count": count, "workspace": str(todo_store.workspace_path)}
+
+        return [TextContent(type="text", text=json.dumps(result, indent=2))]
+
+    except Exception as e:
+        error_result = {"error": {"code": "VALIDATION_ERROR" if "validation" in str(e).lower() or "invalid" in str(e).lower() or "duplicate" in str(e).lower() else "WRITE_ERROR", "message": str(e)}}
+        return [TextContent(type="text", text=json.dumps(error_result, indent=2))]
+
+
+async def handle_todo_update(arguments: dict) -> list[TextContent]:
+    """Handle updating a specific todo."""
+    try:
+        todo_id = arguments.get("todo_id")
+        updates = arguments.get("updates", {})
+
+        if not todo_id:
+            raise ValueError("todo_id is required")
+
+        if not isinstance(updates, dict):
+            raise ValueError("Updates must be provided as a dictionary")
+
+        if not updates:
+            raise ValueError("Updates cannot be empty")
+
+        result = todo_store.update_todo(todo_id, updates)
+        result["success"] = True
+        result["workspace"] = str(todo_store.workspace_path)
+
+        return [TextContent(type="text", text=json.dumps(result, indent=2))]
+
+    except Exception as e:
+        error_result = {"error": {"code": "VALIDATION_ERROR" if "validation" in str(e).lower() or "invalid" in str(e).lower() or "not found" in str(e).lower() else "UPDATE_ERROR", "message": str(e)}}
+        return [TextContent(type="text", text=json.dumps(error_result, indent=2))]