wcgw 4.0.0__py3-none-any.whl → 4.1.0__py3-none-any.whl

wcgw/client/bash_state/bash_state.py

@@ -125,7 +125,6 @@ def cleanup_all_screens_with_name(name: str, console: Console) -> None:
         session_info = line.split()[0].strip()  # e.g., "1234.my_screen"
         if session_info.endswith(f".{name}"):
             sessions_to_kill.append(session_info)
-
     # Now, for every session we found, tell screen to quit it.
     for session in sessions_to_kill:
         try:
@@ -258,7 +257,12 @@ class BashState:
 
     def expect(self, pattern: Any, timeout: Optional[float] = -1) -> int:
         self.close_bg_expect_thread()
-        output = self._shell.expect(pattern, timeout)
+        try:
+            output = self._shell.expect(pattern, timeout)
+        except pexpect.TIMEOUT:
+            # Edge case: gets raised when the child fd is not ready in some timeout
+            # pexpect/utils.py:143
+            return 1
         return output
 
     def send(self, s: str | bytes, set_as_command: Optional[str]) -> int:
@@ -319,11 +323,9 @@ class BashState:
             self._bg_expect_thread_stop_event = threading.Event()
 
     def cleanup(self) -> None:
-        try:
-            self.close_bg_expect_thread()
-            self._shell.close(True)
-        finally:
-            cleanup_all_screens_with_name(self._shell_id, self.console)
+        cleanup_all_screens_with_name(self._shell_id, self.console)
+        self.close_bg_expect_thread()
+        self._shell.close(True)
 
     def __enter__(self) -> "BashState":
         return self

wcgw/client/file_ops/diff_edit.py

@@ -7,7 +7,13 @@ TOLERANCE_TYPES = Literal["SILENT", "WARNING", "ERROR"]
 
 
 class SearchReplaceMatchError(Exception):
-    pass
+    def __init__(self, message: str):
+        message = f"""
+{message}
+---
+Retry immediately with same "percentage_to_change" using search replace blocks fixing above error.
+"""
+        super().__init__(message)
 
 
 @dataclass
@@ -27,7 +33,9 @@ class TolerancesHit(Tolerance):
 class FileEditOutput:
     original_content: list[str]
     orig_search_blocks: list[list[str]]
