Improvements to file editing. Commonly confused characters fix. Throw only outer errors (#83)

Author: rusiaaman

pyproject.toml

@@ -1,7 +1,7 @@
 [project]
 authors = [{ name = "Aman Rusia", email = "[email protected]" }]
 name = "wcgw"
-version = "5.5.1"
+version = "5.5.2"
 description = "Shell and coding agent for Claude and other mcp clients"
 readme = "README.md"
 requires-python = ">=3.11"

src/wcgw/client/file_ops/diff_edit.py

@@ -11,8 +11,14 @@ def __init__(self, message: str):
         message = f"""
 {message}
 ---
-Edit failed, no changes are applied. You'll have to reapply all search/replace blocks again.
-Retry immediately with same "percentage_to_change" using search replace blocks fixing above error.
+Last edit failed, no changes are applied. None of the search/replace blocks applied in the last tool call.
+Recommendations:
+- Retry immediately with same "percentage_to_change" using search replace blocks fixing above error.
+- If you are still unsure you may re-read the file and then proceed accordingly.
+
+If your search failed due to updates in the file content, remember that these
+are the changes that the user made and you should preserve them
+by updating your replace blocks too.
 """
         super().__init__(message)
 
@@ -88,7 +94,7 @@ def replace_or_throw(
         if score > 1000:
             display = (list(warnings) + list(info))[:max_errors]
             raise SearchReplaceMatchError(
-                "Too many warnings generated, not apply the edits\n"
+                "Too many warnings generated, not applying the edits\n"
                 + "\n".join(display)
             )
 
@@ -123,7 +129,44 @@ def line_process_max_space_tolerance(line: str) -> str:
     return re.sub(r"\s", "", line)
 
 
-REMOVE_INDENTATION = "Warning: matching after removing all spaces in lines."
+REMOVE_INDENTATION = (
+    "Warning: matching without considering indentation (leading spaces)."
+)
+REMOVE_LINE_NUMS = "Warning: you gave search/replace blocks with leading line numbers, do not give them from the next time."
+
+COMMON_MISTAKE_TRANSLATION = str.maketrans(
+    {
+        "‘": "'",
+        "’": "'",
+        "‚": ",",
+        "‛": "'",
+        "′": "'",
+        "“": '"',
+        "”": '"',
+        "‟": '"',
+        "″": '"',
+        "‹": "<",
+        "›": ">",
+        "‐": "-",
+        "‑": "-",
+        "‒": "-",
+        "–": "-",
+        "—": "-",
+        "―": "-",
+        "−": "-",
+        "…": "...",
+    }
+)
+
+
+def remove_leading_linenums(string: str) -> str:
+    return re.sub(r"^\d+ ", "", string).rstrip()
+
+
+def normalize_common_mistakes(string: str) -> str:
+    """Normalize unicode chars which are commonly confused by their ascii variants"""
+    return string.translate(COMMON_MISTAKE_TRANSLATION).rstrip()
+
 
 DEFAULT_TOLERANCES = [
     Tolerance(
@@ -136,17 +179,35 @@ def line_process_max_space_tolerance(line: str) -> str:
         line_process=str.lstrip,
         severity_cat="WARNING",
         score_multiplier=10,
-        error_name="Warning: matching without considering indentation (leading spaces).",
+        error_name=REMOVE_INDENTATION,
+    ),
+    Tolerance(
+        line_process=remove_leading_linenums,
+        severity_cat="WARNING",
+        score_multiplier=5,
+        error_name=REMOVE_LINE_NUMS,
+    ),
+    Tolerance(
+        line_process=normalize_common_mistakes,
+        severity_cat="WARNING",
+        score_multiplier=5,
+        error_name="Warning: matching after normalizing commonly confused characters (quotes, dashes, ellipsis).",
     ),
     Tolerance(
         line_process=line_process_max_space_tolerance,
         severity_cat="WARNING",
         score_multiplier=50,
-        error_name=REMOVE_INDENTATION,
+        error_name="Warning: matching after removing all spaces in lines.",
     ),
 ]
 
 
+def fix_line_nums(
+    matched_lines: list[str], searched_lines: list[str], replaced_lines: list[str]
+) -> list[str]:
+    return [remove_leading_linenums(line) for line in replaced_lines]
+
+
 def fix_indentation(
     matched_lines: list[str], searched_lines: list[str], replaced_lines: list[str]
 ) -> list[str]:
@@ -312,6 +373,14 @@ def edit_file(self) -> list[FileEditOutput]:
             matches_with_tolerances = [(match, []) for match in matches]
 
         for match, tolerances in matches_with_tolerances:
+            if any(
+                tolerance.error_name == REMOVE_LINE_NUMS for tolerance in tolerances
+            ):
+                replace_by = fix_line_nums(
+                    self.file_lines[match.start : match.stop],
+                    first_block[0],
+                    replace_by,
+                )
             if any(
                 tolerance.error_name == REMOVE_INDENTATION for tolerance in tolerances
             ):
@@ -454,6 +523,9 @@ def match_with_tolerance(
                     tolerance_index_by_content_line[search_idx][content_idx]
                 ].count += 1
 
+    # Remove 0 counts
+    tolerances_counts = [[x for x in y if x.count > 0] for y in tolerances_counts]
+
     return list(zip(matched_slices, tolerances_counts))
 
 

src/wcgw/client/file_ops/search_replace.py

@@ -101,15 +101,15 @@ def search_replace_edit(
         )
 
     edited_content, comments_ = edit_with_individual_fallback(
-        original_lines, search_replace_blocks
+        original_lines, search_replace_blocks, False
     )
 
     edited_file = "\n".join(edited_content)
     if not comments_:
-        comments = "Edited successfully"
+        comments = "File edited successfully."
     else:
         comments = (
-            "Edited successfully. However, following warnings were generated while matching search blocks.\n"
+            "File edited successfully. However, following warnings were generated while matching search blocks.\n"
             + "\n".join(comments_)
         )
     return edited_file, comments
@@ -152,27 +152,45 @@ def identify_first_differing_block(
 
 
 def edit_with_individual_fallback(
-    original_lines: list[str], search_replace_blocks: list[tuple[list[str], list[str]]]
+    original_lines: list[str],
+    search_replace_blocks: list[tuple[list[str], list[str]]],
+    replace_all: bool,
 ) -> tuple[list[str], set[str]]:
     outputs = FileEditInput(original_lines, 0, search_replace_blocks, 0).edit_file()
     best_matches = FileEditOutput.get_best_match(outputs)
-
     try:
         edited_content, comments_ = best_matches[0].replace_or_throw(3)
     except SearchReplaceMatchError:
         if len(search_replace_blocks) > 1:
-            # Try one at a time
-            all_comments = set[str]()
-            running_lines = list(original_lines)
-            for block in search_replace_blocks:
-                running_lines, comments_ = edit_with_individual_fallback(
-                    running_lines, [block]
-                )
-                all_comments |= comments_
-            return running_lines, all_comments
+            try:
+                # Try one at a time
+                all_comments = set[str]()
+                running_lines = list(original_lines)
+                for block in search_replace_blocks:
+                    running_lines, comments_ = edit_with_individual_fallback(
+                        running_lines, [block], replace_all
+                    )
+                    all_comments |= comments_
+                return running_lines, all_comments
+            except SearchReplaceMatchError:
+                # Raise the outer error instead
+                # Otherwise the suggested search block will be
+                # after applying previous N search blocks and that
+                # would signal to LLM that we've updated the file
+                pass
         raise
 
-    if len(best_matches) > 1:
+    if replace_all and len(best_matches) > 1 and len(search_replace_blocks) == 1:
+        # For only one search/replace block only replace all
+        try:
+            edited_content, comments__ = edit_with_individual_fallback(
+                edited_content, search_replace_blocks, replace_all
+            )
+            comments_ |= comments__
+        except SearchReplaceMatchError:
+            # Will not happen ideally, but still no use of throwing error here
+            pass
+    elif len(best_matches) > 1:
         # Find the first block that differs across matches
         first_diff_block = identify_first_differing_block(best_matches)
         if first_diff_block is not None:

src/wcgw/client/tools.py

@@ -1064,7 +1064,7 @@ def get_tool_output(
                 arg.type,
                 context,
                 arg.any_workspace_path,
-                arg.initial_files_to_read,
+                arg.initial_files_to_read or [],
                 arg.task_id_to_resume,
                 coding_max_tokens,
                 noncoding_max_tokens,

src/wcgw/types_.py

@@ -52,7 +52,7 @@ class Initialize(BaseModel):
     any_workspace_path: str = Field(
         description="Workspce to initialise in. Don't use ~ by default, instead use empty string"
     )
-    initial_files_to_read: list[str]
+    initial_files_to_read: list[str] | None
     task_id_to_resume: str
     mode_name: Literal["wcgw", "architect", "code_writer"]
     thread_id: str = Field(

tests/test_mcp_server.py

@@ -136,7 +136,14 @@ async def test_handle_list_tools():
             assert "any_workspace_path" in properties
             assert properties["any_workspace_path"]["type"] == "string"
             assert "initial_files_to_read" in properties
-            assert properties["initial_files_to_read"]["type"] == "array"
+            # initial_files_to_read is list[str] | None, so it uses anyOf
+            assert "anyOf" in properties["initial_files_to_read"]
+            any_of = properties["initial_files_to_read"]["anyOf"]
+            assert len(any_of) == 2
+            # Check for array type
+            assert any(item.get("type") == "array" for item in any_of)
+            # Check for null type
+            assert any(item.get("type") == "null" for item in any_of)
         elif tool.name == "BashCommand":
             properties = tool.inputSchema["properties"]
             assert "action_json" in properties