tau-coding-agent 0.5.1__tar.gz → 0.5.2__tar.gz

{tau_coding_agent-0.5.1/tau_coding_agent.egg-info → tau_coding_agent-0.5.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tau-coding-agent
-Version: 0.5.1
+Version: 0.5.2
 Summary: A self-extensible agent CLI with terminal UI, multi-provider LLM support, session management with branching, and a plugin system for tools and commands
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown

{tau_coding_agent-0.5.1 → tau_coding_agent-0.5.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "tau-coding-agent"
-version = "0.5.1"
+version = "0.5.2"
 description = "A self-extensible agent CLI with terminal UI, multi-provider LLM support, session management with branching, and a plugin system for tools and commands"
 readme = "README.md"
 requires-python = ">=3.12"

{tau_coding_agent-0.5.1 → tau_coding_agent-0.5.2}/tau/modes/rpc/mode.py

@@ -790,11 +790,16 @@ async def run_rpc_mode(runtime: Runtime) -> None:
 
     import signal as _signal
 
-    try:
-        loop.add_signal_handler(_signal.SIGTERM, _on_signal)
-        loop.add_signal_handler(_signal.SIGHUP, _on_signal)
-    except (NotImplementedError, OSError):
-        pass  # Windows
+    # SIGHUP does not exist on Windows (AttributeError), and add_signal_handler
+    # is unsupported on the Proactor loop (NotImplementedError). Skip whatever the
+    # platform lacks instead of failing.
+    for _sig_name in ("SIGTERM", "SIGHUP"):
+        _sig = getattr(_signal, _sig_name, None)
+        if _sig is None:
+            continue
+        # Windows / unsupported event loop → add_signal_handler raises.
+        with contextlib.suppress(NotImplementedError, OSError):
+            loop.add_signal_handler(_sig, _on_signal)
 
     # ── Announce ready ───────────────────────────────────────────────────────
     sm = runtime.session_manager

{tau_coding_agent-0.5.1 → tau_coding_agent-0.5.2}/tau/tui/terminal.py

@@ -4,12 +4,24 @@ import asyncio
 import os
 import signal
 import sys
-import termios
-import tty
+import threading
 from collections.abc import Callable
 from dataclasses import dataclass
 from typing import Any, Literal
 
+# termios/tty are POSIX-only. On Windows the console is driven through the
+# Win32 console API instead (see the _*_windows helpers on Terminal).
+# The guard tests ``sys.platform`` directly so type checkers can statically
+# narrow the import as bound on POSIX targets.
+_IS_WINDOWS = sys.platform == "win32"
+
+if sys.platform != "win32":
+    import termios
+    import tty
+
+# Windows has no SIGWINCH, so resize is detected by polling the console size.
+_WIN_RESIZE_POLL_INTERVAL = 0.25
+
 # ── Terminal Capabilities ─────────────────────────────────────────────────────
 
 ImageProtocol = Literal["kitty", "iterm2"] | None
@@ -178,6 +190,13 @@ class Terminal:
         self._original_termios: list | None = None
         self._resize_callbacks: list[Callable[[], None]] = []
         self._prev_sigwinch: Any = None
+        # Saved Windows console modes (restored on exit); unused on POSIX.
+        self._win_stdin_mode: int | None = None
+        self._win_stdout_mode: int | None = None
+        # Windows resize poller (no SIGWINCH there); unused on POSIX.
+        self._win_resize_thread: threading.Thread | None = None
+        self._win_resize_stop: threading.Event | None = None
+        self._loop: asyncio.AbstractEventLoop | None = None
         self.width, self.height = self._get_size()
 
     # -------------------------------------------------------------------------
@@ -192,6 +211,9 @@ class Terminal:
         Characters are sent immediately without waiting for Enter.
         Also saves the original terminal settings and signal handlers for later restoration.
         """
+        if _IS_WINDOWS:
+            self._enter_raw_mode_windows()
+            return
         fd = sys.stdin.fileno()
         self._original_termios = termios.tcgetattr(fd)  # Save original settings
         tty.setraw(fd)  # Switch to raw mode (no echo, no buffering)
@@ -207,6 +229,9 @@ class Terminal:
         - Restores original terminal settings (echo, buffering, signals re-enabled)
         - Restores the original signal handler for terminal resize events
         """
+        if _IS_WINDOWS:
+            self._exit_raw_mode_windows()
+            return
         if self._original_termios is not None:
             # TCSADRAIN: wait for pending output to finish before restoring
             termios.tcsetattr(sys.stdin.fileno(), termios.TCSADRAIN, self._original_termios)
@@ -216,6 +241,125 @@ class Terminal:
             signal.signal(signal.SIGWINCH, self._prev_sigwinch)
             self._prev_sigwinch = None
 
+    # -------------------------------------------------------------------------
+    # Windows console backend
+    # -------------------------------------------------------------------------
+
+    # Win32 console-mode flags (see docs.microsoft.com SetConsoleMode).
+    _WIN_ENABLE_PROCESSED_INPUT = 0x0001
+    _WIN_ENABLE_LINE_INPUT = 0x0002
+    _WIN_ENABLE_ECHO_INPUT = 0x0004
+    _WIN_ENABLE_VIRTUAL_TERMINAL_INPUT = 0x0200
+    _WIN_ENABLE_PROCESSED_OUTPUT = 0x0001
+    _WIN_ENABLE_VIRTUAL_TERMINAL_PROCESSING = 0x0004
+    _WIN_STD_INPUT_HANDLE = -10
+    _WIN_STD_OUTPUT_HANDLE = -11
+
+    def _enter_raw_mode_windows(self) -> None:
+        """Put the Windows console into raw + VT mode via the Win32 console API.
+
+        termios/tty/SIGWINCH do not exist on Windows, so instead we clear the
+        console's line-input/echo/processing flags (raw keyboard input) and turn
+        on virtual-terminal processing so ANSI escape sequences are honoured on
+        both input and output. Resize is not delivered as a signal on Windows;
+        the size is re-read lazily by ``_get_size()``.
+        """
+        import ctypes
+
+        if sys.platform != "win32":  # pragma: no cover - keeps type checkers on win32 stubs
+            return
+
+        k32 = ctypes.windll.kernel32
+        hin = k32.GetStdHandle(self._WIN_STD_INPUT_HANDLE)
+        hout = k32.GetStdHandle(self._WIN_STD_OUTPUT_HANDLE)
+
+        in_mode = ctypes.c_uint32()
+        if k32.GetConsoleMode(hin, ctypes.byref(in_mode)):
+            self._win_stdin_mode = in_mode.value
+            new_in = (
+                in_mode.value
+                & ~(
+                    self._WIN_ENABLE_PROCESSED_INPUT
+                    | self._WIN_ENABLE_LINE_INPUT
+                    | self._WIN_ENABLE_ECHO_INPUT
+                )
+            ) | self._WIN_ENABLE_VIRTUAL_TERMINAL_INPUT
+            k32.SetConsoleMode(hin, new_in)
+
+        out_mode = ctypes.c_uint32()
+        if k32.GetConsoleMode(hout, ctypes.byref(out_mode)):
+            self._win_stdout_mode = out_mode.value
+            k32.SetConsoleMode(
+                hout,
+                out_mode.value
+                | self._WIN_ENABLE_PROCESSED_OUTPUT
+                | self._WIN_ENABLE_VIRTUAL_TERMINAL_PROCESSING,
+            )
+
+        self._start_resize_poller_windows()
+
+    def _exit_raw_mode_windows(self) -> None:
+        """Restore the Windows console modes saved by _enter_raw_mode_windows."""
+        import ctypes
+
+        if sys.platform != "win32":  # pragma: no cover - keeps type checkers on win32 stubs
+            return
+
+        self._stop_resize_poller_windows()
+
+        k32 = ctypes.windll.kernel32
+        if self._win_stdin_mode is not None:
+            k32.SetConsoleMode(k32.GetStdHandle(self._WIN_STD_INPUT_HANDLE), self._win_stdin_mode)
+            self._win_stdin_mode = None
+        if self._win_stdout_mode is not None:
+            k32.SetConsoleMode(k32.GetStdHandle(self._WIN_STD_OUTPUT_HANDLE), self._win_stdout_mode)
+            self._win_stdout_mode = None
+
+    def _start_resize_poller_windows(self) -> None:
+        """Start a daemon thread that polls the console size (Windows has no SIGWINCH).
+
+        Windows delivers no resize signal, so a background thread samples
+        ``_get_size()`` on an interval and fires the registered resize callbacks
+        (on the event loop thread) whenever the dimensions change.
+        """
+        try:
+            self._loop = asyncio.get_running_loop()
+        except RuntimeError:
+            self._loop = None
+        self._win_resize_stop = threading.Event()
+        self._win_resize_thread = threading.Thread(
+            target=self._win_resize_poll_loop,
+            args=(self._win_resize_stop,),
+            name="tau-tui-resize",
+            daemon=True,
+        )
+        self._win_resize_thread.start()
+
+    def _stop_resize_poller_windows(self) -> None:
+        if self._win_resize_stop is not None:
+            self._win_resize_stop.set()
+        self._win_resize_thread = None
+        self._win_resize_stop = None
+        self._loop = None
+
+    def _win_resize_poll_loop(self, stop: threading.Event) -> None:
+        """Poll the terminal size and fire callbacks on change until ``stop`` is set."""
+        while not stop.wait(_WIN_RESIZE_POLL_INTERVAL):
+            new_size = self._get_size()
+            if new_size == (self.width, self.height):
+                continue
+            self.width, self.height = new_size
+            loop = self._loop
+            if loop is None:
+                for cb in list(self._resize_callbacks):
+                    cb()
+                continue
+            for cb in list(self._resize_callbacks):
+                try:
+                    loop.call_soon_threadsafe(cb)
+                except RuntimeError:
+                    return  # event loop already closed
+
     def enter_alt_screen(self) -> None:
         """
         Switch to alternate screen buffer (like vim or less does).

{tau_coding_agent-0.5.1 → tau_coding_agent-0.5.2}/tau/tui/tui.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 import asyncio
 import logging
 import sys
+import threading
 import time
 from collections.abc import Awaitable, Callable
 from dataclasses import dataclass, field
@@ -15,6 +16,10 @@ from tau.tui.utils import set_window_focused
 
 _log = logging.getLogger(__name__)
 
+# The asyncio event loops on Windows can't watch a console handle with
+# add_reader, so stdin is pumped from a background thread there instead.
+_IS_WINDOWS = sys.platform == "win32"
+
 if TYPE_CHECKING:
     pass
 
@@ -805,6 +810,7 @@ class TUI(Container):
         self._render_timer: asyncio.TimerHandle | None = None
         self._render_requested = False
         self._esc_timer: asyncio.TimerHandle | None = None
+        self._stdin_thread: threading.Thread | None = None
 
         self._input_handlers: list[EventHandler] = []
         self._intercept_handlers: list[EventHandler] = []
@@ -878,7 +884,19 @@ class TUI(Container):
             self._request_render()
 
             self._terminal.enable_kitty_keyboard()
-            loop.add_reader(sys.stdin.fileno(), self._on_stdin_ready)
+            if _IS_WINDOWS:
+                # Windows event loops can't add_reader() a console handle, so a
+                # daemon thread does the blocking read and hands each chunk back
+                # to the loop thread.
+                self._stdin_thread = threading.Thread(
+                    target=self._win_stdin_loop,
+                    args=(loop,),
+                    name="tau-tui-stdin",
+                    daemon=True,
+                )
+                self._stdin_thread.start()
+            else:
+                loop.add_reader(sys.stdin.fileno(), self._on_stdin_ready)
 
             # Query terminal background colour for theme hints, then notify any
             # listener (e.g. auto light/dark theme selection).
@@ -891,7 +909,13 @@ class TUI(Container):
             try:
                 await self._stop_event.wait()
             finally:
-                loop.remove_reader(sys.stdin.fileno())
+                if _IS_WINDOWS:
+                    # The daemon reader observes _stop_event and exits after its
+                    # next read returns (or dies with the process); nothing to
+                    # unregister from the loop.
+                    self._stdin_thread = None
+                else:
+                    loop.remove_reader(sys.stdin.fileno())
                 self._cancel_timers()
                 self._terminal.disable_kitty_keyboard()
                 self._terminal.disable_bracketed_paste()
@@ -1175,11 +1199,20 @@ class TUI(Container):
     # -------------------------------------------------------------------------
 
     def _on_stdin_ready(self) -> None:
+        """Loop-thread callback (POSIX add_reader): read stdin and process it."""
         try:
             data = self._terminal.read_raw()
         except OSError:
             return
+        self._process_input(data)
 
+    def _process_input(self, data: str) -> None:
+        """Feed raw input bytes through the parser and dispatch resulting events.
+
+        Runs on the event-loop thread. On POSIX it is called directly from the
+        add_reader callback; on Windows it is scheduled via call_soon_threadsafe
+        from the stdin reader thread.
+        """
         if not data:
             return
 
@@ -1194,6 +1227,27 @@ class TUI(Container):
         if events:
             self._request_render()
 
+    def _win_stdin_loop(self, loop: asyncio.AbstractEventLoop) -> None:
+        """Windows stdin pump: blocking-read on a daemon thread.
+
+        Reads keystrokes with the console in raw/VT mode (set by Terminal) and
+        marshals each chunk onto the event loop via call_soon_threadsafe, since
+        Windows event loops cannot watch a console handle with add_reader.
+        """
+        while not self._stop_event.is_set():
+            try:
+                data = self._terminal.read_raw()
+            except OSError:
+                break
+            if not data:
+                continue
+            if self._stop_event.is_set():
+                break
+            try:
+                loop.call_soon_threadsafe(self._process_input, data)
+            except RuntimeError:
+                break  # event loop already closed
+
     def _schedule_esc_flush(self) -> None:
         if self._esc_timer is not None:
             self._esc_timer.cancel()

{tau_coding_agent-0.5.1 → tau_coding_agent-0.5.2/tau_coding_agent.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tau-coding-agent
-Version: 0.5.1
+Version: 0.5.2
 Summary: A self-extensible agent CLI with terminal UI, multi-provider LLM support, session management with branching, and a plugin system for tools and commands
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown