feat: add create_text_file and append_text_file_contents tools

- Add create_text_file tool for new file creation
- Add append_text_file_contents tool for appending content
- Add comprehensive test cases for both tools
- Update test_server.py to accommodate new tools

Author: Yoshihiro Takahara

src/mcp_text_editor/server.py

@@ -308,6 +308,103 @@ async def run_tool(self, arguments: Dict[str, Any]) -> Sequence[TextContent]:
                 ],
                 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
+
+
+class AppendTextFileContentsHandler:
+    """Handler for appending content to an existing text file."""
+
+    name = "append_text_file_contents"
+    description = "Append content to an existing text file. The file must exist."
+
+    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": {
+                    "path": {
+                        "type": "string",
+                        "description": "Path to the text file. File path must be absolute.",
+                    },
+                    "contents": {
+                        "type": "string",
+                        "description": "Content to append to the file",
+                    },
+                    "file_hash": {
+                        "type": "string",
+                        "description": "Hash of the file contents for concurrency control",
+                    },
+                    "encoding": {
+                        "type": "string",
+                        "description": "Text encoding (default: 'utf-8')",
+                        "default": "utf-8",
+                    },
+                },
+                "required": ["path", "contents", "file_hash"],
+            },
+        )
+
+    async def run_tool(self, arguments: Dict[str, Any]) -> Sequence[TextContent]:
+        """Execute the tool with given arguments."""
+        try:
+            if "path" not in arguments:
+                raise RuntimeError("Missing required argument: path")
+            if "contents" not in arguments:
+                raise RuntimeError("Missing required argument: contents")
+            if "file_hash" not in arguments:
+                raise RuntimeError("Missing required argument: file_hash")
+
+            file_path = arguments["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")
+            
+            # Check file contents and hash before modification
+            # Get file information and verify hash
+            content, _, _, current_hash, total_lines, _ = await self.editor.read_file_contents(
+                file_path,
+                encoding=encoding
+            )
+
+            # Verify file hash
+            if current_hash != arguments["file_hash"]:
+                raise RuntimeError("File hash mismatch - file may have been modified")
+
+            # Ensure the append content ends with newline
+            append_content = arguments["contents"]
+            if not append_content.endswith("\n"):
+                append_content += "\n"
+
+            # Create patch for append operation
+            result = await self.editor.edit_file_contents(
+                file_path,
+                expected_hash=arguments["file_hash"],
+                patches=[
+                    {
+                        "start": total_lines + 1,
+                        "end": None,
+                        "contents": append_content,
+                        "range_hash": "",
+                    }
+                ],
+                encoding=encoding,
+            )
 
             return [TextContent(type="text", text=json.dumps(result, indent=2))]
 
@@ -322,7 +419,7 @@ async def run_tool(self, arguments: Dict[str, Any]) -> Sequence[TextContent]:
 get_contents_handler = GetTextFileContentsHandler()
 edit_contents_handler = EditTextFileContentsHandler()
 create_file_handler = CreateTextFileHandler()
-
+append_file_handler = AppendTextFileContentsHandler()
 
 @app.list_tools()
 async def list_tools() -> List[Tool]:
@@ -331,6 +428,7 @@ async def list_tools() -> List[Tool]:
         get_contents_handler.get_tool_description(),
         edit_contents_handler.get_tool_description(),
         create_file_handler.get_tool_description(),
+        append_file_handler.get_tool_description(),
     ]
 
 
@@ -345,6 +443,8 @@ async def call_tool(name: str, arguments: Any) -> Sequence[TextContent]:
             return await edit_contents_handler.run_tool(arguments)
         elif name == create_file_handler.name:
             return await create_file_handler.run_tool(arguments)
+        elif name == append_file_handler.name:
+            return await append_file_handler.run_tool(arguments)
         else:
             raise ValueError(f"Unknown tool: {name}")
     except ValueError:

tests/test_append_text_file.py

