wcgw 5.1.1__tar.gz → 5.1.3__tar.gz

{wcgw-5.1.1 → wcgw-5.1.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wcgw
-Version: 5.1.1
+Version: 5.1.3
 Summary: Shell and coding agent for Claude and other mcp clients
 Project-URL: Homepage, https://github.com/rusiaaman/wcgw
 Author-email: Aman Rusia <gapypi@arcfu.com>

{wcgw-5.1.1 → wcgw-5.1.3}/pyproject.toml

@@ -1,7 +1,7 @@
 [project]
 authors = [{ name = "Aman Rusia", email = "gapypi@arcfu.com" }]
 name = "wcgw"
-version = "5.1.1"
+version = "5.1.3"
 description = "Shell and coding agent for Claude and other mcp clients"
 readme = "README.md"
 requires-python = ">=3.11"

{wcgw-5.1.1 → wcgw-5.1.3}/src/wcgw/client/bash_state/bash_state.py

@@ -342,30 +342,30 @@ def get_bash_state_dir_xdg() -> str:
     return bash_state_dir
 
 
-def generate_chat_id() -> str:
-    """Generate a random 4-digit chat ID."""
+def generate_thread_id() -> str:
+    """Generate a random 4-digit thread_id."""
     return f"i{random.randint(1000, 9999)}"
 
 
-def save_bash_state_by_id(chat_id: str, bash_state_dict: dict[str, Any]) -> None:
-    """Save bash state to XDG directory with the given chat ID."""
-    if not chat_id:
+def save_bash_state_by_id(thread_id: str, bash_state_dict: dict[str, Any]) -> None:
+    """Save bash state to XDG directory with the given thread_id."""
+    if not thread_id:
         return
 
     bash_state_dir = get_bash_state_dir_xdg()
-    state_file = os.path.join(bash_state_dir, f"{chat_id}_bash_state.json")
+    state_file = os.path.join(bash_state_dir, f"{thread_id}_bash_state.json")
 
     with open(state_file, "w") as f:
         json.dump(bash_state_dict, f, indent=2)
 
 
-def load_bash_state_by_id(chat_id: str) -> Optional[dict[str, Any]]:
-    """Load bash state from XDG directory with the given chat ID."""
-    if not chat_id:
+def load_bash_state_by_id(thread_id: str) -> Optional[dict[str, Any]]:
+    """Load bash state from XDG directory with the given thread_id."""
+    if not thread_id:
         return None
 
     bash_state_dir = get_bash_state_dir_xdg()
-    state_file = os.path.join(bash_state_dir, f"{chat_id}_bash_state.json")
+    state_file = os.path.join(bash_state_dir, f"{thread_id}_bash_state.json")
 
     if not os.path.exists(state_file):
         return None
@@ -376,7 +376,7 @@ def load_bash_state_by_id(chat_id: str) -> Optional[dict[str, Any]]:
 
 class BashState:
     _use_screen: bool
-    _current_chat_id: str
+    _current_thread_id: str
 
     def __init__(
         self,
@@ -388,7 +388,7 @@ class BashState:
         mode: Optional[Modes],
         use_screen: bool,
         whitelist_for_overwrite: Optional[dict[str, "FileWhitelistData"]] = None,
-        chat_id: Optional[str] = None,
+        thread_id: Optional[str] = None,
     ) -> None:
         self._last_command: str = ""
         self.console = console
@@ -406,8 +406,10 @@ class BashState:
         self._whitelist_for_overwrite: dict[str, FileWhitelistData] = (
             whitelist_for_overwrite or {}
         )
-        # Always ensure we have a chat ID
-        self._current_chat_id = chat_id if chat_id is not None else generate_chat_id()
+        # Always ensure we have a thread_id
+        self._current_thread_id = (
+            thread_id if thread_id is not None else generate_thread_id()
+        )
         self._bg_expect_thread: Optional[threading.Thread] = None
         self._bg_expect_thread_stop_event = threading.Event()
         self._use_screen = use_screen
@@ -632,22 +634,22 @@ class BashState:
         self._init_shell()
 
     @property
-    def current_chat_id(self) -> str:
-        """Get the current chat ID."""
-        return self._current_chat_id
+    def current_thread_id(self) -> str:
+        """Get the current thread_id."""
+        return self._current_thread_id
 
-    def load_state_from_chat_id(self, chat_id: str) -> bool:
+    def load_state_from_thread_id(self, thread_id: str) -> bool:
         """
-        Load bash state from a chat ID.
+        Load bash state from a thread_id.
 
         Args:
-            chat_id: The chat ID to load state from
+            thread_id: The thread_id to load state from
 
         Returns:
             bool: True if state was successfully loaded, False otherwise
         """
         # Try to load state from disk
-        loaded_state = load_bash_state_by_id(chat_id)
+        loaded_state = load_bash_state_by_id(thread_id)
         if not loaded_state:
             return False
 
@@ -661,7 +663,7 @@ class BashState:
             parsed_state[4],
             parsed_state[5],
             parsed_state[5],
-            chat_id,
+            thread_id,
         )
         return True
 
