Update dependencies and enhance patch file functionality with improved search-replace block parsing and error handling.

wallneradam · wallneradam · commit df1cc8ced163 · 2025-04-24T00:07:20.000+02:00
diff --git a/pyproject.toml b/pyproject.toml
@@ -7,7 +7,7 @@ readme = "README.md"
 requires-python = ">=3.11"
 license = { text = "MIT" }
 
-dependencies = ["fastmcp>=2.2.0, <3.0.0", "patch-ng>=1.18.0, <2.0.0"]
+dependencies = ["fastmcp>=2.2.0, <3.0.0"]
 
 [project.scripts]
 patch-file-mcp = "patch_file_mcp.server:main"
diff --git a/src/patch_file_mcp/server.py b/src/patch_file_mcp/server.py
@@ -2,19 +2,43 @@
 import sys
 import argparse
 from pathlib import Path
+import re
 
 from fastmcp import FastMCP
 from pydantic.fields import Field
-import patch_ng
 
 
 mcp = FastMCP(
     name="Patch File MCP",
     instructions=f"""
-This MCP is for patching existing files.
-This can be used to patch files in projects, if project is specified, and the full path to the project
-is provided. This should be used most of the time instead of `edit_block` tool from `desktop-commander`.
-It can be used to patch multiple parts of the same file.
+This MCP is for patching existing files using block format.
+
+Use the block format with SEARCH/REPLACE markers:
+```
+<<<<<<< SEARCH
+Text to find in the file
+=======
+Text to replace it with
+>>>>>>> REPLACE
+```
+
+You can include multiple search-replace blocks in a single request:
+```
+<<<<<<< SEARCH
+First text to find
+=======
+First replacement
+>>>>>>> REPLACE
+<<<<<<< SEARCH
+Second text to find
+=======
+Second replacement
+>>>>>>> REPLACE
+```
+
+This tool verifies that each search text appears exactly once in the file to ensure
+the correct section is modified. If a search text appears multiple times or isn't
+found, it will report an error.
 """
 )
 
@@ -28,7 +52,7 @@ def eprint(*args, **kwargs):
 def main():
     # Process command line arguments
     global allowed_directories
