feat: Add delete text file operation

- Add DeleteTextFileContentsRequest model
- Implement delete_text_file_contents functionality
- Add comprehensive test suite
- Add server handler for delete operation

Author: Yoshihiro Takahara

src/mcp_text_editor/models.py

@@ -166,3 +166,34 @@ def validate_line_number(cls, v) -> Optional[int]:
         if v is not None and v < 1:
             raise ValueError("Line numbers must be positive")
         return v
+
+
+class DeleteTextFileContentsRequest(BaseModel):
+    """Request model for deleting text from a file.
+
+    Example:
+    {
+        "path": "/path/to/file",
+        "file_hash": "abc123...",
+        "ranges": [
+            {
+                "start": 5,
+                "end": 10,
+                "range_hash": "def456..."
+            }
+        ]
+    }
+    """
+
+    path: str = Field(..., description="Path to the text file")
+    file_hash: str = Field(..., description="Hash of original contents")
+    ranges: List[FileRange] = Field(..., description="List of ranges to delete")
+
+    @field_validator("range_hash")
+    def validate_range_hash(cls, v: str) -> str:
+        """Validate that range_hash is not empty."""
+        if not v:
+            raise ValueError("range_hash cannot be empty")
+        return v
+
+    range_hash: str = Field(..., description="Hash of the content to be deleted")

src/mcp_text_editor/server.py

@@ -416,11 +416,117 @@ async def run_tool(self, arguments: Dict[str, Any]) -> Sequence[TextContent]:
             raise RuntimeError(f"Error processing request: {str(e)}") from e
 
 
+class DeleteTextFileContentsHandler:
+    """Handler for deleting content from a text file."""
+
+    name = "delete_text_file_contents"
+    description = "Delete specified content ranges from a text file. The file must exist. File paths must be absolute."
+
+    def __init__(self):
+        self.editor = TextEditor()
+
+    def get_tool_description(self) -> Tool:
+        """Get the tool description."""
+        return Tool(
+            name=self.name,
+            description=self.description,
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "file_path": {
+                        "type": "string",
+                        "description": "Path to the text file. File path must be absolute.",
+                    },
+                    "file_hash": {
+                        "type": "string",
+                        "description": "Hash of the file contents for concurrency control",
+                    },
+                    "ranges": {
+                        "type": "array",
+                        "description": "List of line ranges to delete",
+                        "items": {
+                            "type": "object",
+                            "properties": {
+                                "start": {
+                                    "type": "integer",
+                                    "description": "Starting line number (1-based)",
+                                },
+                                "end": {
+                                    "type": ["integer", "null"],
+                                    "description": "Ending line number (null for end of file)",
+                                },
+                                "range_hash": {
+                                    "type": "string",
+                                    "description": "Hash of the content being deleted",
+                                },
+                            },
+                            "required": ["start", "range_hash"],
+                        },
+                    },
+                    "encoding": {
+                        "type": "string",
+                        "description": "Text encoding (default: 'utf-8')",
+                        "default": "utf-8",
+                    },
+                },
+                "required": ["file_path", "file_hash", "ranges"],
+            },
+        )
+
+    async def run_tool(self, arguments: Dict[str, Any]) -> Sequence[TextContent]:
+        """Execute the tool with given arguments."""
+        try:
+            # Input validation
+            if "file_path" not in arguments:
+                raise RuntimeError("Missing required argument: file_path")
+            if "file_hash" not in arguments:
+                raise RuntimeError("Missing required argument: file_hash")
+            if "ranges" not in arguments:
+                raise RuntimeError("Missing required argument: ranges")
+
+            file_path = arguments["file_path"]
+            if not os.path.isabs(file_path):
+                raise RuntimeError(f"File path must be absolute: {file_path}")
+
+            # Check if file exists
+            if not os.path.exists(file_path):
+                raise RuntimeError(f"File does not exist: {file_path}")
+
+            encoding = arguments.get("encoding", "utf-8")
+
+            # Create patches for deletion (replacing content with empty string)
+            patches = [
+                {
+                    "start": r["start"],
+                    "end": r["end"],
+                    "contents": "",
+                    "range_hash": r["range_hash"],
+                }
+                for r in arguments["ranges"]
+            ]
+
+            # Use the existing edit_file_contents method
+            result = await self.editor.edit_file_contents(
+                file_path,
+                expected_hash=arguments["file_hash"],
+                patches=patches,
+                encoding=encoding,
+            )
+
+            return [TextContent(type="text", text=json.dumps(result, indent=2))]
+
+        except Exception as e:
+            logger.error(f"Error processing request: {str(e)}")
+            logger.error(traceback.format_exc())
+            raise RuntimeError(f"Error processing request: {str(e)}") from e
+
+
 # Initialize tool handlers
 get_contents_handler = GetTextFileContentsHandler()
 edit_contents_handler = EditTextFileContentsHandler()
 create_file_handler = CreateTextFileHandler()
 append_file_handler = AppendTextFileContentsHandler()