-    edited_with_tolerances: list[tuple[slice, list[TolerancesHit], list[str]]]
+    edited_with_tolerances: list[
+        tuple[slice, list[TolerancesHit], list[str]]
+    ]  # Need not be equal to orig_search_blocks when early exit
 
     def replace_or_throw(
         self,
@@ -94,8 +102,7 @@ Error:
                     best_score = hit_score
                 elif abs(hit_score - best_score) < 1e-3:
                     best_hits.append(output)
-
-        return best_hits, best_score < 0
+        return best_hits, best_score > 1000
 
 
 def line_process_max_space_tolerance(line: str) -> str:
@@ -205,7 +212,7 @@ class FileEditInput:
                         TolerancesHit(
                             line_process=lambda x: x,
                             severity_cat="ERROR",
-                            score_multiplier=float("-inf"),
+                            score_multiplier=float("inf"),
                             error_name="The blocks couldn't be matched, maybe the sequence of search blocks was incorrect?",
                             count=max(1, len(search_lines)),
                         )
@@ -241,6 +248,7 @@ class FileEditInput:
 
         # search for first block
         first_block = self.search_replace_blocks[self.search_replace_offset]
+        replace_by = first_block[1]
 
         # Try exact match
         matches = match_exact(self.file_lines, self.file_line_offset, first_block[0])
@@ -252,7 +260,6 @@ class FileEditInput:
             matches_with_tolerances = match_with_tolerance(
                 self.file_lines, self.file_line_offset, first_block[0], self.tolerances
             )
-            replace_by = first_block[1]
             if not matches_with_tolerances:
                 # Try with no empty lines
                 matches_with_tolerances = match_with_tolerance_empty_line(
@@ -278,8 +285,8 @@ class FileEditInput:
                                     TolerancesHit(
                                         lambda x: x,
                                         "ERROR",
-                                        -1,
-                                        "Couldn't find match. Do you mean to match the lines in the following context?\n```"
+                                        float("inf"),
+                                        "Couldn't find match. Here's the latest snippet from the file which might be relevant for you to consider:\n```"
                                         + sim_context
                                         + "\n```",
                                         int(len(first_block[0]) // sim_sim),
@@ -288,51 +295,40 @@ class FileEditInput:
                             )
                         ]
 
-            for match, tolerances in matches_with_tolerances:
-                if any(
-                    tolerance.error_name == REMOVE_INDENTATION
-                    for tolerance in tolerances
-                ):
-                    replace_by = fix_indentation(
-                        self.file_lines[match.start : match.stop],
-                        first_block[0],
-                        replace_by,
-                    )
-
-                file_edit_input = FileEditInput(
-                    self.file_lines,
-                    match.stop,
-                    self.search_replace_blocks,
-                    self.search_replace_offset + 1,
-                    self.tolerances,
+        else:
+            matches_with_tolerances = [(match, []) for match in matches]
+
+        for match, tolerances in matches_with_tolerances:
+            if any(
+                tolerance.error_name == REMOVE_INDENTATION for tolerance in tolerances
+            ):
+                replace_by = fix_indentation(
+                    self.file_lines[match.start : match.stop],
+                    first_block[0],
+                    replace_by,
                 )
 
-                remaining_output = file_edit_input.edit_file()
-                for rem_output in remaining_output:
-                    all_outputs.append(
-                        [
-                            (match, tolerances, replace_by),
-                            *rem_output.edited_with_tolerances,
-                        ]
-                    )
-        else:
-            for match in matches:
-                file_edit_input = FileEditInput(
-                    self.file_lines,
-                    match.stop,
-                    self.search_replace_blocks,
-                    self.search_replace_offset + 1,
-                    self.tolerances,
+            file_edit_input = FileEditInput(
+                self.file_lines,
+                match.stop,
+                self.search_replace_blocks,
+                self.search_replace_offset + 1,
+                self.tolerances,
+            )
+
+            if any(tolerance.severity_cat == "ERROR" for tolerance in tolerances):
+                # Exit early
+                all_outputs.append(
+                    [
+                        (match, tolerances, replace_by),
+                    ]
                 )
+            else:
                 remaining_output = file_edit_input.edit_file()
                 for rem_output in remaining_output:
                     all_outputs.append(
                         [
-                            (
-                                match,
-                                [],
-                                first_block[1],
-                            ),
+                            (match, tolerances, replace_by),
                             *rem_output.edited_with_tolerances,
                         ]
                     )

wcgw/client/file_ops/search_replace.py

@@ -1,5 +1,5 @@
 import re
-from typing import Callable
+from typing import Callable, Optional
 
 from .diff_edit import FileEditInput, FileEditOutput, SearchReplaceMatchError
 
@@ -100,9 +100,10 @@ def search_replace_edit(
             "No valid search replace blocks found, ensure your SEARCH/REPLACE blocks are formatted correctly"
         )
 
-    edited_content, comments_ = greedy_context_replace(
-        original_lines, [[x] for x in search_replace_blocks], original_lines, set(), 0
+    edited_content, comments_ = edit_with_individual_fallback(
+        original_lines, search_replace_blocks
     )
+
     edited_file = "\n".join(edited_content)
     if not comments_:
         comments = "Edited successfully"
@@ -114,63 +115,81 @@ def search_replace_edit(
     return edited_file, comments
 
 
-def greedy_context_replace(
-    original_lines: list[str],
-    search_replace_blocks: list[list[tuple[list[str], list[str]]]],
-    running_lines: list[str],
-    running_comments: set[str],
-    current_block_offset: int,
-) -> tuple[list[str], set[str]]:
-    if current_block_offset >= len(search_replace_blocks):
-        return running_lines, running_comments
-    current_blocks = search_replace_blocks[current_block_offset]
+def identify_first_differing_block(
+    best_matches: list[FileEditOutput],
+) -> Optional[list[str]]:
+    """
+    Identify the first search block that differs across multiple best matches.
+    Returns the search block content that first shows different matches.
+    """
+    if not best_matches or len(best_matches) <= 1:
+        return None
+
+    # First, check if the number of blocks differs (shouldn't happen, but let's be safe)
+    block_counts = [len(match.edited_with_tolerances) for match in best_matches]
+    if not all(count == block_counts[0] for count in block_counts):
+        # If block counts differ, just return the first search block as problematic
+        return (
+            best_matches[0].orig_search_blocks[0]
+            if best_matches[0].orig_search_blocks
+            else None
+        )
+
+    # Go through each block position and see if the slices differ
+    for i in range(min(block_counts)):
+        slices = [match.edited_with_tolerances[i][0] for match in best_matches]
 
-    outputs = FileEditInput(running_lines, 0, current_blocks, 0).edit_file()
+        # Check if we have different slices for this block across matches
+        if any(s.start != slices[0].start or s.stop != slices[0].stop for s in slices):
+            # We found our differing block - return the search block content
+            if i < len(best_matches[0].orig_search_blocks):
+                return best_matches[0].orig_search_blocks[i]
+            else:
+                return None
+
+    # If we get here, we couldn't identify a specific differing block
+    return None
+
+
+def edit_with_individual_fallback(
+    original_lines: list[str], search_replace_blocks: list[tuple[list[str], list[str]]]
+) -> tuple[list[str], set[str]]:
+    outputs = FileEditInput(original_lines, 0, search_replace_blocks, 0).edit_file()
     best_matches, is_error = FileEditOutput.get_best_match(outputs)
 
-    if is_error:
-        best_matches[0].replace_or_throw(3)
-        raise Exception("Shouldn't happen")
+    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
+        raise
+    assert not is_error
 
     if len(best_matches) > 1:
-        # Duplicate found, try to ground using previous blocks.
-        if current_block_offset == 0:
-            matches_ = "\n".join(current_blocks[-1][0])
+        # Find the first block that differs across matches
+        first_diff_block = identify_first_differing_block(best_matches)
+        if first_diff_block is not None:
+            block_content = "\n".join(first_diff_block)
             raise SearchReplaceMatchError(f"""
-    The following block matched more than once:
-    ---
-    ```
-    {matches_}
-    ```
+The following block matched more than once:
+```
+{block_content}
+```
+Consider adding more context before and after this block to make the match unique.
     """)
-
         else:
-            search_replace_blocks = (
-                search_replace_blocks[: current_block_offset - 1]
-                + [search_replace_blocks[current_block_offset - 1] + current_blocks]
-                + search_replace_blocks[current_block_offset + 1 :]
-            )
-            try:
-                return greedy_context_replace(
-                    original_lines, search_replace_blocks, original_lines, set(), 0
-                )
-            except Exception:
-                ma_more = "\n".join(current_blocks[-1][0])
-                raise Exception(f"""
-        The following block matched more than once:
-        ---
-        ```
-        {ma_more}
-        ```
-        """)
-
-    best_match = best_matches[0]
-    running_lines, comments = best_match.replace_or_throw(3)
-    running_comments = running_comments | comments
-    return greedy_context_replace(
-        original_lines,
-        search_replace_blocks,
-        running_lines,
-        running_comments,
-        current_block_offset + 1,
-    )
+            raise SearchReplaceMatchError("""
+One of the blocks matched more than once
+
+Consider adding more context before and after all the blocks to make the match unique.
+    """)
+
+    return edited_content, comments_

wcgw/client/mcp_server/server.py

@@ -16,7 +16,7 @@ from wcgw.client.tool_prompts import TOOL_PROMPTS
 from ...types_ import (
     Initialize,
 )
-from ..bash_state.bash_state import CONFIG, BashState
+from ..bash_state.bash_state import CONFIG, BashState, get_tmpdir
 from ..tools import (
     Context,
     default_enc,
@@ -155,9 +155,13 @@ async def main() -> None:
     global BASH_STATE
     CONFIG.update(3, 55, 5)
     version = str(importlib.metadata.version("wcgw"))
-    home_dir = os.path.expanduser("~")
+
+    # starting_dir is inside tmp dir
+    tmp_dir = get_tmpdir()
+    starting_dir = os.path.join(tmp_dir, "claude_playground")
+
     with BashState(
-        Console(), home_dir, None, None, None, None, True, None
+        Console(), starting_dir, None, None, None, None, True, None
     ) as BASH_STATE:
         BASH_STATE.console.log("wcgw version: " + version)
         # Run the server using stdin/stdout streams

wcgw/client/modes.py

@@ -125,8 +125,9 @@ Instructions:
     - Do not install new tools/packages before ensuring no such tools/package or an alternative already exists.
     - Do not use artifacts if you have access to the repository and not asked by the user to provide artifacts/snippets. Directly create/update using wcgw tools
     - Do not use Ctrl-c or interrupt commands without asking the user, because often the programs don't show any update but they still are running.
-    - Do not use echo to write multi-line files, always use FileEdit tool to update a code.
-    
+    - Do not use echo to write multi-line files, always use FileWriteOrEdit tool to update a code.
+    - Provide as many file paths as you need in ReadFiles in one go.
+
 Additional instructions:
     Always run `pwd` if you get any file or directory not found error to make sure you're not lost, or to get absolute cwd.
 
@@ -134,18 +135,26 @@ Additional instructions:
 
 
 """
-ARCHITECT_PROMPT = """You are now running in "architect" mode. This means
+ARCHITECT_PROMPT = """
+# Instructions
+You are now running in "architect" mode. This means
 - You are not allowed to edit or update any file. You are not allowed to create any file. 
 - You are not allowed to run any commands that may change disk, system configuration, packages or environment. Only read-only commands are allowed.
 - Only run commands that allows you to explore the repository, understand the system or read anything of relevance. 
 - Do not use Ctrl-c or interrupt commands without asking the user, because often the programs don't show any update but they still are running.
 - You are not allowed to change directory (bash will run in -r mode)
 - Share only snippets when any implementation is requested.
+- Provide as many file paths as you need in ReadFiles in one go.
+
+# Disallowed tools (important!)
+- FileWriteOrEdit
 
+# Response instructions
 Respond only after doing the following:
 - Read as many relevant files as possible. 
 - Be comprehensive in your understanding and search of relevant files.
 - First understand about the project by getting the folder structure (ignoring .git, node_modules, venv, etc.)
+- Share minimal snippets higlighting the changes (avoid large number of lines in the snippets, use ... comments)
 """
 
 

wcgw/client/repo_ops/repo_context.py

@@ -141,7 +141,22 @@ def get_recent_git_files(repo: Repository, count: int = 10) -> list[str]:
     return recent_files
 
 
-def get_repo_context(file_or_repo_path: str, max_files: int) -> tuple[str, Path]:
+def calculate_dynamic_file_limit(total_files: int) -> int:
+    # Scale linearly, with minimum and maximum bounds
+    min_files = 50
+    max_files = 400
+
+    if total_files <= min_files:
+        return min_files
+
+    scale_factor = (max_files - min_files) / (30000 - min_files)
+
+    dynamic_limit = min_files + int((total_files - min_files) * scale_factor)
+
+    return min(max_files, dynamic_limit)
+
+
+def get_repo_context(file_or_repo_path: str) -> tuple[str, Path]:
     file_or_repo_path_ = Path(file_or_repo_path).absolute()
 
     repo = find_ancestor_with_git(file_or_repo_path_)
@@ -150,9 +165,6 @@ def get_repo_context(file_or_repo_path: str, max_files: int) -> tuple[str, Path]
     # Determine the context directory
     if repo is not None:
         context_dir = Path(repo.path).parent
-        # Get recent git files - get at least 50 or the max_files count, whichever is larger
-        recent_files_count = max(10, max_files)
-        recent_git_files = get_recent_git_files(repo, recent_files_count)
     else:
         if file_or_repo_path_.is_file():
             context_dir = file_or_repo_path_.parent
@@ -162,8 +174,19 @@ def get_repo_context(file_or_repo_path: str, max_files: int) -> tuple[str, Path]
     # Load workspace stats from the context directory
     workspace_stats = load_workspace_stats(str(context_dir))
 
+    # Get all files and calculate dynamic max files limit once
     all_files = get_all_files_max_depth(str(context_dir), 10, repo)
 
+    # For Git repositories, get recent files
+    if repo is not None:
+        dynamic_max_files = calculate_dynamic_file_limit(len(all_files))
+        # Get recent git files - get at least 10 or 20% of dynamic_max_files, whichever is larger
+        recent_files_count = max(10, int(dynamic_max_files * 0.2))
+        recent_git_files = get_recent_git_files(repo, recent_files_count)
+    else:
+        # We don't want dynamic limit for non git folders like /tmp or ~
+        dynamic_max_files = 50
+
     # Calculate probabilities in batch
     path_scores = PATH_SCORER.calculate_path_probabilities_batch(all_files)
 
@@ -218,16 +241,16 @@ def get_repo_context(file_or_repo_path: str, max_files: int) -> tuple[str, Path]
         if file not in top_files and file in all_files:
             top_files.append(file)
 
-    # Use statistical sorting for the remaining files, but respect max_files limit
+    # Use statistical sorting for the remaining files, but respect dynamic_max_files limit
     # and ensure we don't add duplicates
-    if len(top_files) < max_files:
+    if len(top_files) < dynamic_max_files:
         # Only add statistically important files that aren't already in top_files
         for file in sorted_files:
-            if file not in top_files and len(top_files) < max_files:
+            if file not in top_files and len(top_files) < dynamic_max_files:
                 top_files.append(file)
 
-    directory_printer = DirectoryTree(context_dir, max_files=max_files)
-    for file in top_files[:max_files]:
+    directory_printer = DirectoryTree(context_dir, max_files=dynamic_max_files)
+    for file in top_files[:dynamic_max_files]:
         directory_printer.expand(file)
 
     return directory_printer.display(), context_dir
@@ -245,7 +268,7 @@ if __name__ == "__main__":
     # Profile using cProfile for overall function statistics
     profiler = cProfile.Profile()
     profiler.enable()
-    result = get_repo_context(folder, 50)[0]
+    result = get_repo_context(folder)[0]
     profiler.disable()
 
     # Print cProfile stats
@@ -257,7 +280,7 @@ if __name__ == "__main__":
     # Profile using line_profiler for line-by-line statistics
     lp = LineProfiler()
     lp_wrapper = lp(get_repo_context)
-    lp_wrapper(folder, 50)
+    lp_wrapper(folder)
 
     print("\n=== Line-by-line profiling ===")
     lp.print_stats()

wcgw/client/tool_prompts.py

@@ -77,6 +77,7 @@ TOOL_PROMPTS = [
         description="""
 - Writes or edits a file based on the percentage of changes.
 - Use absolute path only (~ allowed).
+- percentage_to_change is calculated as number of existing lines that will have some diff divided by total existing lines.
 - First write down percentage of lines that need to be replaced in the file (between 0-100) in percentage_to_change
 - percentage_to_change should be low if mostly new code is to be added. It should be high if a lot of things are to be replaced.
 - If percentage_to_change > 50, provide full file content in file_content_or_search_replace_blocks

wcgw/client/tools.py

@@ -142,7 +142,7 @@ def initialize(
                     read_files_ = [any_workspace_path]
                 any_workspace_path = os.path.dirname(any_workspace_path)
             # Let get_repo_context handle loading the workspace stats
-            repo_context, folder_to_start = get_repo_context(any_workspace_path, 50)
+            repo_context, folder_to_start = get_repo_context(any_workspace_path)
 
             repo_context = f"---\n# Workspace structure\n{repo_context}\n---\n"
 
@@ -229,6 +229,20 @@ def initialize(
         )
         initial_files_context = f"---\n# Requested files\n{initial_files}\n---\n"
 
+    # Check for CLAUDE.md in the workspace folder on first call
+    alignment_context = ""
+    if folder_to_start:
+        alignment_file_path = os.path.join(folder_to_start, "CLAUDE.md")
+        if os.path.exists(alignment_file_path):
+            try:
+                # Read the CLAUDE.md file content
+                with open(alignment_file_path, "r") as f:
+                    alignment_content = f.read()
+                alignment_context = f"---\n# CLAUDE.md - Project alignment guidelines\n```\n{alignment_content}\n```\n---\n\n"
+            except Exception:
+                # Handle any errors when reading the file
+                alignment_context = ""
+
     uname_sysname = os.uname().sysname
     uname_machine = os.uname().machine
 
@@ -239,9 +253,11 @@ def initialize(
 System: {uname_sysname}
 Machine: {uname_machine}
 Initialized in directory (also cwd): {context.bash_state.cwd}
+User home directory: {expanduser("~")}
 
 {repo_context}
 
+{alignment_context}
 {initial_files_context}
 
 ---

{wcgw-4.0.0.dist-info → wcgw-4.1.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wcgw
-Version: 4.0.0
+Version: 4.1.0
 Summary: Shell and coding agent on claude and chatgpt
 Project-URL: Homepage, https://github.com/rusiaaman/wcgw
 Author-email: Aman Rusia <gapypi@arcfu.com>
@@ -29,7 +29,7 @@ Description-Content-Type: text/markdown
 
 Empowering chat applications to code, build and run on your local machine.
 
-- Claude - An MCP server on claude desktop for autonomous shell and coding agent. (mac, linux, windows on wsl)
+- Claude - MCP server with tightly integrated shell and code editing tools.
 - Chatgpt - Allows custom gpt to talk to your shell via a relay server. (linux, mac, windows on wsl)
 
 ⚠️ Warning: do not allow BashCommand tool without reviewing the command, it may result in data loss.
@@ -46,6 +46,8 @@ Empowering chat applications to code, build and run on your local machine.
 
 ## Updates
 
+- [24 Mar 2025] Improved writing and editing experience for sonnet 3.7, CLAUDE.md gets loaded automatically.
+
 - [16 Feb 2025] You can now attach to the working terminal that the AI uses. See the "attach-to-terminal" section below.
 
 - [15 Jan 2025] Modes introduced: architect, code-writer, and all powerful wcgw mode.
@@ -59,7 +61,7 @@ Empowering chat applications to code, build and run on your local machine.
 ## 🚀 Highlights
 
 - ⚡ **Create, Execute, Iterate**: Ask claude to keep running compiler checks till all errors are fixed, or ask it to keep checking for the status of a long running command till it's done.
-- ⚡ **Large file edit**: Supports large file incremental edits to avoid token limit issues. Faster than full file write.
+- ⚡ **Large file edit**: Supports large file incremental edits to avoid token limit issues. Smartly selects when to do small edits or large rewrite based on % of change needed.
 - ⚡ **Syntax checking on edits**: Reports feedback to the LLM if its edits have any syntax errors, so that it can redo it.
 - ⚡ **Interactive Command Handling**: Supports interactive commands using arrow keys, interrupt, and ansi escape sequences.
 - ⚡ **File protections**:

{wcgw-4.0.0.dist-info → wcgw-4.1.0.dist-info}/RECORD

@@ -5,22 +5,22 @@ wcgw/client/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 wcgw/client/common.py,sha256=OCH7Tx64jojz3M3iONUrGMadE07W21DiZs5sOxWX1Qc,1456
 wcgw/client/diff-instructions.txt,sha256=HXYfGvhlDMxmiIX9AbB05wJcptJF_gSIobYhYSqWRJo,1685
 wcgw/client/memory.py,sha256=M0plOGE5WXTEAs7nVLg4eCpVhmSW94ckpg5D0ycWX5I,2927
-wcgw/client/modes.py,sha256=Opmy5nKrCA4YITn79G1Q8l55xeBmhwtSv6MasSGkp5U,10338
-wcgw/client/tool_prompts.py,sha256=H2jzhnRDv99R-VaYo38FtGh4DxAVJniqG5Wuj35JfHs,4287
-wcgw/client/tools.py,sha256=rsoEUVVqZkYCTK-qlsik4CuxsmANvNOoCXJgDHAAX1Y,43243
-wcgw/client/bash_state/bash_state.py,sha256=9lBqdnHStgKEOU_t1ACeHed0cwbO2npaLAiEerFj1Es,33874
+wcgw/client/modes.py,sha256=gXm0u5EGQuPYEPZnyAptdzusN0JzLMED_DyErojPE6s,10679
+wcgw/client/tool_prompts.py,sha256=zHJQHb_E44zA3rBIkAudibgP3Zbw0DjA-CKM8qlqmMU,4410
+wcgw/client/tools.py,sha256=JXk6t7iNtP2EK6mdTkMqCquGGQ6TtoIJ8AEhkSith14,43963
+wcgw/client/bash_state/bash_state.py,sha256=1i72oLJ73AHvj0XmK0kAKnksiZwxWdAg21K27loKmpo,34020
 wcgw/client/encoder/__init__.py,sha256=Y-8f43I6gMssUCWpX5rLYiAFv3D-JPRs4uNEejPlke8,1514
-wcgw/client/file_ops/diff_edit.py,sha256=vKELPknWu3FGgPos74yN9wox6BCVcaocZ7dpBAT8Blk,18723
-wcgw/client/file_ops/search_replace.py,sha256=2biF6b_l9JRWXJRkeRIo_ltUVBKgsQgPuDd_sqkPMX8,5811
+wcgw/client/file_ops/diff_edit.py,sha256=eNxFRmVsBfY0ISwfsV5s8rlMwMxTlm6ko150iFFCsT8,18525
+wcgw/client/file_ops/search_replace.py,sha256=TaIPDqjgmTo4oghhO3zIFklq5JjAbx_aPHJ7yEgvDh4,6854
 wcgw/client/mcp_server/Readme.md,sha256=2Z88jj1mf9daYGW1CWaldcJ0moy8owDumhR2glBY3A8,109
 wcgw/client/mcp_server/__init__.py,sha256=mm7xhBIPwJpRT3u-Qsj4cKVMpVyucJoKRlbMP_gRRB0,343
-wcgw/client/mcp_server/server.py,sha256=ayK6qbzCveoQW7RO80m10cAIS3m-hvxzd15XhjiyxmE,5055
+wcgw/client/mcp_server/server.py,sha256=bHr9kv6hOs8s7LySNfpJeSX69GdFvFtbWpVyrp3G_eM,5160
 wcgw/client/repo_ops/display_tree.py,sha256=uOGX2IbXTKXwtXT2wdDszuH4ODmSYsHm0toU55e1vYI,4021
 wcgw/client/repo_ops/file_stats.py,sha256=AUA0Br7zFRpylWFYZPGMeGPJy3nWp9e2haKi34JptHE,4887
 wcgw/client/repo_ops/path_prob.py,sha256=SWf0CDn37rtlsYRQ51ufSxay-heaQoVIhr1alB9tZ4M,2144
 wcgw/client/repo_ops/paths_model.vocab,sha256=M1pXycYDQehMXtpp-qAgU7rtzeBbCOiJo4qcYFY0kqk,315087
 wcgw/client/repo_ops/paths_tokens.model,sha256=jiwwE4ae8ADKuTZISutXuM5Wfyc_FBmN5rxTjoNnCos,1569052
-wcgw/client/repo_ops/repo_context.py,sha256=vB3ET5RLA7p9OpL3XNPr3nycQkoeu6gC-RbyA9Ml-xA,8871
+wcgw/client/repo_ops/repo_context.py,sha256=e_w-1VfxWQiZT3r66N13nlmPt6AGm0uvG3A7aYSgaCI,9632
 wcgw/relay/client.py,sha256=BUeEKUsWts8RpYxXwXcyFyjBJhOCS-CxThAlL_-VCOI,3618
 wcgw/relay/serve.py,sha256=vaHxSm4DkWUKLMOnz2cO6ClR2udnaXCWAGl0O_bXvrs,6984
 wcgw/relay/static/privacy.txt,sha256=s9qBdbx2SexCpC_z33sg16TptmAwDEehMCLz4L50JLc,529
@@ -52,8 +52,8 @@ mcp_wcgw/shared/memory.py,sha256=dBsOghxHz8-tycdSVo9kSujbsC8xb_tYsGmuJobuZnw,281
 mcp_wcgw/shared/progress.py,sha256=ymxOsb8XO5Mhlop7fRfdbmvPodANj7oq6O4dD0iUcnw,1048
 mcp_wcgw/shared/session.py,sha256=e44a0LQOW8gwdLs9_DE9oDsxqW2U8mXG3d5KT95bn5o,10393
 mcp_wcgw/shared/version.py,sha256=d2LZii-mgsPIxpshjkXnOTUmk98i0DT4ff8VpA_kAvE,111
-wcgw-4.0.0.dist-info/METADATA,sha256=lep9tKuEznEoFQBQ7VpRAOrhUlFnGcPu8Q4KXIE2QQo,14785
-wcgw-4.0.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-wcgw-4.0.0.dist-info/entry_points.txt,sha256=vd3tj1_Kzfp55LscJ8-6WFMM5hm9cWTfNGFCrWBnH3Q,124
-wcgw-4.0.0.dist-info/licenses/LICENSE,sha256=BvY8xqjOfc3X2qZpGpX3MZEmF-4Dp0LqgKBbT6L_8oI,11142
-wcgw-4.0.0.dist-info/RECORD,,
+wcgw-4.1.0.dist-info/METADATA,sha256=6v32rPTVYTPeEGY9F0miFZRknGe31eeN0bZKWskoSW8,14916
+wcgw-4.1.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+wcgw-4.1.0.dist-info/entry_points.txt,sha256=vd3tj1_Kzfp55LscJ8-6WFMM5hm9cWTfNGFCrWBnH3Q,124
+wcgw-4.1.0.dist-info/licenses/LICENSE,sha256=BvY8xqjOfc3X2qZpGpX3MZEmF-4Dp0LqgKBbT6L_8oI,11142
+wcgw-4.1.0.dist-info/RECORD,,