wcgw 4.0.0__tar.gz → 4.1.0__tar.gz

wcgw-4.1.0/CLAUDE.md

@@ -0,0 +1,41 @@
+# Alignment instructions to contribute to this repository
+
+## Hard rules
+
+- Make sure mypy --strict passes for these two folders `uv run mypy --strict src/wcgw src/wcgw_cli`.
+- Use `list` directly for typing like `list[str]` no need to import `List`. Same thing for `tuple`, `set`, etc.
+- No optional parameters in a function with default values. All parameters must be passed by a caller.
+- This library uses `uv` as package manager. To add a package `uv add numpy`. To run pytest `uv run pytest` and so on.
+
+## Coding mantras
+
+### Reduce states and dependencies between the states
+
+- Don't introduce any state unless really necessary.
+- If anything can be derived, avoid storing it or passing it.
+
+#### Python `Exception` guideline 1
+
+- Exception thrown inside functions are their hidden extra state which should be avoided.
+- Parse don't validate: avoid throwing validation errors by letting the types avoid bad values to be passed in the first place.
+
+### Put burden on type checker not the code reader
+
+- No hidden contracts and assumptions.
+- Don't assume any relationship between two states unless it's encoded in the type of the state.
+- Any contract should be enforced by the way types are constructed.
+- If it's just not possible due to complexity to type in such a way to avoid hidden contract, add in docstring details.
+
+#### Python `Exception` guideline 2
+
+- When you can't avoid it, instead of enforcing the hidden contract as hard failure during runtime, try to return some sensible value instead.
+  _Example_
+  In PIL adding boxes outside image bounds don't do anything, but they don't fail either, making it a cleaner experience to deal with edge cases.
+
+- A functions signature (along with types) should be enough to understand its purpose.
+- This can be achieved by typing the parameters to only take narrow types
+
+### Functions should be as pure as possible
+
+- Avoid mutating mutable input parameters, instead return newly derived values in the output and leave upto the caller to update the state if required.
+- It should be clear from function signature what the function computes, this should also enforce the previous point of not updating mutable input parameters.

{wcgw-4.0.0 → wcgw-4.1.0}/PKG-INFO

@@ -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 → wcgw-4.1.0}/README.md

@@ -2,7 +2,7 @@
 
 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.
@@ -19,6 +19,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.
@@ -32,7 +34,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 → wcgw-4.1.0}/pyproject.toml

@@ -1,7 +1,7 @@
 [project]
 authors = [{ name = "Aman Rusia", email = "gapypi@arcfu.com" }]
 name = "wcgw"
-version = "4.0.0"
+version = "4.1.0"
 description = "Shell and coding agent on claude and chatgpt"
 readme = "README.md"
 requires-python = ">=3.11"

{wcgw-4.0.0 → wcgw-4.1.0}/src/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-4.0.0 → wcgw-4.1.0}/src/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-4.0.0 → wcgw-4.1.0}/src/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-4.0.0 → wcgw-4.1.0}/src/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-4.0.0 → wcgw-4.1.0}/src/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-4.0.0 → wcgw-4.1.0}/src/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-4.0.0 → wcgw-4.1.0}/src/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