@@ -0,0 +1,169 @@
+"""Test cases for append_text_file_contents handler."""
+
+import os
+from typing import Any, Dict
+
+import pytest
+
+from mcp_text_editor.server import AppendTextFileContentsHandler
+from mcp_text_editor.text_editor import TextEditor
+
+# Initialize handler for tests
+append_handler = AppendTextFileContentsHandler()
+
+
+@pytest.fixture
+def test_dir(tmp_path: str) -> str:
+    """Create a temporary directory for test files."""
+    return str(tmp_path)
+
+
+@pytest.fixture
+def cleanup_files() -> None:
+    """Clean up any test files after each test."""
+    yield
+    # Add cleanup code if needed
+
+
+@pytest.mark.asyncio
+async def test_append_text_file_success(test_dir: str, cleanup_files: None) -> None:
+    """Test successful appending to a file."""
+    test_file = os.path.join(test_dir, "append_test.txt")
+    initial_content = "Initial content\n"
+    append_content = "Appended content\n"
+
+    # Create initial file
+    with open(test_file, "w", encoding="utf-8") as f:
+        f.write(initial_content)
+
+    # Get file hash for append operation
+    editor = TextEditor()
+    _, _, _, file_hash, _, _ = await editor.read_file_contents(test_file)
+
+    # Append content using handler
+    arguments: Dict[str, Any] = {
+        "path": test_file,
+        "contents": append_content,
+        "file_hash": file_hash,
+    }
+    response = await append_handler.run_tool(arguments)
+
+    # Check if content was appended correctly
+    with open(test_file, "r", encoding="utf-8") as f:
+        content = f.read()
+        assert content == initial_content + append_content
+
+    # Parse response to check success
+    assert len(response) == 1
+    result = response[0].text
+    assert "\"result\": \"ok\"" in result
+
+
+@pytest.mark.asyncio
+async def test_append_text_file_not_exists(test_dir: str, cleanup_files: None) -> None:
+    """Test attempting to append to a non-existent file."""
+    test_file = os.path.join(test_dir, "nonexistent.txt")
+
+    # Try to append to non-existent file
+    arguments: Dict[str, Any] = {
+        "path": test_file,
+        "contents": "Some content\n",
+        "file_hash": "dummy_hash",
+    }
+
+    # Should raise error because file doesn't exist
+    with pytest.raises(RuntimeError) as exc_info:
+        await append_handler.run_tool(arguments)
+    assert "File does not exist" in str(exc_info.value)
+
+
+@pytest.mark.asyncio
+async def test_append_text_file_hash_mismatch(test_dir: str, cleanup_files: None) -> None:
+    """Test appending with incorrect file hash."""
+    test_file = os.path.join(test_dir, "hash_test.txt")
+    initial_content = "Initial content\n"
+
+    # Create initial file
+    with open(test_file, "w", encoding="utf-8") as f:
+        f.write(initial_content)
+
+    # Try to append with incorrect hash
+    arguments: Dict[str, Any] = {
+        "path": test_file,
+        "contents": "New content\n",
+        "file_hash": "incorrect_hash",
+    }
+
+    # Should raise error because hash doesn't match
+    with pytest.raises(RuntimeError) as exc_info:
+        await append_handler.run_tool(arguments)
+    assert "hash mismatch" in str(exc_info.value).lower()
+
+
+@pytest.mark.asyncio
+async def test_append_text_file_relative_path(test_dir: str, cleanup_files: None) -> None:
+    """Test attempting to append using a relative path."""
+    arguments: Dict[str, Any] = {
+        "path": "relative_path.txt",
+        "contents": "Some content\n",
+        "file_hash": "dummy_hash",
+    }
+
+    # Should raise error because path is not absolute
+    with pytest.raises(RuntimeError) as exc_info:
+        await append_handler.run_tool(arguments)
+    assert "File path must be absolute" in str(exc_info.value)
+
+
+@pytest.mark.asyncio
+async def test_append_text_file_missing_args() -> None:
+    """Test appending with missing arguments."""
+    # Test missing path
+    with pytest.raises(RuntimeError) as exc_info:
+        await append_handler.run_tool({"contents": "content\n", "file_hash": "hash"})
+    assert "Missing required argument: path" in str(exc_info.value)
+
+    # Test missing contents
+    with pytest.raises(RuntimeError) as exc_info:
+        await append_handler.run_tool({"path": "/absolute/path.txt", "file_hash": "hash"})
+    assert "Missing required argument: contents" in str(exc_info.value)
+
+    # Test missing file_hash
+    with pytest.raises(RuntimeError) as exc_info:
+        await append_handler.run_tool({"path": "/absolute/path.txt", "contents": "content\n"})
+    assert "Missing required argument: file_hash" in str(exc_info.value)
+
+
+@pytest.mark.asyncio
+async def test_append_text_file_custom_encoding(test_dir: str, cleanup_files: None) -> None:
+    """Test appending with custom encoding."""
+    test_file = os.path.join(test_dir, "encode_test.txt")
+    initial_content = "こんにちは\n"
+    append_content = "さようなら\n"
+
+    # Create initial file
+    with open(test_file, "w", encoding="utf-8") as f:
+        f.write(initial_content)
+
+    # Get file hash for append operation
+    editor = TextEditor()
+    _, _, _, file_hash, _, _ = await editor.read_file_contents(test_file, encoding="utf-8")
+
+    # Append content using handler with specified encoding
+    arguments: Dict[str, Any] = {
+        "path": test_file,
+        "contents": append_content,
+        "file_hash": file_hash,
+        "encoding": "utf-8",
+    }
+    response = await append_handler.run_tool(arguments)
+
+    # Check if content was appended correctly
+    with open(test_file, "r", encoding="utf-8") as f:
+        content = f.read()
+        assert content == initial_content + append_content
+
+    # Parse response to check success
+    assert len(response) == 1
+    result = response[0].text
+    assert "\"result\": \"ok\"" in result

tests/test_server.py

@@ -25,7 +25,7 @@
 async def test_list_tools():
     """Test tool listing."""
     tools: List[Tool] = await list_tools()
-    assert len(tools) == 3
+    assert len(tools) == 4
 
     # Verify GetTextFileContents tool
     get_contents_tool = next(