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

wcgw/client/bash_state/bash_state.py

@@ -6,6 +6,7 @@ import threading
 import time
 import traceback
 from dataclasses import dataclass
+from hashlib import sha256
 from typing import (
     Any,
     Literal,
@@ -232,11 +233,13 @@ class BashState:
         write_if_empty_mode: Optional[WriteIfEmptyMode],
         mode: Optional[Modes],
         use_screen: bool,
-        whitelist_for_overwrite: Optional[set[str]] = None,
+        whitelist_for_overwrite: Optional[dict[str, "FileWhitelistData"]] = None,
     ) -> None:
         self._last_command: str = ""
         self.console = console
         self._cwd = working_dir or os.getcwd()
+        # Store the workspace root separately from the current working directory
+        self._workspace_root = working_dir or os.getcwd()
         self._bash_command_mode: BashCommandMode = bash_command_mode or BashCommandMode(
             "normal_mode", "all"
         )
@@ -245,7 +248,9 @@ class BashState:
             write_if_empty_mode or WriteIfEmptyMode("all")
         )
         self._mode = mode or "wcgw"
-        self._whitelist_for_overwrite: set[str] = whitelist_for_overwrite or set()
+        self._whitelist_for_overwrite: dict[str, FileWhitelistData] = (
+            whitelist_for_overwrite or {}
+        )
         self._bg_expect_thread: Optional[threading.Thread] = None
         self._bg_expect_thread_stop_event = threading.Event()
         self._use_screen = use_screen
@@ -314,9 +319,11 @@ class BashState:
             self._bg_expect_thread_stop_event = threading.Event()
 
     def cleanup(self) -> None:
-        self.close_bg_expect_thread()
-        self._shell.close(True)
-        cleanup_all_screens_with_name(self._shell_id, self.console)
+        try:
+            self.close_bg_expect_thread()
+            self._shell.close(True)
+        finally:
+            cleanup_all_screens_with_name(self._shell_id, self.console)
 
     def __enter__(self) -> "BashState":
         return self
@@ -427,6 +434,15 @@ class BashState:
     def cwd(self) -> str:
         return self._cwd
 
+    @property
+    def workspace_root(self) -> str:
+        """Return the workspace root directory."""
+        return self._workspace_root
+
+    def set_workspace_root(self, workspace_root: str) -> None:
+        """Set the workspace root directory."""
+        self._workspace_root = workspace_root
+
     @property
     def prompt(self) -> str:
         return PROMPT_CONST
@@ -454,20 +470,56 @@ class BashState:
             "bash_command_mode": self._bash_command_mode.serialize(),
             "file_edit_mode": self._file_edit_mode.serialize(),
             "write_if_empty_mode": self._write_if_empty_mode.serialize(),
-            "whitelist_for_overwrite": list(self._whitelist_for_overwrite),
+            "whitelist_for_overwrite": {
+                k: v.serialize() for k, v in self._whitelist_for_overwrite.items()
+            },
             "mode": self._mode,
+            "workspace_root": self._workspace_root,
         }
 
     @staticmethod
     def parse_state(
         state: dict[str, Any],
-    ) -> tuple[BashCommandMode, FileEditMode, WriteIfEmptyMode, Modes, list[str]]:
+    ) -> tuple[
+        BashCommandMode,
+        FileEditMode,
+        WriteIfEmptyMode,
+        Modes,
+        dict[str, "FileWhitelistData"],
+        str,
+    ]:
+        whitelist_state = state["whitelist_for_overwrite"]
+        # Convert serialized whitelist data back to FileWhitelistData objects
+        whitelist_dict = {}
+        if isinstance(whitelist_state, dict):
+            for file_path, data in whitelist_state.items():
+                if isinstance(data, dict) and "file_hash" in data:
+                    # New format
+                    whitelist_dict[file_path] = FileWhitelistData.deserialize(data)
+                else:
+                    # Legacy format (just a hash string)
+                    # Try to get line count from file if it exists, otherwise use a large default
+                    whitelist_dict[file_path] = FileWhitelistData(
+                        file_hash=data if isinstance(data, str) else "",
+                        line_ranges_read=[(1, 1000000)],  # Assume entire file was read
+                        total_lines=1000000,
+                    )
+        else:
+            # Handle really old format if needed
+            whitelist_dict = {
+                k: FileWhitelistData(
+                    file_hash="", line_ranges_read=[(1, 1000000)], total_lines=1000000
+                )
+                for k in whitelist_state
+            }
+
         return (
             BashCommandMode.deserialize(state["bash_command_mode"]),
             FileEditMode.deserialize(state["file_edit_mode"]),
             WriteIfEmptyMode.deserialize(state["write_if_empty_mode"]),
             state["mode"],
-            state["whitelist_for_overwrite"],
+            whitelist_dict,
+            state.get("workspace_root", ""),
         )
 
     def load_state(
@@ -476,15 +528,17 @@ class BashState:
         file_edit_mode: FileEditMode,
         write_if_empty_mode: WriteIfEmptyMode,
         mode: Modes,
-        whitelist_for_overwrite: list[str],
+        whitelist_for_overwrite: dict[str, "FileWhitelistData"],
         cwd: str,
+        workspace_root: str,
     ) -> None:
         """Create a new BashState instance from a serialized state dictionary"""
         self._bash_command_mode = bash_command_mode
         self._cwd = cwd or self._cwd
