wcgw 3.0.1rc2__py3-none-any.whl → 3.0.1rc3__py3-none-any.whl

wcgw/client/bash_state/bash_state.py

@@ -32,7 +32,8 @@ from ...types_ import (
 from ..encoder import EncoderDecoder
 from ..modes import BashCommandMode, FileEditMode, WriteIfEmptyMode
 
-PROMPT_CONST = "#" + "@wcgw@#"
+PROMPT_CONST = "wcgw→" + " "
+PROMPT_STATEMENT = "export GIT_PAGER=cat PAGER=cat PROMPT_COMMAND= PS1='wcgw→'' '"
 BASH_CLF_OUTPUT = Literal["repl", "pending"]
 os.environ["TOKENIZERS_PARALLELISM"] = "false"
 
@@ -79,9 +80,7 @@ def get_tmpdir() -> str:
 
 def check_if_screen_command_available() -> bool:
     try:
-        subprocess.run(
-            ["screen", "-v"], capture_output=True, check=True, timeout=CONFIG.timeout
-        )
+        subprocess.run(["screen", "-v"], capture_output=True, check=True, timeout=0.2)
         return True
     except (subprocess.CalledProcessError, FileNotFoundError):
         return False
@@ -100,7 +99,7 @@ def cleanup_all_screens_with_name(name: str, console: Console) -> None:
             capture_output=True,
             text=True,
             check=True,
-            timeout=CONFIG.timeout,
+            timeout=0.2,
         )
         output = result.stdout
     except subprocess.CalledProcessError as e:
@@ -146,23 +145,21 @@ def start_shell(
         **os.environ,
         "PS1": PROMPT_CONST,
         "TMPDIR": get_tmpdir(),
-        "TERM": "vt100",
+        "TERM": "xterm-256color",
     }
     try:
         shell = pexpect.spawn(
             cmd,
             env=overrideenv,  # type: ignore[arg-type]
-            echo=False,
+            echo=True,
             encoding="utf-8",
             timeout=CONFIG.timeout,
             cwd=initial_dir,
             codec_errors="backslashreplace",
             dimensions=(500, 160),
         )
-        shell.sendline(
-            f"export PROMPT_COMMAND= PS1={PROMPT_CONST}"
-        )  # Unset prompt command to avoid interfering
-        shell.expect(PROMPT_CONST, timeout=CONFIG.timeout)
+        shell.sendline(PROMPT_STATEMENT)  # Unset prompt command to avoid interfering
+        shell.expect(PROMPT_CONST, timeout=0.2)
     except Exception as e:
         console.print(traceback.format_exc())
         console.log(f"Error starting shell: {e}. Retrying without rc ...")
@@ -170,13 +167,13 @@ def start_shell(
         shell = pexpect.spawn(
             "/bin/bash --noprofile --norc",
             env=overrideenv,  # type: ignore[arg-type]
-            echo=False,
+            echo=True,
             encoding="utf-8",
             timeout=CONFIG.timeout,
             codec_errors="backslashreplace",
         )
-        shell.sendline(f"export PS1={PROMPT_CONST}")
-        shell.expect(PROMPT_CONST, timeout=CONFIG.timeout)
+        shell.sendline(PROMPT_STATEMENT)
+        shell.expect(PROMPT_CONST, timeout=0.2)
 
     shellid = "wcgw." + time.strftime("%H%M%S")
     if over_screen:
@@ -184,20 +181,11 @@ def start_shell(
             raise ValueError("Screen command not available")
         # shellid is just hour, minute, second number
         shell.sendline(f"trap 'screen -X -S {shellid} quit' EXIT")
-        shell.expect(PROMPT_CONST, timeout=CONFIG.timeout)
+        shell.expect(PROMPT_CONST, timeout=0.2)
 
         shell.sendline(f"screen -q -S {shellid} /bin/bash --noprofile --norc")
         shell.expect(PROMPT_CONST, timeout=CONFIG.timeout)
 
-    shell.sendline("stty -icanon -echo")
-    shell.expect(PROMPT_CONST, timeout=CONFIG.timeout)
-
-    shell.sendline("set +o pipefail")
-    shell.expect(PROMPT_CONST, timeout=CONFIG.timeout)
-
-    shell.sendline("export GIT_PAGER=cat PAGER=cat")
-    shell.expect(PROMPT_CONST, timeout=CONFIG.timeout)
-
     return shell, shellid
 
 
@@ -234,7 +222,9 @@ def requires_shell(
 ) -> Callable[Concatenate["BashState", P], R]:
     def wrapper(self: "BashState", /, *args: P.args, **kwargs: P.kwargs) -> R:
         if not self._shell_loading.is_set():
-            if not self._shell_loading.wait(timeout=CONFIG.timeout):
+            if not self._shell_loading.wait(
+                timeout=CONFIG.timeout * 2
+            ):  # Twice in worst case if screen fails
                 raise RuntimeError("Shell initialization timeout")
 
         if self._shell_error:
@@ -278,7 +268,6 @@ class BashState:
         )
         self._mode = mode or Modes.wcgw
         self._whitelist_for_overwrite: set[str] = whitelist_for_overwrite or set()
-        self._prompt = PROMPT_CONST
         self._bg_expect_thread: Optional[threading.Thread] = None
         self._bg_expect_thread_stop_event = threading.Event()
         self._shell = None
@@ -296,6 +285,7 @@ class BashState:
                     if self._shell is not None:
                         return
                     self._init_shell()
+                self.run_bg_expect_thread()
             except Exception as e:
                 self._shell_error = e
             finally:
@@ -308,18 +298,19 @@ class BashState:
         self, shell: "pexpect.spawn[str]", pattern: Any, timeout: Optional[float] = -1
     ) -> int:
         self.close_bg_expect_thread()