@@ -676,13 +678,13 @@ class BashState:
             },
             "mode": self._mode,
             "workspace_root": self._workspace_root,
-            "chat_id": self._current_chat_id,
+            "chat_id": self._current_thread_id,
         }
 
     def save_state_to_disk(self) -> None:
-        """Save the current bash state to disk using the chat ID."""
+        """Save the current bash state to disk using the thread_id."""
         state_dict = self.serialize()
-        save_bash_state_by_id(self._current_chat_id, state_dict)
+        save_bash_state_by_id(self._current_thread_id, state_dict)
 
     @staticmethod
     def parse_state(
@@ -721,10 +723,10 @@ class BashState:
                 for k in whitelist_state
             }
 
-        # Get the chat_id from state, or generate a new one if not present
-        chat_id = state.get("chat_id")
-        if chat_id is None:
-            chat_id = generate_chat_id()
+        # Get the thread_id from state, or generate a new one if not present
+        thread_id = state.get("chat_id")
+        if thread_id is None:
+            thread_id = generate_thread_id()
 
         return (
             BashCommandMode.deserialize(state["bash_command_mode"]),
@@ -733,7 +735,7 @@ class BashState:
             state["mode"],
             whitelist_dict,
             state.get("workspace_root", ""),
-            chat_id,
+            thread_id,
         )
 
     def load_state(
@@ -745,7 +747,7 @@ class BashState:
         whitelist_for_overwrite: dict[str, "FileWhitelistData"],
         cwd: str,
         workspace_root: str,
-        chat_id: str,
+        thread_id: str,
     ) -> None:
         """Create a new BashState instance from a serialized state dictionary"""
         self._bash_command_mode = bash_command_mode
@@ -755,7 +757,7 @@ class BashState:
         self._write_if_empty_mode = write_if_empty_mode
         self._whitelist_for_overwrite = dict(whitelist_for_overwrite)
         self._mode = mode
-        self._current_chat_id = chat_id
+        self._current_thread_id = thread_id
         self.reset_shell()
 
         # Save state to disk after loading
@@ -1000,12 +1002,12 @@ def execute_bash(
     timeout_s: Optional[float],
 ) -> tuple[str, float]:
     try:
-        # Check if the chat ID matches current
-        if bash_arg.chat_id != bash_state.current_chat_id:
-            # Try to load state from the chat ID
-            if not bash_state.load_state_from_chat_id(bash_arg.chat_id):
+        # Check if the thread_id matches current
+        if bash_arg.thread_id != bash_state.current_thread_id:
+            # Try to load state from the thread_id
+            if not bash_state.load_state_from_thread_id(bash_arg.thread_id):
                 return (
-                    f"Error: No saved bash state found for chat ID {bash_arg.chat_id}. Please initialize first with this ID.",
+                    f"Error: No saved bash state found for thread_id {bash_arg.thread_id}. Please initialize first with this ID.",
                     0.0,
                 )
 