+        self._workspace_root = workspace_root or cwd or self._workspace_root
         self._file_edit_mode = file_edit_mode
         self._write_if_empty_mode = write_if_empty_mode
-        self._whitelist_for_overwrite = set(whitelist_for_overwrite)
+        self._whitelist_for_overwrite = dict(whitelist_for_overwrite)
         self._mode = mode
         self.reset_shell()
 
@@ -505,17 +559,132 @@ class BashState:
         return "Not pending"
 
     @property
-    def whitelist_for_overwrite(self) -> set[str]:
+    def whitelist_for_overwrite(self) -> dict[str, "FileWhitelistData"]:
         return self._whitelist_for_overwrite
 
-    def add_to_whitelist_for_overwrite(self, file_path: str) -> None:
-        self._whitelist_for_overwrite.add(file_path)
+    def add_to_whitelist_for_overwrite(
+        self, file_paths_with_ranges: dict[str, list[tuple[int, int]]]
+    ) -> None:
+        """
+        Add files to the whitelist for overwrite.
+
+        Args:
+            file_paths_with_ranges: Dictionary mapping file paths to sequences of
+                               (start_line, end_line) tuples representing
+                               the ranges that have been read.
+        """
+        for file_path, ranges in file_paths_with_ranges.items():
+            # Read the file to get its hash and count lines
+            with open(file_path, "rb") as f:
+                file_content = f.read()
+                file_hash = sha256(file_content).hexdigest()
+                total_lines = file_content.count(b"\n") + 1
+
+            # Update or create whitelist entry
+            if file_path in self._whitelist_for_overwrite:
+                # Update existing entry
+                whitelist_data = self._whitelist_for_overwrite[file_path]
+                whitelist_data.file_hash = file_hash
+                whitelist_data.total_lines = total_lines
+                for range_start, range_end in ranges:
+                    whitelist_data.add_range(range_start, range_end)
+            else:
+                # Create new entry
+                self._whitelist_for_overwrite[file_path] = FileWhitelistData(
+                    file_hash=file_hash,
+                    line_ranges_read=list(ranges),
+                    total_lines=total_lines,
+                )
 
     @property
     def pending_output(self) -> str:
         return self._pending_output
 
 
