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

wcgw/client/file_ops/search_replace.py

@@ -1,71 +1,83 @@
 import re
-from typing import Callable
+from typing import Callable, Optional
 
 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:
@@ -86,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"
@@ -100,61 +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:
+        # 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:
-    ---
-    ```
-    {'\n'.join(current_blocks[-1][0])}
-    ```
+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:
-                raise Exception(f"""
-        The following block matched more than once:
-        ---
-        ```
-        {'\n'.join(current_blocks[-1][0])}
-        ```
-        """)
-
-    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/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.)
@@ -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/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)
 

wcgw/client/repo_ops/file_stats.py

@@ -0,0 +1,152 @@
+import hashlib
+import json
+import os
+import sys
+from typing import Any, Callable, Dict, TypeVar, cast
+
+T = TypeVar("T")  # Type variable for generic functions
+F = TypeVar("F", bound=Callable[..., Any])  # Type variable for decorated functions
+
+
+class FileStats:
+    """Track read, edit, and write counts for a single file."""
+
+    def __init__(self) -> None:
+        self.read_count: int = 0
+        self.edit_count: int = 0
+        self.write_count: int = 0
+
+    def increment_read(self) -> None:
+        """Increment the read counter."""
+        self.read_count += 1
+
+    def increment_edit(self) -> None:
+        """Increment the edit counter."""
+        self.edit_count += 1
+
+    def increment_write(self) -> None:
+        """Increment the write counter."""
+        self.write_count += 1
+
+    def to_dict(self) -> Dict[str, int]:
+        """Convert to a dictionary for serialization."""
+        return {
+            "read_count": self.read_count,
+            "edit_count": self.edit_count,
+            "write_count": self.write_count,
+        }
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "FileStats":
+        """Create from a serialized dictionary."""
+        stats = cls()
+        stats.read_count = data.get("read_count", 0)
+        stats.edit_count = data.get("edit_count", 0)
+        stats.write_count = data.get("write_count", 0)
+        return stats
+
+
+class WorkspaceStats:
+    """Track file operations statistics for an entire workspace."""
+
+    def __init__(self) -> None:
+        self.files: Dict[str, FileStats] = {}  # filepath -> FileStats
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to a dictionary for serialization."""
+        return {"files": {k: v.to_dict() for k, v in self.files.items()}}
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "WorkspaceStats":
+        """Create from a serialized dictionary."""
+        stats = cls()
+        files_data = data.get("files", {})
+        stats.files = {k: FileStats.from_dict(v) for k, v in files_data.items()}
+        return stats
+
+
+def safe_stats_operation(func: F) -> F:
+    """
+    Decorator to safely perform stats operations without affecting core functionality.
+    If an exception occurs, it logs the error but allows the program to continue.
+    """
+
+    def wrapper(*args: Any, **kwargs: Any) -> Any:
+        try:
+            return func(*args, **kwargs)
+        except Exception as e:
+            # Log the error but continue with the operation
+            print(f"Warning: Stats tracking error - {e}", file=sys.stderr)
+            return None
+
+    # This is a workaround for proper typing with decorators
+    return cast(F, wrapper)
+
+
+def get_stats_path(workspace_path: str) -> str:
+    """
+    Get the path to the stats file for a workspace using a hash-based approach.
+
+    Args:
+        workspace_path: The full path of the workspace directory.
+
+    Returns:
+        The path to the stats file.
+    """
+    # Normalize the path
+    workspace_path = os.path.normpath(os.path.expanduser(workspace_path))
+
+    # Get the basename of the workspace path for readability
+    workspace_name = os.path.basename(workspace_path)
+    if not workspace_name:  # In case of root directory
+        workspace_name = "root"
+
+    # Create a hash of the full path
+    path_hash = hashlib.md5(workspace_path.encode()).hexdigest()
+
+    # Combine to create a unique identifier that's still somewhat readable
+    filename = f"{workspace_name}_{path_hash}.json"
+
+    # Create directory if it doesn't exist
+    xdg_data_dir = os.environ.get("XDG_DATA_HOME", os.path.expanduser("~/.local/share"))
+    stats_dir = os.path.join(xdg_data_dir, "wcgw/workspace_stats")
+    os.makedirs(stats_dir, exist_ok=True)
+
+    return os.path.join(stats_dir, filename)
+
+
+@safe_stats_operation
+def load_workspace_stats(workspace_path: str) -> WorkspaceStats:
+    """
+    Load the stats for a workspace, or create empty stats if not exists.
+
+    Args:
+        workspace_path: The full path of the workspace directory.
+
+    Returns:
+        WorkspaceStats object containing file operation statistics.
+    """
+    stats_path = get_stats_path(workspace_path)
+    if os.path.exists(stats_path):
+        try:
+            with open(stats_path, "r") as f:
+                return WorkspaceStats.from_dict(json.load(f))
+        except (json.JSONDecodeError, KeyError, ValueError):
+            # Handle corrupted file
+            return WorkspaceStats()
+    else:
+        return WorkspaceStats()
+
+
+@safe_stats_operation
+def save_workspace_stats(workspace_path: str, stats: WorkspaceStats) -> None:
+    """
+    Save the stats for a workspace.
+
+    Args:
+        workspace_path: The full path of the workspace directory.
+        stats: WorkspaceStats object to save.
+    """
+    stats_path = get_stats_path(workspace_path)
+    with open(stats_path, "w") as f:
+        json.dump(stats.to_dict(), f, indent=2)