{wcgw-5.1.1 → wcgw-5.1.3}/src/wcgw/client/tool_prompts.py

@@ -74,12 +74,10 @@ 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
-- If percentage_to_change <= 50, file_content_or_search_replace_blocks should be search/replace blocks.
-
+- If percentage_to_change > 50, provide full file content in text_or_search_replace_blocks
+- If percentage_to_change <= 50, text_or_search_replace_blocks should be search/replace blocks.
 """
         + diffinstructions,
         annotations=ToolAnnotations(

{wcgw-5.1.1 → wcgw-5.1.3}/src/wcgw/client/tools.py

@@ -31,7 +31,7 @@ from syntax_checker import check_syntax
 from ..client.bash_state.bash_state import (
     BashState,
     execute_bash,
-    generate_chat_id,
+    generate_thread_id,
     get_status,
 )
 from ..client.repo_ops.file_stats import (
@@ -103,7 +103,7 @@ def initialize(
     coding_max_tokens: Optional[int],
     noncoding_max_tokens: Optional[int],
     mode: ModesConfig,
-    chat_id: str,
+    thread_id: str,
 ) -> tuple[str, Context, dict[str, list[tuple[int, int]]]]:
     # Expand the workspace path
     any_workspace_path = expand_user(any_workspace_path)
@@ -113,16 +113,16 @@ def initialize(
     loaded_state = None
 
     # For workspace/mode changes, ensure we're using an existing state if possible
-    if type != "first_call" and chat_id != context.bash_state.current_chat_id:
-        # Try to load state from the chat ID
-        if not context.bash_state.load_state_from_chat_id(chat_id):
+    if type != "first_call" and thread_id != context.bash_state.current_thread_id:
+        # Try to load state from the thread_id
+        if not context.bash_state.load_state_from_thread_id(thread_id):
             return (
-                f"Error: No saved bash state found for chat ID {chat_id}. Please re-initialize to get a new id or use correct id.",
+                f"Error: No saved bash state found for thread_id {thread_id}. Please re-initialize to get a new id or use correct id.",
                 context,
                 {},
             )
     del (
-        chat_id
+        thread_id
     )  # No use other than loading correct state before doing actual tool related stuff
 
     # Handle task resumption - this applies only to first_call
@@ -181,10 +181,10 @@ def initialize(
             workspace_root = (
                 str(folder_to_start) if folder_to_start else parsed_state[5]
             )
-            loaded_chat_id = parsed_state[6] if len(parsed_state) > 6 else None
+            loaded_thread_id = parsed_state[6] if len(parsed_state) > 6 else None
 
-            if not loaded_chat_id:
-                loaded_chat_id = context.bash_state.current_chat_id
+            if not loaded_thread_id:
+                loaded_thread_id = context.bash_state.current_thread_id
 
             if mode == "wcgw":
                 context.bash_state.load_state(
@@ -195,7 +195,7 @@ def initialize(
                     {**parsed_state[4], **context.bash_state.whitelist_for_overwrite},
                     str(folder_to_start) if folder_to_start else workspace_root,
                     workspace_root,
-                    loaded_chat_id,
+                    loaded_thread_id,
                 )
             else:
                 state = modes_to_state(mode)
@@ -207,7 +207,7 @@ def initialize(
                     {**parsed_state[4], **context.bash_state.whitelist_for_overwrite},
                     str(folder_to_start) if folder_to_start else workspace_root,
                     workspace_root,
-                    loaded_chat_id,
+                    loaded_thread_id,
                 )
         except ValueError:
             context.console.print(traceback.format_exc())
@@ -217,10 +217,10 @@ def initialize(
     else:
         mode_changed = is_mode_change(mode, context.bash_state)
         state = modes_to_state(mode)
-        new_chat_id = context.bash_state.current_chat_id
+        new_thread_id = context.bash_state.current_thread_id
         if type == "first_call":
-            # Recreate chat id
-            new_chat_id = generate_chat_id()
+            # Recreate thread_id
+            new_thread_id = generate_thread_id()
         # Use the provided workspace path as the workspace root
         context.bash_state.load_state(
             state[0],
@@ -230,7 +230,7 @@ def initialize(
             dict(context.bash_state.whitelist_for_overwrite),
             str(folder_to_start) if folder_to_start else "",
             str(folder_to_start) if folder_to_start else "",
-            new_chat_id,
+            new_thread_id,
         )
         if type == "first_call" or mode_changed:
             mode_prompt = get_mode_prompt(context)
@@ -273,6 +273,8 @@ def initialize(
     uname_machine = os.uname().machine
 
     output = f"""