+@dataclass
+class FileWhitelistData:
+    """Data about a file that has been read and can be modified."""
+
+    file_hash: str
+    # List of line ranges that have been read (inclusive start, inclusive end)
+    # E.g., [(1, 10), (20, 30)] means lines 1-10 and 20-30 have been read
+    line_ranges_read: list[tuple[int, int]]
+    # Total number of lines in the file
+    total_lines: int
+
+    def get_percentage_read(self) -> float:
+        """Calculate percentage of file read based on line ranges."""
+        if self.total_lines == 0:
+            return 100.0
+
+        # Count unique lines read
+        lines_read: set[int] = set()
+        for start, end in self.line_ranges_read:
+            lines_read.update(range(start, end + 1))
+
+        return (len(lines_read) / self.total_lines) * 100.0
+
+    def is_read_enough(self) -> bool:
+        """Check if enough of the file has been read (>=99%)"""
+        return self.get_percentage_read() >= 99
+
+    def get_unread_ranges(self) -> list[tuple[int, int]]:
+        """Return a list of line ranges (start, end) that haven't been read yet.
+
+        Returns line ranges as tuples of (start_line, end_line) in 1-indexed format.
+        If the whole file has been read, returns an empty list.
+        """
+        if self.total_lines == 0:
+            return []
+
+        # First collect all lines that have been read
+        lines_read: set[int] = set()
+        for start, end in self.line_ranges_read:
+            lines_read.update(range(start, end + 1))
+
+        # Generate unread ranges from the gaps
+        unread_ranges: list[tuple[int, int]] = []
+        start_range = None
+
+        for i in range(1, self.total_lines + 1):
+            if i not in lines_read:
+                if start_range is None:
+                    start_range = i
+            elif start_range is not None:
+                # End of an unread range
+                unread_ranges.append((start_range, i - 1))
+                start_range = None
+
+        # Don't forget the last range if it extends to the end of the file
+        if start_range is not None:
+            unread_ranges.append((start_range, self.total_lines))
+
+        return unread_ranges
+
+    def add_range(self, start: int, end: int) -> None:
+        """Add a new range of lines that have been read."""
+        # Merge with existing ranges if possible
+        self.line_ranges_read.append((start, end))
+        # Could add range merging logic here for optimization
+
+    def serialize(self) -> dict[str, Any]:
+        """Convert to a serializable dictionary."""
+        return {
+            "file_hash": self.file_hash,
+            "line_ranges_read": self.line_ranges_read,
+            "total_lines": self.total_lines,
+        }
+
+    @classmethod
+    def deserialize(cls, data: dict[str, Any]) -> "FileWhitelistData":
+        """Create from a serialized dictionary."""
+        return cls(
+            file_hash=data.get("file_hash", ""),
+            line_ranges_read=data.get("line_ranges_read", []),
+            total_lines=data.get("total_lines", 0),
+        )
+
+
 WAITING_INPUT_MESSAGE = """A command is already running. NOTE: You can't run multiple shell sessions, likely a previous program hasn't exited. 
 1. Get its output using status check.
 2. Use `send_ascii` or `send_specials` to give inputs to the running program OR

wcgw/client/diff-instructions.txt

@@ -1,17 +1,40 @@
 
 Instructions for editing files.
+# Example
+## Input file
+```
+import numpy as np
+from impls import impl1, impl2
+
+def hello():
+    "print a greeting"
 
+    print("hello")
 
-Only edit the files using the following SEARCH/REPLACE blocks.
+def call_hello():
+    "call hello"
+
+    hello()
+    print("Called")
+    impl1()
+    hello()
+    impl2()
+
+```
+## Edit format on the input file
 ```
-file_edit_using_search_replace_blocks="""
+<<<<<<< SEARCH
+from impls import impl1, impl2
+=======
+from impls import impl1, impl2
+from hello import hello as hello_renamed
+>>>>>>> REPLACE
 <<<<<<< SEARCH
 def hello():
     "print a greeting"
 
     print("hello")
 =======
-from hello import hello as hello_renamed
 >>>>>>> REPLACE
 <<<<<<< SEARCH
 def call_hello():
@@ -33,26 +56,17 @@ def call_hello_renamed():
     hello_renamed()
     impl2()
 >>>>>>> REPLACE