+delete_contents_handler = DeleteTextFileContentsHandler()
 
 
 @app.list_tools()
@@ -431,6 +537,7 @@ async def list_tools() -> List[Tool]:
         edit_contents_handler.get_tool_description(),
         create_file_handler.get_tool_description(),
         append_file_handler.get_tool_description(),
+        delete_contents_handler.get_tool_description(),
     ]
 
 
@@ -447,6 +554,8 @@ async def call_tool(name: str, arguments: Any) -> Sequence[TextContent]:
             return await create_file_handler.run_tool(arguments)
         elif name == append_file_handler.name:
             return await append_file_handler.run_tool(arguments)
+        elif name == delete_contents_handler.name:
+            return await delete_contents_handler.run_tool(arguments)
         else:
             raise ValueError(f"Unknown tool: {name}")
     except ValueError:

src/mcp_text_editor/text_editor.py

@@ -536,3 +536,104 @@ async def insert_text_file_contents(
                 "reason": str(e),
                 "hash": None,
             }
+
+    async def delete_text_file_contents(
+        self,
+        file_path: str,
+        file_hash: str,
+        range_hash: str,
+        start_line: int,
+        end_line: int,
+        encoding: str = "utf-8",
+    ) -> Dict[str, Any]:
+        """Delete lines from a text file.
+
+        Args:
+            file_path (str): Path to the text file
+            file_hash (str): Expected hash of the file before editing
+            range_hash (str): Expected hash of the range to be deleted
+            start_line (int): Starting line number (1-based)
+            end_line (int): Ending line number (inclusive)
+            encoding (str, optional): File encoding. Defaults to "utf-8".
+
+        Returns:
+            Dict[str, Any]: Results containing:
+                - result: "ok" or "error"
+                - hash: New file hash if successful
+                - reason: Error message if result is "error"
+        """
+        try:
+            # Read current content and verify hash
+            content, _, _, current_hash, total_lines, _ = await self.read_file_contents(
+                file_path=file_path,
+                encoding=encoding,
+            )
+
+            if current_hash != file_hash:
+                return {
+                    "result": "error",
+                    "reason": "File hash mismatch - Please use get_text_file_contents tool to get current content and hash",
+                    "file_hash": None,
+                }
+
+            # Validate line range
+            if end_line < start_line:
+                return {
+                    "result": "error",
+                    "reason": "End line must be greater than or equal to start line",
+                    "file_hash": None,
+                }
+
+            if start_line > total_lines or end_line > total_lines:
+                return {
+                    "result": "error",
+                    "reason": "Line number out of range",
+                    "file_hash": None,
+                }
+
+            # Verify range hash
+            range_content = await self.read_file_contents(
+                file_path=file_path,
+                start=start_line,
+                end=end_line,
+                encoding=encoding,
+            )
+            if self.calculate_hash(range_content[0]) != range_hash:
+                return {
+                    "result": "error",
+                    "reason": "Range hash mismatch - Please use get_text_file_contents tool to get current content and hashes",
+                    "file_hash": None,
+                }
+
+            # Split into lines, preserving line endings
+            lines = content.splitlines(keepends=True)
+
+            # Delete lines (convert to zero-based index)
+            del lines[start_line - 1 : end_line]
+
+            # Write the updated content back to file
+            final_content = "".join(lines)
+            with open(file_path, "w", encoding=encoding) as f:
+                f.write(final_content)
+
+            # Calculate new hash
+            new_hash = self.calculate_hash(final_content)
+
+            return {
+                "result": "ok",
+                "file_hash": new_hash,
+                "reason": None,
+            }
+
+        except FileNotFoundError:
+            return {
+                "result": "error",
+                "reason": f"File not found: {file_path}",
+                "file_hash": None,
+            }
+        except Exception as e:
+            return {
+                "result": "error",
+                "reason": str(e),
+                "file_hash": None,
+            }