+Use thread_id={context.bash_state.current_thread_id} for all wcgw tool calls which take that.
+---
 {mode_prompt}
 
 # Environment
@@ -281,17 +283,16 @@ Machine: {uname_machine}
 Initialized in directory (also cwd): {context.bash_state.cwd}
 User home directory: {expanduser("~")}
 
-{repo_context}
-
 {alignment_context}
-{initial_files_context}
+{repo_context}
 
 ---
 
 {memory}
-
 ---
-Use chat_id={context.bash_state.current_chat_id} for all wcgw tool calls which take that.
+
+{initial_files_context}
+
 """
 
     return output, context, initial_paths_with_ranges
@@ -313,13 +314,13 @@ def reset_wcgw(
     starting_directory: str,
     mode_name: Optional[Modes],
     change_mode: ModesConfig,
-    chat_id: str,
+    thread_id: str,
 ) -> str:
-    # Load state for this chat_id before proceeding with mode/directory changes
-    if chat_id != context.bash_state.current_chat_id:
-        # Try to load state from the chat ID
-        if not context.bash_state.load_state_from_chat_id(chat_id):
-            return f"Error: No saved bash state found for chat ID {chat_id}. Please re-initialize to get a new id or use correct id."
+    # Load state for this thread_id before proceeding with mode/directory changes
+    if thread_id != context.bash_state.current_thread_id:
+        # Try to load state from the thread_id
+        if not context.bash_state.load_state_from_thread_id(thread_id):
+            return f"Error: No saved bash state found for thread_id {thread_id}. Please re-initialize to get a new id or use correct id."
     if mode_name:
         # update modes if they're relative
         if isinstance(change_mode, CodeWriterMode):
@@ -332,7 +333,7 @@ def reset_wcgw(
             change_mode
         )
 
-        # Reset shell with new mode, using the provided chat ID
+        # Reset shell with new mode, using the provided thread_id
         context.bash_state.load_state(
             bash_command_mode,
             file_edit_mode,
@@ -341,7 +342,7 @@ def reset_wcgw(
             dict(context.bash_state.whitelist_for_overwrite),
             starting_directory,
             starting_directory,
-            chat_id,
+            thread_id,
         )
         mode_prompt = get_mode_prompt(context)
         return (
@@ -357,7 +358,7 @@ def reset_wcgw(
         write_if_empty_mode = context.bash_state.write_if_empty_mode
         mode = context.bash_state.mode
 
-        # Reload state with new directory, using the provided chat ID
+        # Reload state with new directory, using the provided thread_id
         context.bash_state.load_state(
             bash_command_mode,
             file_edit_mode,
@@ -366,7 +367,7 @@ def reset_wcgw(
             dict(context.bash_state.whitelist_for_overwrite),
             starting_directory,
             starting_directory,
-            chat_id,
+            thread_id,
         )
     return "Reset successful" + get_status(context.bash_state)
 
@@ -475,7 +476,7 @@ def get_context_for_errors(
         ntokens = len(default_enc.encoder(context))
         if ntokens > max_tokens:
             return "Please re-read the file to understand the context"
-    return f"Here's relevant snippet from the file where the syntax errors occured:\n```\n{context}\n```"
+    return f"Here's relevant snippet from the file where the syntax errors occured:\n<snippet>\n{context}\n</snippet>"
 
 
 def write_file(
@@ -556,7 +557,7 @@ def write_file(
                     return (
                         (
                             msg
-                            + f"Here's the existing file:\n```\n{file_content_str}\n{final_message}\n```"
+                            + f"Here's the existing file:\n<wcgw:file>\n{file_content_str}\n{final_message}\n</wcgw:file>"
                         ),
                         {path_: file_ranges},
                     )
@@ -578,7 +579,7 @@ def write_file(
                     return (
                         (
                             msg
-                            + f"Here's the existing file:\n```\n{file_content_str}\n```\n{final_message}"
+                            + f"Here's the existing file:\n<wcgw:file>\n{file_content_str}\n</wcgw:file>\n{final_message}"
                         ),
                         {path_: file_ranges},
                     )
@@ -819,12 +820,14 @@ def file_writing(
     If percentage_changed > 50%, treat content as direct file content.
     Otherwise, treat content as search/replace blocks.
     """