-"""
 ```
 
 # *SEARCH/REPLACE block* Rules:
-
-Every *SEARCH/REPLACE block* must use this format:
-1. The start of match block: <<<<<<< SEARCH
-2. A contiguous chunk of lines to do exact match for in the existing source code
-3. The dividing line: =======
-4. The lines to replace into the source code
-5. The end of the replace block: >>>>>>> REPLACE
-
 Every "<<<<<<< SEARCH" section must *EXACTLY MATCH* the existing file content, character for character, including all comments, docstrings, whitespaces, etc.
 
 Including multiple unique *SEARCH/REPLACE* blocks if needed.
-Include enough lines in each SEARCH section to uniquely match each set of lines that need to change.
+Include enough and only enough lines in each SEARCH section to uniquely match each set of lines that need to change.
 
 Keep *SEARCH/REPLACE* blocks concise.
 Break large *SEARCH/REPLACE* blocks into a series of smaller blocks that each change a small portion of the file.
-Include just the changing lines, and a few surrounding lines if needed for uniqueness.
-Do not include long runs of unchanging lines in *SEARCH/REPLACE* blocks.
+Include just the changing lines, and a few surrounding lines (2-3 lines) if needed for uniqueness.
+Other than for uniqueness, avoid including those lines which do not change in search (and replace) blocks. Target 2-3 non trivial extra lines per block.
 
 Preserve leading spaces and indentations in both SEARCH and REPLACE blocks.

wcgw/client/file_ops/diff_edit.py

@@ -45,11 +45,12 @@ class FileEditOutput:
                     if tol.severity_cat == "WARNING":
                         warnings.add(tol.error_name)
                     elif tol.severity_cat == "ERROR":
+                        search__ = "\n".join(search_)
                         errors.append(f"""
 Got error while processing the following search block:
 ---
 ```
-{"\n".join(search_)}
+{search__}
 ```
 ---
 Error:

wcgw/client/file_ops/search_replace.py

@@ -5,67 +5,79 @@ from .diff_edit import FileEditInput, FileEditOutput, SearchReplaceMatchError
 
 # Global regex patterns
 SEARCH_MARKER = re.compile(r"^<<<<<<+\s*SEARCH\s*$")
-DIVIDER_MARKER = re.compile(r"^======*\s*$") 
+DIVIDER_MARKER = re.compile(r"^======*\s*$")
 REPLACE_MARKER = re.compile(r"^>>>>>>+\s*REPLACE\s*$")
 
+
 class SearchReplaceSyntaxError(Exception):
     def __init__(self, message: str):
-        message =f"""Got syntax error while parsing search replace blocks:
+        message = f"""Got syntax error while parsing search replace blocks:
 {message}
 ---
 
 Make sure blocks are in correct sequence, and the markers are in separate lines:
 
-<{'<<<<<< SEARCH'}
+<{"<<<<<< SEARCH"}
     example old
 =======
     example new
->{'>>>>>> REPLACE'}
+>{">>>>>> REPLACE"}
  
 """
         super().__init__(message)
 
+
 def search_replace_edit(
     lines: list[str], original_content: str, logger: Callable[[str], object]
 ) -> tuple[str, str]:
     if not lines:
         raise SearchReplaceSyntaxError("Error: No input to search replace edit")
-    
+
     original_lines = original_content.split("\n")
     n_lines = len(lines)
     i = 0
     search_replace_blocks = list[tuple[list[str], list[str]]]()
-    
+
     while i < n_lines:
         if SEARCH_MARKER.match(lines[i]):
             line_num = i + 1
             search_block = []
             i += 1
-            
+
             while i < n_lines and not DIVIDER_MARKER.match(lines[i]):
                 if SEARCH_MARKER.match(lines[i]) or REPLACE_MARKER.match(lines[i]):
-                    raise SearchReplaceSyntaxError(f"Line {i+1}: Found stray marker in SEARCH block: {lines[i]}")
+                    raise SearchReplaceSyntaxError(
+                        f"Line {i + 1}: Found stray marker in SEARCH block: {lines[i]}"
+                    )
                 search_block.append(lines[i])
                 i += 1
-            
+
             if i >= n_lines:
-                raise SearchReplaceSyntaxError(f"Line {line_num}: Unclosed SEARCH block - missing ======= marker")
-            
+                raise SearchReplaceSyntaxError(
+                    f"Line {line_num}: Unclosed SEARCH block - missing ======= marker"
+                )
+
             if not search_block:
-                raise SearchReplaceSyntaxError(f"Line {line_num}: SEARCH block cannot be empty")
-            
+                raise SearchReplaceSyntaxError(
+                    f"Line {line_num}: SEARCH block cannot be empty"
+                )
+
             i += 1
             replace_block = []
-            
+
             while i < n_lines and not REPLACE_MARKER.match(lines[i]):
                 if SEARCH_MARKER.match(lines[i]) or DIVIDER_MARKER.match(lines[i]):
-                    raise SearchReplaceSyntaxError(f"Line {i+1}: Found stray marker in REPLACE block: {lines[i]}")
+                    raise SearchReplaceSyntaxError(
+                        f"Line {i + 1}: Found stray marker in REPLACE block: {lines[i]}"
+                    )
                 replace_block.append(lines[i])
                 i += 1
-            
+
             if i >= n_lines:
-                raise SearchReplaceSyntaxError(f"Line {line_num}: Unclosed block - missing REPLACE marker")
-            
+                raise SearchReplaceSyntaxError(
+                    f"Line {line_num}: Unclosed block - missing REPLACE marker"
+                )
+
             i += 1
 
             for line in search_block:
@@ -78,7 +90,9 @@ def search_replace_edit(
             search_replace_blocks.append((search_block, replace_block))
         else:
             if REPLACE_MARKER.match(lines[i]) or DIVIDER_MARKER.match(lines[i]):
-                raise SearchReplaceSyntaxError(f"Line {i+1}: Found stray marker outside block: {lines[i]}")
+                raise SearchReplaceSyntaxError(
+                    f"Line {i + 1}: Found stray marker outside block: {lines[i]}"
+                )
             i += 1
 
     if not search_replace_blocks:
@@ -121,11 +135,12 @@ def greedy_context_replace(
     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])
             raise SearchReplaceMatchError(f"""
     The following block matched more than once:
     ---
     ```
-    {'\n'.join(current_blocks[-1][0])}
+    {matches_}
     ```
     """)
 
@@ -140,11 +155,12 @@ def 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:
         ---
         ```
-        {'\n'.join(current_blocks[-1][0])}
+        {ma_more}
         ```
         """)
 