-    parser = argparse.ArgumentParser(description="Project Memory MCP server")
+    parser = argparse.ArgumentParser(description="Patch File MCP server")
     parser.add_argument(
         '--allowed-dir',
         action='append',
@@ -56,61 +80,150 @@ def main():
 # Tools
 #
 
+def parse_search_replace_blocks(patch_content):
+    """
+    Parse multiple search-replace blocks from the patch content.
+    Returns a list of tuples (search_text, replace_text).
+    """
+    # Define the markers
+    search_marker = "<<<<<<< SEARCH"
+    separator = "======="
+    replace_marker = ">>>>>>> REPLACE"
+
+    # Use regex to extract all blocks
+    pattern = f"{search_marker}\\n(.*?)\\n{separator}\\n(.*?)\\n{replace_marker}"
+    matches = re.findall(pattern, patch_content, re.DOTALL)
+
+    if not matches:
+        # Try alternative parsing if regex fails
+        blocks = []
+        lines = patch_content.splitlines()
+        i = 0
+        while i < len(lines):
+            if lines[i] == search_marker:
+                search_start = i + 1
+                separator_idx = -1
+                replace_end = -1
+
+                # Find the separator
+                for j in range(search_start, len(lines)):
+                    if lines[j] == separator:
+                        separator_idx = j
+                        break
+
+                if separator_idx == -1:
+                    raise ValueError("Invalid format: missing separator")
+
+                # Find the replace marker
+                for j in range(separator_idx + 1, len(lines)):
+                    if lines[j] == replace_marker:
+                        replace_end = j
+                        break
+
+                if replace_end == -1:
+                    raise ValueError("Invalid format: missing replace marker")
+
+                search_text = "\n".join(lines[search_start:separator_idx])
+                replace_text = "\n".join(lines[separator_idx + 1:replace_end])
+                blocks.append((search_text, replace_text))
+
+                i = replace_end + 1
+            else:
+                i += 1
+
+        if blocks:
+            return blocks
+        else:
+            raise ValueError("Invalid patch format. Expected block format with SEARCH/REPLACE markers.")
+
+    return matches
+
+
 @mcp.tool()
 def patch_file(
     file_path: str = Field(description="The path to the file to patch"),
-    patch_content: str = Field(description="Unified diff/patch to apply to the file.")
+    patch_content: str = Field(
+        description="Content to search and replace in the file using block format with SEARCH/REPLACE markers. Multiple blocks are supported.")
 ):
     """
-    Update the file by applying a unified diff/patch to it.
-    The patch must be in unified diff format and will be applied to the current file content.
+    Update the file by applying a patch/edit to it using block format.
+
+    Required format:
+    ```
+    <<<<<<< SEARCH
+    Text to find in the file
+    =======
+    Text to replace it with
+    >>>>>>> REPLACE
+    ```
+
+    You can include multiple search-replace blocks in a single request:
+    ```
+    <<<<<<< SEARCH
+    First text to find
+    =======
+    First replacement
+    >>>>>>> REPLACE
+    <<<<<<< SEARCH
+    Second text to find
+    =======
+    Second replacement
+    >>>>>>> REPLACE
+    ```
+
+    This tool verifies that each search text appears exactly once in the file to ensure
+    the correct section is modified. If a search text appears multiple times or isn't
+    found, it will report an error.
     """
     pp = Path(file_path).resolve()
     if not pp.exists() or not pp.is_file():
         raise FileNotFoundError(f"File {file_path} does not exist")
     if not any(str(pp).startswith(base) for base in allowed_directories):
         raise PermissionError(f"File {file_path} is not in allowed directories")
 
-    # Extract just the hunk part (starting with @@)
-    lines = patch_content.splitlines()
-    hunk_start = -1
-    
-    for i, line in enumerate(lines):
-        if line.startswith("@@"):
-            hunk_start = i
-            break
-    
-    if hunk_start == -1:
-        raise RuntimeError(
-            "No @@ line markers found in the patch content.\n"
-            "Make sure the patch follows the unified diff format with @@ line markers."
-        )
-    
-    # Use only the hunk part (remove any headers)
-    hunk_content = "\n".join(lines[hunk_start:])
-    
-    # Create a standardized patch with the correct filename
-    filename = pp.name
-    standardized_patch = f"--- {filename}\n+++ {filename}\n{hunk_content}"
-    eprint(f"Created standardized patch for {filename}")
-
-    # Ensure patch_content is properly encoded
-    encoded_content = standardized_patch.encode("utf-8")
-    patchset = patch_ng.fromstring(encoded_content)
-    if not patchset:
-        raise RuntimeError(
-            "Failed to parse patch string. You can use `write_file` tool to write the "
-            "whole file content instead.\n"
-            "Make sure the patch follows the unified diff format with @@ line markers."
-        )
-    
-    # Use the parent directory as root and the filename for patching
-    parent_dir = str(pp.parent)
-    success = patchset.apply(root=parent_dir)
-    
-    if not success:
-        raise RuntimeError(
-            "Failed to apply patch to file. Use `write_file` tool to write the "
-            "whole file content instead.\n"
-            "Check that the patch lines match the target file content."
-        )
+    # Read the current file content
+    with open(pp, 'r', encoding='utf-8') as f:
+        original_content = f.read()
+
+    try:
+        # Parse multiple search-replace blocks
+        blocks = parse_search_replace_blocks(patch_content)
+        if not blocks:
+            raise ValueError("No valid search-replace blocks found in the patch content")
+
+        eprint(f"Found {len(blocks)} search-replace blocks")
+
+        # Apply each block sequentially
+        current_content = original_content
+        applied_blocks = 0
+
+        for i, (search_text, replace_text) in enumerate(blocks):
+            eprint(f"Processing block {i+1}/{len(blocks)}")
+
+            # Check exact match count
+            count = current_content.count(search_text)
+
+            if count == 1:
+                # Exactly one match - perfect!
+                eprint(f"Block {i+1}: Found exactly one exact match")
+                current_content = current_content.replace(search_text, replace_text)
+                applied_blocks += 1
+
+            elif count > 1:
+                # Multiple matches - too ambiguous
+                raise ValueError(f"Block {i+1}: The search text appears {count} times in the file. "
+                                 "Please provide more context to identify the specific occurrence.")
+
+            else:
+                # No match found
+                raise ValueError(f"Block {i+1}: Could not find the search text in the file. "
+                                 "Please ensure the search text exactly matches the content in the file.")
+
+        # Write the final content back to the file
+        with open(pp, 'w', encoding='utf-8') as f:
+            f.write(current_content)
+
+        return f"Successfully applied {applied_blocks} patch blocks to {file_path}"
+
+    except Exception as e:
+        raise RuntimeError(f"Failed to apply patch: {str(e)}")
diff --git a/src/patch_file_mcp/server.py.old b/src/patch_file_mcp/server.py.old
