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

wcgw/client/bash_state/bash_state.py

@@ -16,6 +16,7 @@ from typing import (
 )
 
 import pexpect
+import psutil
 import pyte
 
 from ...types_ import (
@@ -30,6 +31,7 @@ from ...types_ import (
 )
 from ..encoder import EncoderDecoder
 from ..modes import BashCommandMode, FileEditMode, WriteIfEmptyMode
+from .parser.bash_statement_parser import BashStatementParser
 
 PROMPT_CONST = "wcgw→" + " "
 PROMPT_STATEMENT = "export GIT_PAGER=cat PAGER=cat PROMPT_COMMAND= PS1='wcgw→'' '"
@@ -87,6 +89,116 @@ def check_if_screen_command_available() -> bool:
         return False
 
 
+def get_wcgw_screen_sessions() -> list[str]:
+    """
+    Get a list of all WCGW screen session IDs.
+
+    Returns:
+        List of screen session IDs that match the wcgw pattern.
+    """
+    screen_sessions = []
+
+    try:
+        # Get list of all screen sessions
+        result = subprocess.run(
+            ["screen", "-ls"],
+            capture_output=True,
+            text=True,
+            check=False,  # Don't raise exception on non-zero exit code
+            timeout=0.5,
+        )
+        output = result.stdout or result.stderr or ""
+
+        # Parse screen output to get session IDs
+        for line in output.splitlines():
+            line = line.strip()
+            if not line or not line[0].isdigit():
+                continue
+
+            # Extract session info (e.g., "1234.wcgw.123456 (Detached)")
+            session_parts = line.split()
+            if not session_parts:
+                continue
+
+            session_id = session_parts[0].strip()
+
+            # Check if it's a WCGW session
+            if ".wcgw." in session_id:
+                screen_sessions.append(session_id)
+    except Exception:
+        # If anything goes wrong, just return empty list
+        pass
+
+    return screen_sessions
+
+
+def get_orphaned_wcgw_screens() -> list[str]:
+    """
+    Identify orphaned WCGW screen sessions where the parent process has PID 1
+    or doesn't exist.
+
+    Returns:
+        List of screen session IDs that are orphaned and match the wcgw pattern.
+    """
+    orphaned_screens = []
+
+    try:
+        # Get list of all WCGW screen sessions
+        screen_sessions = get_wcgw_screen_sessions()
+
+        for session_id in screen_sessions:
+            # Extract PID from session ID (first part before the dot)
+            try:
+                pid = int(session_id.split(".")[0])
+
+                # Check if process exists and if its parent is PID 1
+                try:
+                    process = psutil.Process(pid)
+                    parent_pid = process.ppid()
+
+                    if parent_pid == 1:
+                        # This is an orphaned process
+                        orphaned_screens.append(session_id)
+                except psutil.NoSuchProcess:
+                    # Process doesn't exist anymore, consider it orphaned
+                    orphaned_screens.append(session_id)
+            except (ValueError, IndexError):
+                # Couldn't parse PID, skip
+                continue
+    except Exception:
+        # If anything goes wrong, just return empty list
+        pass
+
+    return orphaned_screens
+
+
+def cleanup_orphaned_wcgw_screens(console: Console) -> None:
+    """
+    Clean up all orphaned WCGW screen sessions.
+
+    Args:
+        console: Console for logging.
+    """
+    orphaned_sessions = get_orphaned_wcgw_screens()
+
+    if not orphaned_sessions:
+        return
+
+    console.log(
+        f"Found {len(orphaned_sessions)} orphaned WCGW screen sessions to clean up"
+    )
+
+    for session in orphaned_sessions:
+        try:
+            subprocess.run(
+                ["screen", "-S", session, "-X", "quit"],
+                check=False,
+                timeout=CONFIG.timeout,
+            )
+        except Exception as e:
+            console.log(f"Failed to kill orphaned screen session: {session}\n{e}")
+
+
 def cleanup_all_screens_with_name(name: str, console: Console) -> None:
     """
     There could be in worst case multiple screens with same name, clear them if any.
@@ -125,7 +237,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,13 +369,20 @@ 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:
         self.close_bg_expect_thread()
         if set_as_command is not None:
             self._last_command = set_as_command
+        # if s == "\n":
+        #     return self._shell.sendcontrol("m")
         output = self._shell.send(s)
         return output
 
@@ -319,11 +437,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
@@ -385,6 +501,11 @@ class BashState:
         self._last_command = ""
         # Ensure self._cwd exists
         os.makedirs(self._cwd, exist_ok=True)
+
+        # Clean up orphaned WCGW screen sessions
+        if check_if_screen_command_available():
+            cleanup_orphaned_wcgw_screens(self.console)
+
         try:
             self._shell, self._shell_id = start_shell(
                 self._bash_command_mode.bash_mode == "restricted_mode",
@@ -815,10 +936,22 @@ def _execute_bash(
                 raise ValueError(WAITING_INPUT_MESSAGE)
 
             command = command_data.command.strip()
+
+            # Check for multiple statements using the bash statement parser
             if "\n" in command:
-                raise ValueError(
-                    "Command should not contain newline character in middle. Run only one command at a time."
-                )
+                try:
+                    parser = BashStatementParser()
+                    statements = parser.parse_string(command)
+                    if len(statements) > 1:
+                        return (
+                            "Error: Command contains multiple statements. Please run only one bash statement at a time.",
+                            0.0,
+                        )
+                except Exception:
+                    # Fall back to simple newline check if something goes wrong
+                    raise ValueError(
+                        "Command should not contain newline character in middle. Run only one command at a time."
+                    )
 
             for i in range(0, len(command), 128):
                 bash_state.send(command[i : i + 128], set_as_command=None)

wcgw/client/bash_state/parser/__init__.py

@@ -0,0 +1,7 @@
+"""
+Parser for bash statements using tree-sitter.
+
+This module provides functionality to parse and identify individual bash statements.
+"""
+
+from .bash_statement_parser import BashStatementParser, Statement

wcgw/client/bash_state/parser/bash_statement_parser.py

@@ -0,0 +1,181 @@
+#!/usr/bin/env python3
+"""
+Bash Statement Parser
+
+This script parses bash scripts and identifies individual statements using tree-sitter.
+It correctly handles multi-line strings, command chains with && and ||, and semicolon-separated statements.
+"""
+
+import sys
+from dataclasses import dataclass
+from typing import Any, List, Optional
+
+import tree_sitter_bash
+from tree_sitter import Language, Parser
+
+
+@dataclass
+class Statement:
+    """A bash statement with its source code and position information."""
+
+    text: str
+    start_line: int
+    end_line: int
+    start_byte: int
+    end_byte: int
+    node_type: str
+    parent_type: Optional[str] = None
+
+    def __str__(self) -> str:
+        return self.text.strip()
+
+
+class BashStatementParser:
+    def __init__(self) -> None:
+        # Use the precompiled bash language
+        self.language = Language(tree_sitter_bash.language())
+        self.parser = Parser(self.language)
+
+    def parse_file(self, file_path: str) -> List[Statement]:
+        """Parse a bash script file and return a list of statements."""
+        with open(file_path, "r", encoding="utf-8") as f:
+            content = f.read()
+        return self.parse_string(content)
+
+    def parse_string(self, content: str) -> List[Statement]:
+        """Parse a string containing bash script and return a list of statements."""
+        tree = self.parser.parse(bytes(content, "utf-8"))
+        root_node = tree.root_node
+
+        # For debugging: Uncomment to print the tree structure
+        # self._print_tree(root_node, content)
+
+        statements: List[Statement] = []
+        self._extract_statements(root_node, content, statements, None)
+
+        # Post-process statements to handle multi-line statements correctly
+        return self._post_process_statements(statements, content)
+
+    def _print_tree(self, node: Any, content: str, indent: str = "") -> None:
+        """Debug helper to print the entire syntax tree."""
+        node_text = content[node.start_byte : node.end_byte]
+        if len(node_text) > 40:
+            node_text = node_text[:37] + "..."
+        print(f"{indent}{node.type}: {repr(node_text)}")
+        for child in node.children:
+            self._print_tree(child, content, indent + "  ")
+
+    def _extract_statements(
+        self,
+        node: Any,
+        content: str,
+        statements: List[Statement],
+        parent_type: Optional[str],
+    ) -> None:
+        """Recursively extract statements from the syntax tree."""
+        # Node types that represent bash statements
+        statement_node_types = {
+            # Basic statements
+            "command",
+            "variable_assignment",
+            "declaration_command",
+            "unset_command",
+            # Control flow statements
+            "for_statement",
+            "c_style_for_statement",
+            "while_statement",
+            "if_statement",
+            "case_statement",
+            # Function definition
+            "function_definition",
+            # Command chains and groups
+            "pipeline",  # For command chains with | and |&
+            "list",  # For command chains with && and ||
+            "compound_statement",
+            "subshell",
+            "redirected_statement",
+        }
+
+        # Create a Statement object for this node if it's a recognized statement type
+        if node.type in statement_node_types:
+            # Get the text of this statement
+            start_byte = node.start_byte
+            end_byte = node.end_byte
+            statement_text = content[start_byte:end_byte]
+
+            # Get line numbers
+            start_line = (
+                node.start_point[0] + 1
+            )  # tree-sitter uses 0-indexed line numbers
+            end_line = node.end_point[0] + 1
+
+            statements.append(
+                Statement(
+                    text=statement_text,
+                    start_line=start_line,
+                    end_line=end_line,
+                    start_byte=start_byte,
+                    end_byte=end_byte,
+                    node_type=node.type,
+                    parent_type=parent_type,
+                )
+            )
+
+            # Update parent type for children
+            parent_type = node.type
+
+        # Recursively process all children
+        for child in node.children:
+            self._extract_statements(child, content, statements, parent_type)
+
+    def _post_process_statements(
+        self, statements: List[Statement], content: str
+    ) -> List[Statement]:
+        if not statements:
+            return []
+
+        # Filter out list statements that have been split
+        top_statements = []
+        for stmt in statements:
+            # Skip statements that are contained within others
+            is_contained = False
+            for other in statements:
+                if other is stmt:
+                    continue
+
+                # Check if completely contained (except for lists we've split)
+                if other.node_type != "list" or ";" not in other.text:
+                    if (
+                        other.start_line <= stmt.start_line
+                        and other.end_line >= stmt.end_line
+                        and len(other.text) > len(stmt.text)
+                        and stmt.text in other.text
+                    ):
+                        is_contained = True
+                        break
+
+            if not is_contained:
+                top_statements.append(stmt)
+
+        # Sort by position in file for consistent output
+        top_statements.sort(key=lambda s: (s.start_line, s.text))
+
+        return top_statements
+
+
+def main() -> None:
+    if len(sys.argv) < 2:
+        print("Usage: python bash_statement_parser.py <bash_script_file>")
+        sys.exit(1)
+
+    parser = BashStatementParser()
+    statements = parser.parse_file(sys.argv[1])
+
+    print(f"Found {len(statements)} statements:")
+    for i, stmt in enumerate(statements, 1):
+        print(f"\n--- Statement {i} (Lines {stmt.start_line}-{stmt.end_line}) ---")
+        print(stmt)
+
+
+if __name__ == "__main__":
+    main()

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.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wcgw
-Version: 4.0.0
+Version: 4.1.1
 Summary: Shell and coding agent on claude and chatgpt
 Project-URL: Homepage, https://github.com/rusiaaman/wcgw
 Author-email: Aman Rusia <gapypi@arcfu.com>
@@ -11,6 +11,7 @@ Requires-Dist: fastapi>=0.115.0
 Requires-Dist: openai>=1.46.0
 Requires-Dist: petname>=2.6
 Requires-Dist: pexpect>=4.9.0
+Requires-Dist: psutil>=7.0.0
 Requires-Dist: pydantic>=2.9.2
 Requires-Dist: pygit2>=1.16.0
 Requires-Dist: pyte>=0.8.2
@@ -29,7 +30,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 +47,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 +62,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.1.dist-info}/RECORD

@@ -5,22 +5,24 @@ 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=hbLBRcBhFCGqHKwxl9b3R1XXAvBLm0P7N7iYpDOh1CM,38190
+wcgw/client/bash_state/parser/__init__.py,sha256=AnlNSmoQTSoqqlLOLX4P1uXfzc5VGeCGJsGgtisq2zE,207
+wcgw/client/bash_state/parser/bash_statement_parser.py,sha256=9a8vPO1r3_tXmaAcubTQ5UY-NseWlalgm8LZA17LXuY,6058
 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 +54,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.1.dist-info/METADATA,sha256=0uPUOufx9j1789XQHkl43hTwvJ5FD8QSX83bQRmI2Q8,14945
+wcgw-4.1.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+wcgw-4.1.1.dist-info/entry_points.txt,sha256=vd3tj1_Kzfp55LscJ8-6WFMM5hm9cWTfNGFCrWBnH3Q,124
+wcgw-4.1.1.dist-info/licenses/LICENSE,sha256=BvY8xqjOfc3X2qZpGpX3MZEmF-4Dp0LqgKBbT6L_8oI,11142
+wcgw-4.1.1.dist-info/RECORD,,