feat: add create_text_file tool

Add new tool for creating new text files with validation:
- Check if file already exists
- Validate absolute path
- Support custom encoding
- Add comprehensive test cases

Author: Yoshihiro Takahara

src/mcp_text_editor/server.py

@@ -241,10 +241,87 @@ async def run_tool(self, arguments: Dict[str, Any]) -> Sequence[TextContent]:
             logger.error(traceback.format_exc())
             raise RuntimeError(f"Error processing request: {str(e)}") from e
 
+class CreateTextFileHandler:
+    """Handler for creating a new text file."""
+
+    name = "create_text_file"
+    description = "Create a new text file with given content. The file must not exist already."
+
+    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 write to the file",
+                    },
+                    "encoding": {
+                        "type": "string",
+                        "description": "Text encoding (default: 'utf-8')",
+                        "default": "utf-8",
+                    },
+                },
+                "required": ["path", "contents"],
+            },
+        )
+
+    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")
+
+            file_path = arguments["path"]
+            if not os.path.isabs(file_path):
+                raise RuntimeError(f"File path must be absolute: {file_path}")
+
+            # Check if file already exists
+            if os.path.exists(file_path):
+                raise RuntimeError(f"File already exists: {file_path}")
+
+            encoding = arguments.get("encoding", "utf-8")
+            
+            # Create new file using edit_file_contents with empty expected_hash
+            result = await self.editor.edit_file_contents(
+                file_path,
+                expected_hash="",  # Empty hash for new file
+                patches=[
+                    {
+                        "start": 1,
+                        "end": None,
+                        "contents": arguments["contents"],
+                        "range_hash": "",  # Empty range_hash for new file
+                    }
+                ],
+                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()
 
 
 @app.list_tools()
@@ -253,6 +330,7 @@ async def list_tools() -> List[Tool]:
     return [
         get_contents_handler.get_tool_description(),
         edit_contents_handler.get_tool_description(),
+        create_file_handler.get_tool_description(),
     ]
 
 
@@ -265,6 +343,8 @@ async def call_tool(name: str, arguments: Any) -> Sequence[TextContent]:
             return await get_contents_handler.run_tool(arguments)
         elif name == edit_contents_handler.name:
             return await edit_contents_handler.run_tool(arguments)
+        elif name == create_file_handler.name:
+            return await create_file_handler.run_tool(arguments)
         else:
             raise ValueError(f"Unknown tool: {name}")
     except ValueError:

tests/test_create_text_file.py

@@ -0,0 +1,123 @@
+"""Test cases for create_text_file handler."""
+
+import os
+from typing import Any, Dict
+
+import pytest
+
+from mcp_text_editor.server import CreateTextFileHandler
+from mcp_text_editor.text_editor import TextEditor
+
+# Initialize handlers for tests
+create_file_handler = CreateTextFileHandler()
+
+
+@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_create_text_file_success(test_dir: str, cleanup_files: None) -> None:
+    """Test successful creation of a new text file."""
+    test_file = os.path.join(test_dir, "new_file.txt")
+    content = "Hello, World!\n"
+
+    # Create file using handler
+    arguments: Dict[str, Any] = {
+        "path": test_file,
+        "contents": content,
+    }
+    response = await create_file_handler.run_tool(arguments)
+
+    # Check if file was created with correct content
+    assert os.path.exists(test_file)
+    with open(test_file, "r", encoding="utf-8") as f:
+        assert f.read() == 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_create_text_file_exists(test_dir: str, cleanup_files: None) -> None:
+    """Test attempting to create a file that already exists."""
+    test_file = os.path.join(test_dir, "existing_file.txt")
+
+    # Create file first
+    with open(test_file, "w", encoding="utf-8") as f:
+        f.write("Existing content\n")
+
+    # Try to create file using handler
+    arguments: Dict[str, Any] = {
+        "path": test_file,
+        "contents": "New content\n",
+    }
+
+    # Should raise error because file exists
+    with pytest.raises(RuntimeError):
+        await create_file_handler.run_tool(arguments)
+
+
+@pytest.mark.asyncio
+async def test_create_text_file_relative_path(test_dir: str, cleanup_files: None) -> None:
+    """Test attempting to create a file with a relative path."""
+    # Try to create file using relative path
+    arguments: Dict[str, Any] = {
+        "path": "relative_path.txt",
+        "contents": "Some content\n",
+    }
+
+    # Should raise error because path is not absolute
+    with pytest.raises(RuntimeError) as exc_info:
+        await create_file_handler.run_tool(arguments)
+    assert "File path must be absolute" in str(exc_info.value)
+
+
+@pytest.mark.asyncio
+async def test_create_text_file_missing_args() -> None:
+    """Test creating a file with missing arguments."""
+    # Test missing path
+    with pytest.raises(RuntimeError) as exc_info:
+        await create_file_handler.run_tool({"contents": "content\n"})
+    assert "Missing required argument: path" in str(exc_info.value)
+
+    # Test missing contents
+    with pytest.raises(RuntimeError) as exc_info:
+        await create_file_handler.run_tool({"path": "/absolute/path.txt"})
+    assert "Missing required argument: contents" in str(exc_info.value)
+
+
+@pytest.mark.asyncio
+async def test_create_text_file_custom_encoding(test_dir: str, cleanup_files: None) -> None:
+    """Test creating a file with custom encoding."""
+    test_file = os.path.join(test_dir, "encoded_file.txt")
+    content = "こんにちは\n"  # Japanese text
+
+    # Create file using handler with specified encoding
+    arguments: Dict[str, Any] = {
+        "path": test_file,
+        "contents": content,
+        "encoding": "utf-8",
+    }
+    response = await create_file_handler.run_tool(arguments)
+
+    # Check if file was created with correct content
+    assert os.path.exists(test_file)
+    with open(test_file, "r", encoding="utf-8") as f:
+        assert f.read() == 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) == 2
+    assert len(tools) == 3
 
     # Verify GetTextFileContents tool
     get_contents_tool = next(