wcgw 4.0.0__tar.gz → 4.1.1__tar.gz

wcgw-4.1.1/CLAUDE.md

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

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

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

@@ -2,7 +2,7 @@
 
 Empowering chat applications to code, build and run on your local machine.
 
-- Claude - An MCP server on claude desktop for autonomous shell and coding agent. (mac, linux, windows on wsl)
+- Claude - MCP server with tightly integrated shell and code editing tools.
 - Chatgpt - Allows custom gpt to talk to your shell via a relay server. (linux, mac, windows on wsl)
 
 ⚠️ Warning: do not allow BashCommand tool without reviewing the command, it may result in data loss.
@@ -19,6 +19,8 @@ Empowering chat applications to code, build and run on your local machine.
 
 ## Updates
 
+- [24 Mar 2025] Improved writing and editing experience for sonnet 3.7, CLAUDE.md gets loaded automatically.
+
 - [16 Feb 2025] You can now attach to the working terminal that the AI uses. See the "attach-to-terminal" section below.
 
 - [15 Jan 2025] Modes introduced: architect, code-writer, and all powerful wcgw mode.
@@ -32,7 +34,7 @@ Empowering chat applications to code, build and run on your local machine.
 ## 🚀 Highlights
 
 - ⚡ **Create, Execute, Iterate**: Ask claude to keep running compiler checks till all errors are fixed, or ask it to keep checking for the status of a long running command till it's done.
-- ⚡ **Large file edit**: Supports large file incremental edits to avoid token limit issues. Faster than full file write.
+- ⚡ **Large file edit**: Supports large file incremental edits to avoid token limit issues. Smartly selects when to do small edits or large rewrite based on % of change needed.
 - ⚡ **Syntax checking on edits**: Reports feedback to the LLM if its edits have any syntax errors, so that it can redo it.
 - ⚡ **Interactive Command Handling**: Supports interactive commands using arrow keys, interrupt, and ansi escape sequences.
 - ⚡ **File protections**:

{wcgw-4.0.0 → wcgw-4.1.1}/pyproject.toml

@@ -1,7 +1,7 @@
 [project]
 authors = [{ name = "Aman Rusia", email = "gapypi@arcfu.com" }]
 name = "wcgw"
-version = "4.0.0"
+version = "4.1.1"
 description = "Shell and coding agent on claude and chatgpt"
 readme = "README.md"
 requires-python = ">=3.11"
@@ -23,6 +23,7 @@ dependencies = [
     "tokenizers>=0.21.0",
     "pygit2>=1.16.0",
     "syntax-checker>=0.3.0",
+    "psutil>=7.0.0",
 ]
 
 [project.urls]
@@ -58,6 +59,9 @@ dev-dependencies = [
     "line-profiler>=4.2.0",
     "pytest-asyncio>=0.25.3",
     "types-pexpect>=4.9.0.20241208",
+    "types-psutil>=7.0.0.20250218",
+    "tree-sitter>=0.24.0",
+    "tree-sitter-bash>=0.23.3",
 ]
 
 [tool.pytest.ini_options]

{wcgw-4.0.0 → wcgw-4.1.1}/src/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-4.1.1/src/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-4.1.1/src/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()