-    # Check if the chat ID matches current
-    if file_writing_args.chat_id != context.bash_state.current_chat_id:
-        # Try to load state from the chat ID
-        if not context.bash_state.load_state_from_chat_id(file_writing_args.chat_id):
+    # Check if the thread_id matches current
+    if file_writing_args.thread_id != context.bash_state.current_thread_id:
+        # Try to load state from the thread_id
+        if not context.bash_state.load_state_from_thread_id(
+            file_writing_args.thread_id
+        ):
             return (
-                f"Error: No saved bash state found for chat ID {file_writing_args.chat_id}. Please re-initialize to get a new id or use correct id.",
+                f"Error: No saved bash state found for thread_id {file_writing_args.thread_id}. Please re-initialize to get a new id or use correct id.",
                 {},
             )
 
@@ -837,14 +840,14 @@ def file_writing(
         )
 
     # If file doesn't exist, always use direct file_content mode
-    content = file_writing_args.file_content_or_search_replace_blocks
+    content = file_writing_args.text_or_search_replace_blocks
 
     if not _is_edit(content, file_writing_args.percentage_to_change):
         # Use direct content mode (same as WriteIfEmpty)
         result, paths = write_file(
             WriteIfEmpty(
                 file_path=path_,
-                file_content=file_writing_args.file_content_or_search_replace_blocks,
+                file_content=file_writing_args.text_or_search_replace_blocks,
             ),
             True,
             coding_max_tokens,
@@ -857,7 +860,7 @@ def file_writing(
         result, paths = do_diff_edit(
             FileEdit(
                 file_path=path_,
-                file_edit_using_search_replace_blocks=file_writing_args.file_content_or_search_replace_blocks,
+                file_edit_using_search_replace_blocks=file_writing_args.text_or_search_replace_blocks,
             ),
             coding_max_tokens,
             noncoding_max_tokens,
@@ -1012,7 +1015,7 @@ def get_tool_output(
             )
             workspace_path = workspace_path if os.path.exists(workspace_path) else ""
 
-            # For these specific operations, chat_id is required
+            # For these specific operations, thread_id is required
             output = (
                 reset_wcgw(
                     context,
@@ -1021,7 +1024,7 @@ def get_tool_output(
                     if is_mode_change(arg.mode, context.bash_state)
                     else None,
                     arg.mode,
-                    arg.chat_id,
+                    arg.thread_id,
                 ),
                 0.0,
             )
@@ -1035,7 +1038,7 @@ def get_tool_output(
                 coding_max_tokens,
                 noncoding_max_tokens,
                 arg.mode,
-                arg.chat_id,
+                arg.thread_id,
             )
             output = output_, 0.0
             # Since init_paths is already a dictionary mapping file paths to line ranges,
@@ -1164,25 +1167,27 @@ def read_files(
             continue
 
         if coding_max_tokens:
-            coding_max_tokens = coding_max_tokens - tokens
+            coding_max_tokens = max(0, coding_max_tokens - tokens)
         if noncoding_max_tokens:
-            noncoding_max_tokens = noncoding_max_tokens - tokens
+            noncoding_max_tokens = max(0, noncoding_max_tokens - tokens)
 
         range_formatted = range_format(start_line_num, end_line_num)
-        message += f"\n{file}{range_formatted}\n```\n{content}\n"
+        message += f'\n<wcgw:file path="{file}{range_formatted}">\n{content}\n'
 
-        # Check if we've hit either token limit
+        if not truncated:
+            message += "</wcgw:file>"
+
+        # Check if we've hit both token limit
         if (
             truncated
             or (coding_max_tokens is not None and coding_max_tokens <= 0)
-            or (noncoding_max_tokens is not None and noncoding_max_tokens <= 0)
+            and (noncoding_max_tokens is not None and noncoding_max_tokens <= 0)
         ):
             not_reading = file_paths[i + 1 :]
             if not_reading:
                 message += f"\nNot reading the rest of the files: {', '.join(not_reading)} due to token limit, please call again"
             break
-        else:
-            message += "```"
+
     return message, file_ranges_dict, truncated
 
 
@@ -1313,7 +1318,7 @@ if __name__ == "__main__":
                     task_id_to_resume="",
                     mode_name="wcgw",
                     code_writer_config=None,
-                    chat_id="",
+                    thread_id="",
                 ),
                 default_enc,
                 0,
@@ -1327,7 +1332,7 @@ if __name__ == "__main__":
                 Context(BASH_STATE, BASH_STATE.console),
                 BashCommand(
                     action_json=Command(command="pwd"),
-                    chat_id=BASH_STATE.current_chat_id,
+                    thread_id=BASH_STATE.current_thread_id,
                 ),
                 default_enc,
                 0,
@@ -1357,9 +1362,9 @@ if __name__ == "__main__":
                 Context(BASH_STATE, BASH_STATE.console),
                 FileWriteOrEdit(
                     file_path="/Users/arusia/repos/wcgw/src/wcgw/client/tools.py",
-                    file_content_or_search_replace_blocks="""test""",
+                    text_or_search_replace_blocks="""test""",
                     percentage_to_change=100,
-                    chat_id=BASH_STATE.current_chat_id,
+                    thread_id=BASH_STATE.current_thread_id,
                 ),
                 default_enc,
                 0,

{wcgw-5.1.1 → wcgw-5.1.3}/src/wcgw/types_.py

@@ -53,8 +53,8 @@ class Initialize(BaseModel):
     initial_files_to_read: list[str]
     task_id_to_resume: str
     mode_name: Literal["wcgw", "architect", "code_writer"]
-    chat_id: str = Field(
-        description="Use the chat id created in first_call, leave it as empty string if first_call"
+    thread_id: str = Field(
+        description="Use the thread_id created in first_call, leave it as empty string if first_call"
     )
     code_writer_config: Optional[CodeWriterMode] = None
 
@@ -105,7 +105,7 @@ class SendAscii(BaseModel):
 class BashCommand(BaseModel):
     action_json: Command | StatusCheck | SendText | SendSpecials | SendAscii
     wait_for_seconds: Optional[float] = None
-    chat_id: str
+    thread_id: str
 
 
 class ReadImage(BaseModel):
@@ -215,10 +215,15 @@ class FileEdit(BaseModel):
 
 
 class FileWriteOrEdit(BaseModel):
-    file_path: str
-    percentage_to_change: int  # 0.0 to 100.0
-    file_content_or_search_replace_blocks: str
-    chat_id: str
+    # Naming should be in sorted order otherwise it gets changed in LLM backend.
+    file_path: str = Field(description="#1: absolute file path")
+    percentage_to_change: int = Field(
+        description="#2: predict this percentage, calculated as number of existing lines that will have some diff divided by total existing lines."
+    )
+    text_or_search_replace_blocks: str = Field(
+        description="#3: content/edit blocks. Must be after #2 in the tool xml"
+    )
+    thread_id: str = Field(description="#4: thread_id")
 
 
 class ContextSave(BaseModel):