-        return shell.expect(pattern, timeout)
+        output = shell.expect(pattern, timeout)
+        return output
 
     @requires_shell
     def send(self, shell: "pexpect.spawn[str]", s: str | bytes) -> int:
+        self.close_bg_expect_thread()
         output = shell.send(s)
-        self.run_bg_expect_thread()
         return output
 
     @requires_shell
     def sendline(self, shell: "pexpect.spawn[str]", s: str | bytes) -> int:
+        self.close_bg_expect_thread()
         output = shell.sendline(s)
-        self.run_bg_expect_thread()
         return output
 
     @property
@@ -329,6 +320,7 @@ class BashState:
 
     @requires_shell
     def sendintr(self, shell: "pexpect.spawn[str]") -> None:
+        self.close_bg_expect_thread()
         shell.sendintr()
 
     @property
@@ -336,8 +328,7 @@ class BashState:
     def before(self, shell: "pexpect.spawn[str]") -> Optional[str]:
         return shell.before
 
-    @requires_shell
-    def run_bg_expect_thread(self, shell: "pexpect.spawn[str]") -> None:
+    def run_bg_expect_thread(self) -> None:
         """
         Run background expect thread for handling shell interactions.
         """
@@ -346,11 +337,16 @@ class BashState:
             while True:
                 if self._bg_expect_thread_stop_event.is_set():
                     break
-                output = shell.expect([pexpect.EOF, pexpect.TIMEOUT], timeout=0.1)
+                if self._shell is None:
+                    time.sleep(0.1)
+                    continue
+                output = self._shell.expect([pexpect.EOF, pexpect.TIMEOUT], timeout=0.1)
                 if output == 0:
                     break
 