wcgw/client/memory.py

@@ -2,7 +2,7 @@ import json
 import os
 import re
 import shlex
-from typing import Any, Callable, Optional
+from typing import Any, Callable, Optional, TypeVar
 
 from ..types_ import ContextSave
 
@@ -59,7 +59,10 @@ def save_memory(
     return memory_file_full
 
 
-def load_memory[T](
+T = TypeVar("T")
+
+
+def load_memory(
     task_id: str,
     max_tokens: Optional[int],
     encoder: Callable[[str], list[T]],

wcgw/client/modes.py

@@ -55,38 +55,38 @@ You are now running in "code_writer" mode.
 """
 
     path_prompt = """
-    - You are allowed to run FileEdit in the provided repository only.
+    - You are allowed to edit files in the provided repository only.
     """
 
     if allowed_file_edit_globs != "all":
         if allowed_file_edit_globs:
             path_prompt = f"""
-    - You are allowed to run FileEdit for files matching only the following globs: {", ".join(allowed_file_edit_globs)}
+    - You are allowed to edit files for files matching only the following globs: {", ".join(allowed_file_edit_globs)}
 """
         else:
             path_prompt = """
-    - You are not allowed to run FileEdit.
+    - You are not allowed to edit files.
 """
     base += path_prompt
 
     path_prompt = """
-    - You are allowed to run WriteIfEmpty in the provided repository only.
+    - You are allowed to write files in the provided repository only.
     """
 
     if all_write_new_globs != "all":
         if all_write_new_globs:
             path_prompt = f"""
-    - You are allowed to run WriteIfEmpty files matching only the following globs: {", ".join(allowed_file_edit_globs)}
+    - You are allowed to write files files matching only the following globs: {", ".join(allowed_file_edit_globs)}
 """
         else:
             path_prompt = """
-    - You are not allowed to run WriteIfEmpty.
+    - You are not allowed to write files.
 """
     base += path_prompt
 
     run_command_common = """
     - Do not use Ctrl-c 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.
     - Do not provide code snippets unless asked by the user, instead directly add/edit the code.
     - You should use the provided bash execution, reading and writing file tools to complete objective.
     - First understand about the project by getting the folder structure (ignoring .git, node_modules, venv, etc.)

wcgw/client/repo_ops/display_tree.py

@@ -33,13 +33,13 @@ class DirectoryTree:
         abs_path = self.root / rel_path
 
         if not abs_path.exists():
-            raise ValueError(f"Path {rel_path} does not exist")
+            return
 
         if not abs_path.is_file():
-            raise ValueError(f"Path {rel_path} is not a file")
+            return
 
         if not str(abs_path).startswith(str(self.root)):
-            raise ValueError(f"Path {rel_path} is outside root directory")
+            return
 
         self.expanded_files.add(abs_path)