wcgw 4.1.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.
@@ -269,6 +381,8 @@ class BashState:
         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
 
@@ -387,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",
@@ -817,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-4.1.0.dist-info → wcgw-4.1.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wcgw
-Version: 4.1.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

{wcgw-4.1.0.dist-info → wcgw-4.1.1.dist-info}/RECORD

@@ -8,7 +8,9 @@ wcgw/client/memory.py,sha256=M0plOGE5WXTEAs7nVLg4eCpVhmSW94ckpg5D0ycWX5I,2927
 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=1i72oLJ73AHvj0XmK0kAKnksiZwxWdAg21K27loKmpo,34020
+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=eNxFRmVsBfY0ISwfsV5s8rlMwMxTlm6ko150iFFCsT8,18525
 wcgw/client/file_ops/search_replace.py,sha256=TaIPDqjgmTo4oghhO3zIFklq5JjAbx_aPHJ7yEgvDh4,6854
@@ -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.1.0.dist-info/METADATA,sha256=6v32rPTVYTPeEGY9F0miFZRknGe31eeN0bZKWskoSW8,14916
-wcgw-4.1.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-wcgw-4.1.0.dist-info/entry_points.txt,sha256=vd3tj1_Kzfp55LscJ8-6WFMM5hm9cWTfNGFCrWBnH3Q,124
-wcgw-4.1.0.dist-info/licenses/LICENSE,sha256=BvY8xqjOfc3X2qZpGpX3MZEmF-4Dp0LqgKBbT6L_8oI,11142
-wcgw-4.1.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,,