skydeckai-code 0.1.39__py3-none-any.whl → 0.1.41__py3-none-any.whl

{skydeckai_code-0.1.39.dist-info → skydeckai_code-0.1.41.dist-info}/METADATA

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: skydeckai-code
-Version: 0.1.39
-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
@@ -43,13 +43,13 @@ An MCP server that provides a comprehensive set of tools for AI-driven developme
 
 This mcp server was formerly known as `mcp-server-aidd`. It was renamed to `skydeckai-code` to credit the team at [SkyDeck.ai](https://skydeck.ai) with creating this application along with [East Agile](https://eastagile.com). But more importantly we realized that the term AI Driven Development (AIDD) was just not catching on. People did not understand at a glance what it was about. And nor did LLMs. "Code" was far more intuitive. And linguistically intuitive is important in the world of agentic AI.
 
-<a href="https://glama.ai/mcp/servers/mpixtij6se"><img width="380" height="200" src="https://glama.ai/mcp/servers/mpixtij6se/badge" alt="AiDD Server MCP server" /></a>
+[![Verified on MseeP](https://mseep.ai/badge.svg)](https://mseep.ai/app/fe7a40fd-30c1-4767-84f9-d33bf997497e)
 
 ## Installation
 
 ```bash
-# Using pip
-pip install skydeckai-code
+# Using uvx
+uvx skydeckai-code
 ```
 
 ## Claude Desktop Setup
@@ -69,9 +69,9 @@ Add to your `claude_desktop_config.json`:
 
 ## SkyDeck AI Helper App
 
-If you're using SkyDeck AI Helper app, you can search for "SkyDeckAI Code" and install it.
+If you're using MseeP AI Helper app, you can search for "SkyDeckAI Code" and install it.
 
-![SkyDeck AI Helper App](/screenshots/skydeck_ai_helper.png)
+![MseeP AI Helper App](/screenshots/mseep_ai_helper.png)
 
 ## Key Features
 
@@ -87,7 +87,7 @@ If you're using SkyDeck AI Helper app, you can search for "SkyDeckAI Code" and i
 -   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 SkyDeck AI Helper app, you can search for "SkyDeckAI Code" and i
 | **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
 
@@ -131,34 +134,6 @@ If you're using SkyDeck AI Helper app, you can search for "SkyDeckAI Code" and i
 | delete_file   | path: string                                               | Success confirmation                          |
 | get_file_info | path: string                                               | File metadata (size, timestamps, permissions) |
 
-**CLI Usage:**
-
-```bash
-# Read entire file
-skydeckai-code-cli --tool read_file --args '{"files": [{"path": "src/main.py"}]}'
-
-# Read 10 lines starting from line 20
-skydeckai-code-cli --tool read_file --args '{"files": [{"path": "src/main.py", "offset": 20, "limit": 10}]}'
-
-# Read from line 50 to the end of the file
-skydeckai-code-cli --tool read_file --args '{"files": [{"path": "src/main.py", "offset": 50}]}'
-
-# Read multiple files with different line ranges
-skydeckai-code-cli --tool read_file --args '{"files": [
-  {"path": "src/main.py", "offset": 1, "limit": 10},
-  {"path": "README.md"}
-]}'
-
-# Write file
-skydeckai-code-cli --tool write_file --args '{"path": "output.txt", "content": "Hello World"}'
-
-# Copy file or directory
-skydeckai-code-cli --tool copy_file --args '{"source": "config.json", "destination": "config.backup.json"}'
-
-# Get file info
-skydeckai-code-cli --tool get_file_info --args '{"path": "src/main.py"}'
-```
-
 ### Complex File Operations
 
 #### edit_file
@@ -208,16 +183,6 @@ Generates complete directory structure:
 
 Returns: JSON tree structure of directory contents.
 
-**CLI Usage:**
-
-```bash
-# List directory
-skydeckai-code-cli --tool list_directory --args '{"path": "."}'
-
-# Search for Python files
-skydeckai-code-cli --tool search_files --args '{"pattern": ".py", "path": "src"}'
-```
-
 ### Code Analysis
 
 #### codebase_mapper
@@ -252,19 +217,6 @@ Supported Languages:
 -   C# (.cs)
 -   Kotlin (.kt, .kts)
 
-**CLI Usage:**
-
-```bash
-# Map the entire codebase structure
-skydeckai-code-cli --tool codebase_mapper --args '{"path": "."}'
-
-# Map only the source directory
-skydeckai-code-cli --tool codebase_mapper --args '{"path": "src"}'
-
-# Map a specific component or module
-skydeckai-code-cli --tool codebase_mapper --args '{"path": "src/components"}'
-```
-
 #### search_code
 
 Fast content search tool using regular expressions:
@@ -295,29 +247,6 @@ Matching lines grouped by file with line numbers, sorted by file modification ti
 
 This tool uses ripgrep when available for optimal performance, with a Python fallback implementation. It's ideal for finding specific code patterns like function declarations, imports, variable usages, or error handling.
 
-**CLI Usage:**
-
-```bash
-# Find function and class declarations in JavaScript files
-skydeckai-code-cli --tool search_code --args '{
-    "patterns": ["function\\s+\\w+", "class\\s+\\w+"],
-    "include": "*.js"
-}'
-
-# Find all console.log statements with errors or warnings
-skydeckai-code-cli --tool search_code --args '{
-    "patterns": ["console\\.log.*[eE]rror", "console\\.log.*[wW]arning"],
-    "path": "src"
-}'
-
-# Find import and export statements in TypeScript files
-skydeckai-code-cli --tool search_code --args '{
-    "patterns": ["import.*from", "export.*"],
-    "include": "*.{ts,tsx}",
-    "exclude": "node_modules/**"
-}'
-```
-
 ### System Information
 
 | Tool            | Parameters | Returns                      |
@@ -348,13 +277,6 @@ Returns:
 
 Provides essential system information in a clean, readable format.
 
-**CLI Usage:**
-
-```bash
-# Get system information
-skydeckai-code-cli --tool get_system_info
-```
-
 ### Screen Context and Image Tools
 
 #### get_active_apps
@@ -518,28 +440,6 @@ Response content as text with HTTP status code and size information. For binary
 
 This tool can be used to access web APIs, fetch documentation, or download content from the web while respecting size limits (10MB max) and security constraints.
 
-**CLI Usage:**
-
-```bash
-# Fetch JSON from an API
-skydeckai-code-cli --tool web_fetch --args '{
-    "url": "https://api.github.com/users/octocat",
-    "headers": {"Accept": "application/json"}
-}'
-
-# Download content to a file
-skydeckai-code-cli --tool web_fetch --args '{
-    "url": "https://github.com/github/github-mcp-server/blob/main/README.md",
-    "save_to_file": "downloads/readme.md"
-}'
-
-# Fetch a webpage and convert to markdown for better readability
-skydeckai-code-cli --tool web_fetch --args '{
-    "url": "https://example.com",
-    "convert_html_to_markdown": true
-}'
-```
-
 #### web_search
 
 Performs a robust web search using multiple search engines and returns concise, relevant results.
@@ -566,27 +466,6 @@ A list of search results formatted in markdown, including titles, URLs, and snip
 
 This tool uses a multi-engine approach that tries different search engines with various parsing strategies to ensure reliable results. You can specify a preferred engine, but some engines may block automated access, in which case the tool will fall back to alternative engines when "auto" is selected.
 
-**CLI Usage:**
-
-```bash
-# Search with default settings (auto engine selection)
-skydeckai-code-cli --tool web_search --args '{
-    "query": "latest python release features"
-}'
-
-# Try DuckDuckGo if you want alternative results
-skydeckai-code-cli --tool web_search --args '{
-    "query": "machine learning frameworks comparison",
-    "search_engine": "duckduckgo"
-}'
-
-# Use Bing for reliable results
-skydeckai-code-cli --tool web_search --args '{
-    "query": "best programming practices 2023",
-    "search_engine": "bing"
-}'
-```
-
 ### Utility Tools
 
 #### batch_tools
@@ -640,47 +519,6 @@ This tool provides efficient execution of multiple operations in a single reques
 1. Use paths relative to the current working directory (e.g., "project/src" rather than just "src"), or
 2. Include an explicit tool invocation to change directories using `update_allowed_directory`
 
-**CLI Usage:**
-
-```bash
-# Setup a new project with multiple steps in sequential order (using proper paths)
-skydeckai-code-cli --tool batch_tools --args '{
-    "description": "Setup new project",
-    "sequential": true,
-    "invocations": [
-        {"tool": "create_directory", "arguments": {"path": "project"}},
-        {"tool": "create_directory", "arguments": {"path": "project/src"}},
-        {"tool": "write_file", "arguments": {"path": "project/README.md", "content": "# Project\n\nA new project."}}
-    ]
-}'
-
-# Create nested structure using relative paths (without changing directory)
-skydeckai-code-cli --tool batch_tools --args '{
-    "description": "Create project structure",
-    "sequential": true,
-    "invocations": [
-        {"tool": "create_directory", "arguments": {"path": "project/src"}},
-        {"tool": "create_directory", "arguments": {"path": "project/docs"}},
-        {"tool": "write_file", "arguments": {"path": "project/README.md", "content": "# Project"}}
-    ]
-}'
-
-# Gather system information and take a screenshot (tasks can run in parallel)
-skydeckai-code-cli --tool batch_tools --args '{
-    "description": "System diagnostics",
-    "sequential": false,
-    "invocations": [
-        {"tool": "get_system_info", "arguments": {}},
-        {"tool": "capture_screenshot", "arguments": {
-            "output_path": "diagnostics/screen.png",
-            "capture_mode": {
-                "type": "full"
-            }
-        }}
-    ]
-}'
-```
-
 #### think
 
 A tool for complex reasoning and brainstorming without making changes to the repository.
@@ -701,20 +539,6 @@ Your thoughts formatted as markdown, with a note indicating this was a thinking
 
 This tool is useful for thinking through complex problems, brainstorming solutions, or laying out implementation plans without making any actual changes. It's a great way to document your reasoning process, evaluate different approaches, or plan out a multi-step strategy before taking action.
 
-**CLI Usage:**
-
-```bash
-# Analyze a bug and plan a fix
-skydeckai-code-cli --tool think --args '{
-    "thought": "# Bug Analysis\n\n## Observed Behavior\nThe login endpoint returns a 500 error when email contains Unicode characters.\n\n## Root Cause\nThe database adapter is not properly encoding Unicode strings before constructing the SQL query.\n\n## Potential Fixes\n1. Update the database adapter to use parameterized queries\n2. Add input validation to reject Unicode in emails\n3. Encode email input manually before database operations\n\nFix #1 is the best approach as it solves the core issue and improves security."
-}'
-
-# Evaluate design alternatives
-skydeckai-code-cli --tool think --args '{
-    "thought": "# API Design Options\n\n## REST vs GraphQL\nFor this use case, GraphQL would provide more flexible data fetching but adds complexity. REST is simpler and sufficient for our current needs.\n\n## Authentication Methods\nJWT-based authentication offers stateless operation and better scalability compared to session-based auth.\n\nRecommendation: Use REST with JWT authentication for the initial implementation."
-}'
-```
-
 ### Code Execution
 
 #### execute_code
@@ -745,34 +569,6 @@ Executes code in various programming languages with safety measures and restrict
 | code | string | Yes | Code to execute |
 | timeout | integer | No | Maximum execution time (default: 5s) |
 
-**CLI Usage:**
-
-```bash
-# Python example
-skydeckai-code-cli --tool execute_code --args '{
-    "language": "python",
-    "code": "print(sum(range(10)))"
-}'
-
-# JavaScript example
-skydeckai-code-cli --tool execute_code --args '{
-    "language": "javascript",
-    "code": "console.log(Array.from({length: 5}, (_, i) => i*2))"
-}'
-
-# Ruby example
-skydeckai-code-cli --tool execute_code --args '{
-    "language": "ruby",
-    "code": "puts (1..5).reduce(:+)"
-}'
-
-# Go example
-skydeckai-code-cli --tool execute_code --args '{
-    "language": "go",
-    "code": "fmt.Println(\"Hello, Go!\")"
-}'
-```
-
 **Requirements:**
 
 -   Respective language runtimes must be installed
@@ -805,25 +601,6 @@ Executes shell scripts (bash/sh) with safety measures and restrictions.
 | script | string | Yes | Shell script to execute |
 | timeout | integer | No | Maximum execution time (default: 300s, max: 600s) |
 
-**CLI Usage:**
-
-```bash
-# List directory contents with details
-skydeckai-code-cli --tool execute_shell_script --args '{
-    "script": "ls -la"
-}'
-
-# Find all Python files recursively
-skydeckai-code-cli --tool execute_shell_script --args '{
-    "script": "find . -name \"*.py\" -type f"
-}'
-
-# Complex script with multiple commands
-skydeckai-code-cli --tool execute_shell_script --args '{
-    "script": "echo \"System Info:\" && uname -a && echo \"\nDisk Usage:\" && df -h"
-}'
-```
-
 **Features:**
 
 -   Uses /bin/sh for maximum compatibility across systems
@@ -840,28 +617,119 @@ This tool executes arbitrary shell commands on your system. Always:
 4. Be aware of potential system impacts
 5. Monitor execution output
 
-## Configuration
+### Todo Tools
 
-Configuration file: `~/.skydeckai_code/config.json`
+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
 {
-    "allowed_directory": "/path/to/workspace"
+  "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"
 }
 ```
 
-## CLI Usage
+#### todo_write
 
-Basic command structure:
+Replace the entire todo list for sequential execution workflow. Tasks are executed in array order, building upon previous work.
 
-```bash
-skydeckai-code-cli --tool <tool_name> --args '<json_arguments>'
+```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
 
-# List available tools
-skydeckai-code-cli --list-tools
+Update a specific todo item by ID for sequential workflow progression.
 
-# Enable debug output
-skydeckai-code-cli --debug --tool <tool_name> --args '<json_arguments>'
+```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`
+
+```json
+{
+    "allowed_directory": "/path/to/workspace"
+}
 ```
 
 ## Debugging

{skydeckai_code-0.1.39.dist-info → skydeckai_code-0.1.41.dist-info}/RECORD

@@ -2,13 +2,13 @@ src/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 src/aidd/__init__.py,sha256=c9HBWxWruCxoAqLCJqltylAwz_7xmaK3g8DKViJZs0Q,222
 src/aidd/cli.py,sha256=cLtaQJmMBfr7fHkd0dyJqpDrVTIwybL48PotniWGrFM,5031
 src/aidd/server.py,sha256=kPRyWeWkMCZjabelC65XTmzZG7yw8htMJKSfnUcKnb0,1575
-src/aidd/tools/__init__.py,sha256=j1uL7WVH3xS8JTGnpSIhaz7qkc3gcxuDyvZIYP9UztI,3731
+src/aidd/tools/__init__.py,sha256=LzDxyOEf_Shp_4W3_DAwTpBP9W4CFW6dfyqvU8mOnMM,4108
 src/aidd/tools/base.py,sha256=wHSAaGGYWM8ECmoYd7KEcmjsZRWesNQFf3zMjCKGMcc,380
 src/aidd/tools/code_analysis.py,sha256=fDpm2o_If5PsngXzHN2-ezSkPVT0ZxivLuzmHrOAmVU,33188
 src/aidd/tools/code_execution.py,sha256=7HKstQ-LTjGEUn87LhowOJbd4Pq_zG0xkO-K0JJ-EFs,15513
 src/aidd/tools/code_tools.py,sha256=rJx_CMq0mB7aBJ6YcNB_6geFnjHU4OaGcXyuu909xhM,16010
 src/aidd/tools/directory_tools.py,sha256=GMG4-9iO5RfTkbhlWaW40GPKa1qujMPTN32pwxjUU4E,18052
-src/aidd/tools/file_tools.py,sha256=GYzP6WxGbV1V42FlWNSuGIyiCtRp09kwF6lOZrFtq_U,43112
+src/aidd/tools/file_tools.py,sha256=8Z38Tva8Qe0Fd2d6vU-DW-weHyExfUrIiRsxqrBlw6A,46720
 src/aidd/tools/get_active_apps_tool.py,sha256=BjLF7iXSDgyAmm_gfFgAul2Gn3iX-CNVYHM7Sh4jTAI,19427
 src/aidd/tools/get_available_windows_tool.py,sha256=OVIYhItTn9u_DftOr3vPCT-R0DOFvMEEJXA6tD6gqWQ,15952
 src/aidd/tools/image_tools.py,sha256=wT3EcJAfZWcM0IsXdDfbTNjgFhKZM9nu2wHN6Mk_TTQ,5970
@@ -17,9 +17,11 @@ src/aidd/tools/path_tools.py,sha256=RGoOhqP69eHJzM8tEgn_5-GRaR0gp25fd0XZIJ_RnQE,
 src/aidd/tools/screenshot_tool.py,sha256=NMO5B4UG8qfMEOMRd2YoOjtwz_oQ2y1UAGU22jV1yGU,46337
 src/aidd/tools/state.py,sha256=RWSw0Jfsui8FqC0xsI7Ik07tAg35hRwLHa5xGBVbiI4,1493
 src/aidd/tools/system_tools.py,sha256=XgdIgKeqePZx5pj59zH7Jhs2Abn55XUf0tvKbKMVtPo,7400
+src/aidd/tools/todo_store.py,sha256=cE2yASBm03Ns8c0UL5pm95tdE25FX7QowjDJ_z-Qhog,9624
+src/aidd/tools/todo_tools.py,sha256=ownbYPBB41GeRNxo2S3YGUwKUe2PeiI5ypy7kzWQlrs,9325
 src/aidd/tools/web_tools.py,sha256=gdsj2DEVYb_oYChItK5I1ugt2w25U7IAa5kEw9q6MVg,35534
-skydeckai_code-0.1.39.dist-info/METADATA,sha256=AwWLNrB3UMqXpsqiWYw6-ZSN8h6LRiZr_2PNt0yqfd4,31952
-skydeckai_code-0.1.39.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-skydeckai_code-0.1.39.dist-info/entry_points.txt,sha256=ZkU1spOhLEnz5MpUn4dDihVcE0DMUC6ejzbsF-eNth4,88
-skydeckai_code-0.1.39.dist-info/licenses/LICENSE,sha256=uHse04vmI6ZjW7TblegFl30X-sDyyF0-QvH8ItPca3c,10865
-skydeckai_code-0.1.39.dist-info/RECORD,,
+skydeckai_code-0.1.41.dist-info/METADATA,sha256=oRQ0r_BB6oTzL3-jInu3h_2XvWMKiLnrZyqOanJlgz4,27242
+skydeckai_code-0.1.41.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+skydeckai_code-0.1.41.dist-info/entry_points.txt,sha256=ZkU1spOhLEnz5MpUn4dDihVcE0DMUC6ejzbsF-eNth4,88
+skydeckai_code-0.1.41.dist-info/licenses/LICENSE,sha256=uHse04vmI6ZjW7TblegFl30X-sDyyF0-QvH8ItPca3c,10865
+skydeckai_code-0.1.41.dist-info/RECORD,,

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,
 }

src/aidd/tools/file_tools.py

@@ -232,11 +232,15 @@ def edit_file_tool():
         "description": "Make line-based edits to a text file. "
             "WHEN TO USE: When you need to make selective changes to specific parts of a file while preserving the rest of the content. "
             "Useful for modifying configuration values, updating text while maintaining file structure, or making targeted code changes. "
+            "IMPORTANT: For multiple edits to the same file, use a single tool call with multiple edits in the 'edits' array rather than multiple tool calls. "
+            "This is more efficient and ensures all edits are applied atomically. "
             "WHEN NOT TO USE: When you want to completely replace a file's contents (use write_file instead), when you need to create a new file (use write_file instead), "
             "or when you want to apply highly complex edits with context. "
             "RETURNS: A git-style diff showing the changes made, along with information about any failed matches. "
             "The response includes sections for failed matches (if any) and the unified diff output. "
-            "Always use dryRun first to preview changes before applying them. Only works within the allowed directory.",
+            "Only works within the allowed directory. "
+            "EXAMPLES: For a single edit: {\"path\": \"config.js\", \"edits\": [{\"oldText\": \"port: 3000\", \"newText\": \"port: 8080\"}]}. "
+            "For multiple edits: {\"path\": \"app.py\", \"edits\": [{\"oldText\": \"debug=False\", \"newText\": \"debug=True\"}, {\"oldText\": \"version='1.0'\", \"newText\": \"version='2.0'\"}]}",
         "inputSchema": {
             "type": "object",
             "properties": {
@@ -260,20 +264,26 @@ def edit_file_tool():
                         },
                         "required": ["oldText", "newText"]
                     },
-                    "description": "List of edit operations to perform on the file. Each edit specifies text to find (oldText) and text to replace it with (newText). The edits are applied in sequence, and each one can modify the result of previous edits."
-                },
-                "dryRun": {
-                    "type": "boolean",
-                    "description": "Preview changes without applying them to the file. Set to true to see what changes would be made without actually modifying the file. Highly recommended before making actual changes.",
-                    "default": False
+                    "description": "MUST be an array of edit objects, NOT a string. Each edit object must contain 'oldText' and 'newText' properties. "
+                                   "For multiple edits, use: [{\"oldText\": \"text1\", \"newText\": \"replacement1\"}, {\"oldText\": \"text2\", \"newText\": \"replacement2\"}]. "
+                                   "For single edit, still use array: [{\"oldText\": \"text\", \"newText\": \"replacement\"}]. "
+                                   "The edits are applied in sequence, and each one can modify the result of previous edits. "
+                                   "AVOID multiple tool calls for the same file - instead, group all edits into a single call."
                 },
                 "options": {
                     "type": "object",
                     "properties": {
                         "partialMatch": {
                             "type": "boolean",
-                            "description": "Enable fuzzy matching for finding text. When true, the tool will try to find the best match even if it's not an exact match, using a confidence threshold of 80%.",
+                            "description": "Enable fuzzy matching for finding text. When true, the tool will try to find the best match even if it's not an exact match, using the confidenceThreshold (default 80%).",
                             "default": True
+                        },
+                        "confidenceThreshold": {
+                            "type": "number",
+                            "description": "Minimum confidence threshold for fuzzy matching (0.0 to 1.0). Higher values require more exact matches. Default is 0.8 (80% confidence).",
+                            "minimum": 0.0,
+                            "maximum": 1.0,
+                            "default": 0.8
                         }
                     }
                 }
@@ -784,11 +794,17 @@ def find_best_match(content: str, pattern: str, partial_match: bool = True) -> t
 
     return best_start, best_end, best_score
 
-async def apply_file_edits(file_path: str, edits: List[dict], dry_run: bool = False, options: dict = None) -> str:
-    """Apply edits to a file with optional formatting and return diff."""
+async def apply_file_edits(file_path: str, edits: List[dict], options: dict = None) -> tuple[str, bool, int, int]:
+    """Apply edits to a file with optional formatting and return diff.
+    
+    Returns:
+        tuple: (result_text, has_changes, successful_edits, failed_edits)
+    """
     # Set default options
     options = options or {}
     partial_match = options.get('partialMatch', True)
+    # Use 0.8 confidence threshold to prevent false positives while allowing reasonable fuzzy matches
+    confidence_threshold = options.get('confidenceThreshold', 0.8)
 
     # Read file content
     with open(file_path, 'r', encoding='utf-8') as f:
@@ -797,9 +813,10 @@ async def apply_file_edits(file_path: str, edits: List[dict], dry_run: bool = Fa
     # Track modifications
     modified_content = content
     failed_matches = []
+    successful_edits = []
 
     # Apply each edit
-    for edit in edits:
+    for edit_idx, edit in enumerate(edits):
         old_text = edit['oldText']
         new_text = edit['newText']
 
@@ -810,7 +827,7 @@ async def apply_file_edits(file_path: str, edits: List[dict], dry_run: bool = Fa
         # Find best match
         start, end, confidence = find_best_match(working_content, search_text, partial_match)
 
-        if confidence >= 0.8:
+        if confidence >= confidence_threshold:
             # Fix indentation while preserving relative structure
             if start >= 0:
                 # Get the indentation of the first line of the matched text
@@ -851,31 +868,77 @@ async def apply_file_edits(file_path: str, edits: List[dict], dry_run: bool = Fa
 
             # Apply the edit
             modified_content = modified_content[:start] + replacement + modified_content[end:]
+            successful_edits.append({
+                'index': edit_idx,
+                'oldText': old_text,
+                'newText': new_text,
+                'confidence': confidence
+            })
         else:
             failed_matches.append({
+                'index': edit_idx,
                 'oldText': old_text,
+                'newText': new_text,
                 'confidence': confidence,
                 'bestMatch': working_content[start:end] if start >= 0 and end > start else None
             })
 
     # Create diff
     diff = create_unified_diff(content, modified_content, os.path.basename(file_path))
+    has_changes = modified_content != content
 
-    # Write changes if not dry run
-    if not dry_run and not failed_matches:
+    # CRITICAL FIX: Write changes even if some edits failed (partial success)
+    # This prevents the infinite retry loop
+    if has_changes:
         with open(file_path, 'w', encoding='utf-8') as f:
             f.write(modified_content)
 
-    # Return results
-    failed_matches_text = '=== Failed Matches ===\n' + json.dumps(failed_matches, indent=2) + '\n\n' if failed_matches else ''
-    diff_text = f'=== Diff ===\n{diff}'
-    return failed_matches_text + diff_text
+    # Build comprehensive result message
+    result_parts = []
+    
+    # Summary
+    total_edits = len(edits)
+    successful_count = len(successful_edits)
+    failed_count = len(failed_matches)
+    
+    result_parts.append(f'=== Edit Summary ===')
+    result_parts.append(f'Total edits: {total_edits}')
+    result_parts.append(f'Successful: {successful_count}')
+    result_parts.append(f'Failed: {failed_count}')
+    result_parts.append(f'File modified: {has_changes}')
+    result_parts.append('')
+    
+    # Failed matches details
+    if failed_matches:
+        result_parts.append('=== Failed Matches ===')
+        for failed in failed_matches:
+            result_parts.append(f"Edit #{failed['index'] + 1}: Confidence {failed['confidence']:.2f}")
+            result_parts.append(f"  Searched for: {repr(failed['oldText'][:100])}...")
+            if failed['bestMatch']:
+                result_parts.append(f"  Best match: {repr(failed['bestMatch'][:100])}...")
+            result_parts.append('')
+    
+    # Successful edits
+    if successful_edits:
+        result_parts.append('=== Successful Edits ===')
+        for success in successful_edits:
+            result_parts.append(f"Edit #{success['index'] + 1}: Confidence {success['confidence']:.2f}")
+        result_parts.append('')
+    
+    # Diff
+    if diff.strip():
+        result_parts.append('=== Diff ===')
+        result_parts.append(diff)
+    else:
+        result_parts.append('=== No Changes ===')
+        result_parts.append('No modifications were made to the file.')
+    
+    return '\n'.join(result_parts), has_changes, successful_count, failed_count
 
 async def handle_edit_file(arguments: dict):
     """Handle editing a file with pattern matching and formatting."""
     path = arguments.get("path")
     edits = arguments.get("edits")
-    dry_run = arguments.get("dryRun", False)
     options = arguments.get("options", {})
 
     if not path:
@@ -900,8 +963,14 @@ async def handle_edit_file(arguments: dict):
         raise ValueError(f"Access denied: Path ({full_path}) must be within allowed directory ({state.allowed_directory})")
 
     try:
-        result = await apply_file_edits(full_path, edits, dry_run, options)
-        return [TextContent(type="text", text=result)]
+        result_text, has_changes, successful_count, failed_count = await apply_file_edits(full_path, edits, options)
+        
+        # CRITICAL FIX: Raise an exception only if ALL edits failed AND no changes were made
+        # This prevents silent failures that cause infinite retry loops
+        if failed_count > 0 and successful_count == 0:
+            raise ValueError(f"All {failed_count} edits failed to match. No changes were made to the file. Check the 'oldText' patterns and ensure they match the file content exactly.")
+        
+        return [TextContent(type="text", text=result_text)]
     except Exception as e:
         raise ValueError(f"Error editing file: {str(e)}")
 

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()

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))]