-        if self._bg_expect_thread:
+        if self._bg_expect_thread and self._bg_expect_thread.is_alive():
+            if not self._bg_expect_thread_stop_event.is_set():
+                return
             self.close_bg_expect_thread()
 
         self._bg_expect_thread = threading.Thread(
@@ -403,28 +399,20 @@ class BashState:
 
     def _ensure_env_and_bg_jobs(self) -> Optional[int]:
         # Do not add @requires_shell decorator here, as it will cause deadlock
-
         self.close_bg_expect_thread()
         assert self._shell is not None, "Bad state, shell is not initialized"
-        if self._prompt != PROMPT_CONST:
-            return None
         quick_timeout = 0.2 if not self.over_screen else 1
         # First reset the prompt in case venv was sourced or other reasons.
-        self._shell.sendline(f"export PS1={self._prompt}")
-        self._shell.expect(self._prompt, timeout=quick_timeout)
+        self._shell.sendline(PROMPT_STATEMENT)
+        self._shell.expect(PROMPT_CONST, timeout=quick_timeout)
         # Reset echo also if it was enabled
-        self._shell.sendline("stty -icanon -echo")
-        self._shell.expect(self._prompt, timeout=quick_timeout)
-        self._shell.sendline("set +o pipefail")
-        self._shell.expect(self._prompt, timeout=quick_timeout)
-        self._shell.sendline("export GIT_PAGER=cat PAGER=cat")
-        self._shell.expect(self._prompt, timeout=quick_timeout)
-        self._shell.sendline("jobs | wc -l")
+        command = "jobs | wc -l"
+        self._shell.sendline(command)
         before = ""
         counts = 0
         while not _is_int(before):  # Consume all previous output
             try:
-                self._shell.expect(self._prompt, timeout=quick_timeout)
+                self._shell.expect(PROMPT_CONST, timeout=quick_timeout)
             except pexpect.TIMEOUT:
                 self.console.print(f"Couldn't get exit code, before: {before}")
                 raise
@@ -434,20 +422,18 @@ class BashState:
                 before_val = str(before_val)
             assert isinstance(before_val, str)
             before_lines = render_terminal_output(before_val)
-            before = "\n".join(before_lines).strip()
+            before = "\n".join(before_lines).replace(command, "").strip()
             counts += 1
             if counts > 100:
                 raise ValueError(
                     "Error in understanding shell output. This shouldn't happen, likely shell is in a bad state, please reset it"
                 )
-
         try:
             return int(before)
         except ValueError:
             raise ValueError(f"Malformed output: {before}")
 
     def _init_shell(self) -> None:
-        self._prompt = PROMPT_CONST
         self._state: Literal["repl"] | datetime.datetime = "repl"
         self._is_in_docker: Optional[str] = ""
         # Ensure self._cwd exists
@@ -474,13 +460,15 @@ class BashState:
             self.over_screen = False
 
         self._pending_output = ""
-        self._ensure_env_and_bg_jobs()
+        try:
+            self._ensure_env_and_bg_jobs()
+        except ValueError as e:
+            self.console.log("Error while running _ensure_env_and_bg_jobs" + str(e))
 
     def set_pending(self, last_pending_output: str) -> None:
         if not isinstance(self._state, datetime.datetime):
             self._state = datetime.datetime.now()
         self._pending_output = last_pending_output
-        self.run_bg_expect_thread()
 
     def set_repl(self) -> None:
         self._state = "repl"
@@ -505,12 +493,12 @@ class BashState:
 
     @property
     def prompt(self) -> str:
-        return self._prompt
+        return PROMPT_CONST
 
     @requires_shell
     def update_cwd(self, shell: "pexpect.spawn[str]") -> str:
         shell.sendline("pwd")
-        shell.expect(self._prompt, timeout=0.2)
+        shell.expect(PROMPT_CONST, timeout=0.2)
         before_val = shell.before
         if not isinstance(before_val, str):
             before_val = str(before_val)
@@ -637,9 +625,8 @@ def _incremental_text(text: str, last_pending_output: str) -> str:
     # text = render_terminal_output(text[-100_000:])
     text = text[-100_000:]
 
-    last_pending_output_rendered_lines = render_terminal_output(last_pending_output)
-    last_pending_output_rendered = "\n".join(last_pending_output_rendered_lines)
-    last_rendered_lines = last_pending_output_rendered.split("\n")
+    last_rendered_lines = render_terminal_output(last_pending_output)
+    last_pending_output_rendered = "\n".join(last_rendered_lines)
     if not last_rendered_lines:
         return rstrip(render_terminal_output(text))
 
@@ -690,6 +677,27 @@ def execute_bash(
     bash_arg: BashCommand,
     max_tokens: Optional[int],
     timeout_s: Optional[float],
+) -> tuple[str, float]:
+    try:
+        output, cost = _execute_bash(bash_state, enc, bash_arg, max_tokens, timeout_s)
+
+        # Remove echo if it's a command
+        if isinstance(bash_arg.action, Command):
+            command = bash_arg.action.command.strip()
+            if output.startswith(command):
+                output = output[len(command) :]
+
+    finally:
+        bash_state.run_bg_expect_thread()
+    return output, cost
+
+
+def _execute_bash(
+    bash_state: BashState,
+    enc: EncoderDecoder[int],
+    bash_arg: BashCommand,
+    max_tokens: Optional[int],
+    timeout_s: Optional[float],
 ) -> tuple[str, float]:
     try:
         is_interrupt = False

wcgw/client/mcp_server/server.py

@@ -1,5 +1,4 @@
 import importlib
-import json
 import logging
 import os
 from typing import Any
@@ -9,7 +8,7 @@ import mcp_wcgw.types as types
 from mcp_wcgw.server import NotificationOptions, Server
 from mcp_wcgw.server.models import InitializationOptions
 from mcp_wcgw.types import Tool as ToolParam
-from pydantic import AnyUrl, ValidationError
+from pydantic import AnyUrl
 
 from wcgw.client.modes import KTS
 from wcgw.client.tool_prompts import TOOL_PROMPTS
@@ -18,7 +17,13 @@ from ...types_ import (
     Initialize,
 )
 from ..bash_state.bash_state import CONFIG, BashState
-from ..tools import Context, default_enc, get_tool_output, which_tool_name
+from ..tools import (
+    Context,
+    default_enc,
+    get_tool_output,
+    parse_tool_by_name,
+    which_tool_name,
+)
 
 server = Server("wcgw")
 
@@ -104,20 +109,7 @@ async def handle_call_tool(
         raise ValueError("Missing arguments")
 
     tool_type = which_tool_name(name)
-
-    try:
-        tool_call = tool_type(**arguments)
-    except ValidationError:
-
-        def try_json(x: str) -> Any:
-            if not isinstance(x, str):
-                return x
-            try:
-                return json.loads(x)
-            except json.JSONDecodeError:
-                return x
-
-        tool_call = tool_type(**{k: try_json(v) for k, v in arguments.items()})
+    tool_call = parse_tool_by_name(name, arguments)
 
     try:
         assert BASH_STATE

wcgw/client/tools.py

@@ -10,6 +10,7 @@ from os.path import expanduser
 from pathlib import Path
 from tempfile import NamedTemporaryFile
 from typing import (
+    Any,
     Callable,
     Literal,
     Optional,
@@ -21,7 +22,7 @@ from typing import (
 from openai.types.chat import (
     ChatCompletionMessageParam,
 )
-from pydantic import BaseModel, TypeAdapter
+from pydantic import BaseModel, TypeAdapter, ValidationError
 from syntax_checker import check_syntax
 
 from wcgw.client.bash_state.bash_state import get_status
@@ -549,6 +550,23 @@ def which_tool_name(name: str) -> Type[TOOLS]:
         raise ValueError(f"Unknown tool name: {name}")
 
 
+def parse_tool_by_name(name: str, arguments: dict[str, Any]) -> TOOLS:
+    tool_type = which_tool_name(name)
+    try:
+        return tool_type(**arguments)
+    except ValidationError:
+
+        def try_json(x: str) -> Any:
+            if not isinstance(x, str):
+                return x
+            try:
+                return json.loads(x)
+            except json.JSONDecodeError:
+                return x
+
+        return tool_type(**{k: try_json(v) for k, v in arguments.items()})
+
+
 TOOL_CALLS: list[TOOLS] = []
 
 

{wcgw-3.0.1rc2.dist-info → wcgw-3.0.1rc3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wcgw
-Version: 3.0.1rc2
+Version: 3.0.1rc3
 Summary: Shell and coding agent on claude and chatgpt
 Project-URL: Homepage, https://github.com/rusiaaman/wcgw
 Author-email: Aman Rusia <gapypi@arcfu.com>

{wcgw-3.0.1rc2.dist-info → wcgw-3.0.1rc3.dist-info}/RECORD

@@ -7,14 +7,14 @@ wcgw/client/diff-instructions.txt,sha256=tmJ9Fu9XdO_72lYXQQNY9RZyx91bjxrXJf9d_KB
 wcgw/client/memory.py,sha256=8LdYsOhvCOoC1kfvDr85kNy07WnhPMvE6B2FRM2w85Y,2902
 wcgw/client/modes.py,sha256=dBkiMNQevTFNkhplrDsDuSIyeU-wLmAIfAa9Dqowvk8,10387
 wcgw/client/tool_prompts.py,sha256=j82aYnlr1pcinsOYitSrlyYz4-9K3KcqnAfGqot21NQ,4158
-wcgw/client/tools.py,sha256=eXAGPKm7ViG2OgF1m_yLTPehtmkhQFWDoiLEkV7fOMQ,22660
-wcgw/client/bash_state/bash_state.py,sha256=dNCx2KRQSQHYihTsfIqtQNsd8j27CoSMH4I026Cz8pU,29308
+wcgw/client/tools.py,sha256=caj10NHeK5tZ5Gi0L_oXzPcKBycgXeNaLEbXAzYTpqo,23170
+wcgw/client/bash_state/bash_state.py,sha256=2cxzYN6x-vEJ4oasrCgoRyVQKpARKONcaNDLfLPDTG8,29476
 wcgw/client/encoder/__init__.py,sha256=Y-8f43I6gMssUCWpX5rLYiAFv3D-JPRs4uNEejPlke8,1514
 wcgw/client/file_ops/diff_edit.py,sha256=sIwXSSkWYff_Dp3oHfefqtSuFqLrxbhKvzkCoLuLqDE,18679
 wcgw/client/file_ops/search_replace.py,sha256=Napa7IWaYPGMNdttunKyRDkb90elZE7r23B_o_htRxo,5585
 wcgw/client/mcp_server/Readme.md,sha256=2Z88jj1mf9daYGW1CWaldcJ0moy8owDumhR2glBY3A8,109
 wcgw/client/mcp_server/__init__.py,sha256=mm7xhBIPwJpRT3u-Qsj4cKVMpVyucJoKRlbMP_gRRB0,343
-wcgw/client/mcp_server/server.py,sha256=aF8SLaCsPisQsQ0fOUOpTfP2S4EGEugaLupjCyhHA8o,5371
+wcgw/client/mcp_server/server.py,sha256=ayK6qbzCveoQW7RO80m10cAIS3m-hvxzd15XhjiyxmE,5055
 wcgw/client/repo_ops/display_tree.py,sha256=E5q9mrGBb57NyvudSmRIG-fj4FUqupbzjmARpX8X0XY,4166
 wcgw/client/repo_ops/path_prob.py,sha256=SWf0CDn37rtlsYRQ51ufSxay-heaQoVIhr1alB9tZ4M,2144
 wcgw/client/repo_ops/paths_model.vocab,sha256=M1pXycYDQehMXtpp-qAgU7rtzeBbCOiJo4qcYFY0kqk,315087
@@ -25,7 +25,7 @@ wcgw/relay/serve.py,sha256=Ofq6PjW3zVVA2-9MVviGRiUESTD3sXb-482Q4RV13q8,8664
 wcgw/relay/static/privacy.txt,sha256=s9qBdbx2SexCpC_z33sg16TptmAwDEehMCLz4L50JLc,529
 wcgw_cli/__init__.py,sha256=TNxXsTPgb52OhakIda9wTRh91cqoBqgQRx5TxjzQQFU,21
 wcgw_cli/__main__.py,sha256=wcCrL4PjG51r5wVKqJhcoJPTLfHW0wNbD31DrUN0MWI,28
-wcgw_cli/anthropic_client.py,sha256=hpeqfLxYgfJpLgYmCRvE9r1Iu0ubGiBqmgEFzwKIvCM,18966
+wcgw_cli/anthropic_client.py,sha256=2QLFBLbMeQuixF7Pz9j_hINHTG1CF9IYQZeri7zFuF0,18964
 wcgw_cli/cli.py,sha256=-7FBe_lahKyUOhf65iurTA1M1gXXXAiT0OVKQVcZKKo,948
 wcgw_cli/openai_client.py,sha256=oMFAaOkvXQtOY7choylVRJfaF2SnWvRc02ygQhlhVqY,15995
 wcgw_cli/openai_utils.py,sha256=xGOb3W5ALrIozV7oszfGYztpj0FnXdD7jAxm5lEIVKY,2439
@@ -51,8 +51,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-3.0.1rc2.dist-info/METADATA,sha256=J7O32iQuFetYvpv1pNkdHMsHbeV7o-3HYd6QNUzMszk,13005
-wcgw-3.0.1rc2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-wcgw-3.0.1rc2.dist-info/entry_points.txt,sha256=vd3tj1_Kzfp55LscJ8-6WFMM5hm9cWTfNGFCrWBnH3Q,124
-wcgw-3.0.1rc2.dist-info/licenses/LICENSE,sha256=BvY8xqjOfc3X2qZpGpX3MZEmF-4Dp0LqgKBbT6L_8oI,11142
-wcgw-3.0.1rc2.dist-info/RECORD,,
+wcgw-3.0.1rc3.dist-info/METADATA,sha256=ymiydLYH56IAV_8FKq98BrGf-tt7Vwumtc8nUBvzs50,13005
+wcgw-3.0.1rc3.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+wcgw-3.0.1rc3.dist-info/entry_points.txt,sha256=vd3tj1_Kzfp55LscJ8-6WFMM5hm9cWTfNGFCrWBnH3Q,124
+wcgw-3.0.1rc3.dist-info/licenses/LICENSE,sha256=BvY8xqjOfc3X2qZpGpX3MZEmF-4Dp0LqgKBbT6L_8oI,11142
+wcgw-3.0.1rc3.dist-info/RECORD,,

wcgw_cli/anthropic_client.py

@@ -35,7 +35,7 @@ from wcgw.client.tools import (
     default_enc,
     get_tool_output,
     initialize,
-    which_tool_name,
+    parse_tool_by_name,
 )
 
 
@@ -379,9 +379,9 @@ def loop(
                                 tool_input = str(tc["input"])
                                 tool_id = str(tc["id"])
 
-                                tool_parsed = which_tool_name(
-                                    tool_name
-                                ).model_validate_json(tool_input)
+                                tool_parsed = parse_tool_by_name(
+                                    tool_name, json.loads(tool_input)
+                                )
 
                                 system_console.print(
                                     f"\n---------------------------------------\n# Assistant invoked tool: {tool_parsed}"