aru-code 0.42.0__tar.gz → 0.45.0__tar.gz

{aru_code-0.42.0/aru_code.egg-info → aru_code-0.45.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aru-code
-Version: 0.42.0
+Version: 0.45.0
 Summary: A Claude Code clone built with Agno agents
 Author-email: Estevao <estevaofon@gmail.com>
 License-Expression: MIT

aru_code-0.45.0/aru/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.45.0"

{aru_code-0.42.0 → aru_code-0.45.0}/aru/tui/app.py

@@ -32,6 +32,7 @@ from __future__ import annotations
 
 import asyncio
 import sys
+import time
 from typing import Any
 
 from textual.app import App, ComposeResult
@@ -256,6 +257,25 @@ class AruApp(App):
         "skills", "agents", "commands", "mcp", "yolo",
     }
 
+    # Layer 10 / 12 — interval (seconds) between belt-and-suspenders re-emits
+    # of the mouse-tracking enable sequences. Was 8s pre-Layer-12; user
+    # report on 2026-04-25 against ``final-fantasy-9/.aru/sessions/b33dfb99``
+    # was that the wheel never came back even after the turn ended in YOLO,
+    # and 8s was visibly long enough that the user gave up before the next
+    # tick. 3s is short enough that a corrupted state self-heals before the
+    # next mouse interaction, and the cost is still ~64 bytes per tick (the
+    # Layer 12 off-then-on shake — see ``_reenable_mouse_tracking``).
+    _MOUSE_REENABLE_INTERVAL: float = 3.0
+
+    # Layer 12 — minimum interval (seconds) between keypress-triggered
+    # mouse-tracking re-arms. Each keystroke is an opportunity to recover
+    # — if the user is typing it might be precisely BECAUSE the wheel just
+    # stopped working — but we don't want a fast typist to turn every
+    # keystroke into four extra terminal writes. 500 ms is below human
+    # noticeable retry latency yet caps the keystroke→write amplification
+    # at ~2 Hz worst case.
+    _KEYPRESS_REARM_DEBOUNCE: float = 0.5
+
     def __init__(
         self,
         *,
@@ -281,6 +301,12 @@ class AruApp(App):
         # cleared) by on_input_submitted.
         self._pending_paste: str | None = None
         self._pending_paste_lines: int = 0
+        # Layer 12 — last time we re-emitted the mouse-tracking enable
+        # sequences via the keypress path. Used to debounce per-keystroke
+        # re-arming so a fast typist doesn't spam the terminal with re-
+        # enables. Initialised to negative infinity so the first keystroke
+        # always rearms.
+        self._last_mouse_reenable_at: float = float("-inf")
 
     # ── Composition ──────────────────────────────────────────────────
 
@@ -375,6 +401,21 @@ class AruApp(App):
         if not self.is_headless:
             _push_terminal_title()
             _set_terminal_title(_compose_terminal_title(self.session))
+        # Layer 10 / 11 self-heal — periodic recovery of terminal state and
+        # input focus. Two failure classes share one tick:
+        # * mouse-enable lost (leaked DEC private-mode escape disabled the
+        #   wheel) — re-emit ``_enable_mouse_support`` (Layer 10).
+        # * input focus / visibility lost (a focusable panel mounted by
+        #   ``add_renderable`` grabbed focus, or an ``InlineChoicePrompt``
+        #   left ``#input.-hidden`` stuck because its callback raised) —
+        #   reassert the prompt as focused-and-visible (Layer 11).
+        # Both checks are idempotent on a healthy app and skipped under
+        # headless tests where there's no live driver to talk to.
+        if not self.is_headless:
+            self.set_interval(
+                self._MOUSE_REENABLE_INTERVAL,
+                self._self_heal_terminal_state,
+            )
 
     def _replay_resumed_history(self, chat: ChatPane) -> None:
         """Render a resumed session's user/assistant text back into the chat.
@@ -527,7 +568,14 @@ class AruApp(App):
         suggestion and fires ``Input.Submitted``, which produced the
         "three Enters to run /help" glitch. Tab is the only key that
         accepts the highlighted suggestion.
+
+        Layer 12 — every keystroke is also a recovery opportunity. The
+        Layer 10 periodic tick still runs every ``_MOUSE_REENABLE_INTERVAL``
+        but a typing user wants the wheel back NOW, not in three seconds.
+        Debounced via ``_KEYPRESS_REARM_DEBOUNCE`` so a fast typist
+        doesn't amplify each keystroke into four extra terminal writes.
         """
+        self._maybe_rearm_mouse_on_keypress()
         try:
             completer = self.query_one(SlashCompleter)
         except Exception:
@@ -1069,23 +1117,192 @@ class AruApp(App):
             except Exception:
                 pass
             # Layer 9 self-heal — re-assert Textual's mouse-tracking
-            # sequences at every turn boundary. If any content path
-            # emitted a rogue DEC private-mode escape during the turn
-            # (``\x1b[?1000l`` or similar) the terminal would have
-            # silently disabled wheel reporting for every scroll area
-            # in the app, with no way for us to detect it. Calling the
-            # driver's enable-mouse path writes four short SGR sequences
-            # (``?1000h`` / ``?1003h`` / ``?1015h`` / ``?1006h``) and
-            # restores wheel input no matter what corrupted the state.
-            # Idempotent when mouse tracking was never disabled. See the
-            # Layer 9 post-mortem at the top of
-            # ``aru/tui/widgets/chat.py`` for the full analysis.
+            # sequences at the turn boundary. See ``_reenable_mouse_tracking``
+            # for the rationale; here we eagerly recover the moment the
+            # turn ends so the user's first post-turn scroll always works,
+            # without waiting for the periodic Layer 10 tick.
+            self._reenable_mouse_tracking()
+
+    # Layer 12 — DEC private-mode sequences for mouse tracking. Defined
+    # at class scope so both the off-then-on shake below and any future
+    # caller (Click handler, focus event) can reuse the exact same set
+    # without drift.
+    _MOUSE_DISABLE_SEQS: tuple[str, ...] = (
+        "\x1b[?1000l",
+        "\x1b[?1003l",
+        "\x1b[?1015l",
+        "\x1b[?1006l",
+    )
+    _MOUSE_ENABLE_SEQS: tuple[str, ...] = (
+        "\x1b[?1000h",
+        "\x1b[?1003h",
+        "\x1b[?1015h",
+        "\x1b[?1006h",
+    )
+
+    def _reenable_mouse_tracking(self) -> None:
+        """Re-arm mouse tracking via an off-then-on shake (Layer 12).
+
+        Pre-Layer-12 this method delegated to the driver's
+        ``_enable_mouse_support`` which writes four short SGR sequences
+        (``?1000h`` / ``?1003h`` / ``?1015h`` / ``?1006h``). That worked
+        when the terminal forwarded the writes verbatim, but the user
+        report on 2026-04-25 against
+        ``final-fantasy-9/.aru/sessions/b33dfb99`` was the wheel never
+        coming back even though Layer 9 (turn-boundary call) and Layer 10
+        (8s tick) both ran. Two failure modes the old code couldn't
+        recover from:
+
+        1. **ConPTY enable cache.** Windows ConPTY tracks DEC private-mode
+           state on its side and may treat ``?1000h`` as a no-op when its
+           cache says "already enabled" — even when the underlying
+           terminal lost the state. Sending ``?1000l`` first forces the
+           cache through a state transition so the subsequent ``?1000h``
+           is propagated.
+        2. **Driver-side gate.** ``WindowsDriver._enable_mouse_support``
+           opens with ``if not self._mouse: return`` (textual 8.2.4,
+           windows_driver.py:55). If a future Textual flips the gate
+           during shutdown / pause / alt-screen toggle, our recovery
+           silently no-ops. Going through ``driver.write`` bypasses the
+           gate and writes the bytes regardless.
+
+        Implementation: emit all four ``...l`` (off) sequences, then all
+        four ``...h`` (on) sequences, then flush. Eight short writes
+        (~64 bytes) bufferised into one terminal emit by ``WriterThread``.
+        Idempotent on a healthy terminal — the off→on cycle leaves the
+        final state identical to a single ``?1000h``, just with a
+        microscopic gap during the transition (no observable wheel-event
+        loss in practice).
+
+        Called from three sites:
+        * ``_run_turn`` finally-clause (Layer 9) — eager recovery at every
+          turn boundary so the first post-turn scroll always works.
+        * ``_self_heal_terminal_state`` periodic tick (Layer 10) — recovers
+          mid-turn corruption within ``_MOUSE_REENABLE_INTERVAL``.
+        * ``on_key`` keypress trigger (Layer 12) — recovers the moment the
+          user touches the keyboard, since a keystroke is a strong signal
+          they noticed the wheel is dead.
+
+        Wrapped in ``try/except`` because the driver may be ``None`` in
+        headless / test mode; we'd rather no-op silently than crash.
+        """
+        try:
+            driver = self._driver
+            if driver is None:
+                return
+            for seq in self._MOUSE_DISABLE_SEQS:
+                try:
+                    driver.write(seq)
+                except Exception:
+                    pass
+            for seq in self._MOUSE_ENABLE_SEQS:
+                try:
+                    driver.write(seq)
+                except Exception:
+                    pass
             try:
-                driver = self._driver
-                if driver is not None:
-                    driver._enable_mouse_support()
+                driver.flush()
             except Exception:
                 pass
+        except Exception:
+            pass
+
+    def _maybe_rearm_mouse_on_keypress(self) -> None:
+        """Layer 12 — re-arm mouse tracking on each keystroke (debounced).
+
+        Trigger fires from ``on_key`` so any user keypress is treated as a
+        recovery opportunity. A typing user is the strongest signal we
+        have that the wheel just stopped working — they reached for the
+        keyboard because the mouse stopped responding, or they're about
+        to scroll back with PgUp and want it ready. Either way, paying
+        ~64 bytes per keypress (capped at 2 Hz by ``_KEYPRESS_REARM_DEBOUNCE``)
+        is a trivial cost for sub-second recovery latency.
+
+        The debounce intentionally uses ``time.monotonic`` rather than the
+        Textual scheduler so it survives across the async ``on_key``
+        boundary without an extra task. ``-inf`` initial value guarantees
+        the first keystroke always rearms.
+        """
+        now = time.monotonic()
+        if now - self._last_mouse_reenable_at < self._KEYPRESS_REARM_DEBOUNCE:
+            return
+        self._last_mouse_reenable_at = now
+        self._reenable_mouse_tracking()
+
+    def _self_heal_terminal_state(self) -> None:
+        """Periodic recovery of mouse tracking and input focus (Layers 10 + 11).
+
+        Two failure classes that the tick recovers from:
+
+        1. **Terminal mouse-tracking lost.** Layer 9 already re-enables at
+           the turn boundary; this catches mid-turn corruption so the
+           wheel comes back within ``_MOUSE_REENABLE_INTERVAL`` instead
+           of waiting for the agent to finish.
+        2. **Input prompt invisible or unfocused** when nothing else
+           legitimately owns it. Three concrete scenarios this fixes:
+           * an ``InlineChoicePrompt`` callback raised before
+             ``on_unmount`` ran, leaving ``#input.-hidden`` stuck;
+           * a focusable panel mounted by ``add_renderable`` (pre-Layer-11
+             behaviour) grabbed focus and never released it;
+           * an exception during ``finalize_assistant_message`` cancelled
+             a focus-restore that ``_run_turn`` would normally do.
+
+        We only intervene when **no modal is on top** (modal owns input,
+        ``len(self.screen_stack) <= 1``) and **no ``InlineChoicePrompt``
+        is currently mounted** (the inline prompt legitimately steals
+        focus and hides the input by design — touching it mid-flight
+        would steal back from the user). When both conditions hold, we
+        treat the input as the canonical focus target.
+        """
+        # Layer 10 — mouse tracking.
+        self._reenable_mouse_tracking()
+
+        # Layer 11 — input watchdog. Skip if a modal is on top: the modal
+        # is the legitimate input owner and the underlying ``Input`` is
+        # not part of the active focus chain.
+        try:
+            if len(self.screen_stack) > 1:
+                return
+        except Exception:
+            return
+
+        # Skip if an ``InlineChoicePrompt`` is currently mounted: it has
+        # explicitly hidden the input and owns the focus while waiting
+        # for the user's choice. ``query`` returns an empty list when the
+        # widget tree has no match, so the truth-test is safe.
+        try:
+            from aru.tui.widgets.inline_choice import InlineChoicePrompt
+            if list(self.query(InlineChoicePrompt)):
+                return
+        except Exception:
+            pass
+
+        # Recover ``#input`` if it's stuck hidden (the ``-hidden`` class
+        # comes off only inside ``InlineChoicePrompt._toggle_input``; if
+        # that didn't run because the callback raised, the user is
+        # stranded with no visible prompt). ``remove_class`` on a class
+        # that isn't applied is a no-op, so the unconditional call is safe.
+        try:
+            inp = self.query_one(Input)
+        except Exception:
+            return
+        try:
+            if inp.has_class("-hidden"):
+                inp.remove_class("-hidden")
+        except Exception:
+            pass
+
+        # Re-focus only when *nothing* currently has focus. We deliberately
+        # do NOT yank focus away from a sidebar / scrollback / search
+        # screen the user navigated to themselves — that would fight
+        # legitimate keyboard navigation. The ``focused is None`` guard
+        # narrows the recovery to the ghost-focus state we actually
+        # observed in the bug.
+        try:
+            if self.screen.focused is None:
+                inp.focus()
+        except Exception:
+            pass
 
     # ── Bus wiring — ToolsPane + StatusPane subscribe to plugin events ──
 

aru_code-0.45.0/aru/tui/sanitize.py

@@ -0,0 +1,76 @@
+"""Terminal-output hygiene helpers used across the TUI.
+
+Layer 7 / Layer 9 / Layer 10 of the scroll-freeze post-mortem (see
+``aru/tui/widgets/chat.py`` for the full history) all hinge on the same
+invariant: **no string content originating from the agent, a tool, or
+arbitrary file content may reach the terminal with raw C0 control bytes
+intact.** A single stray ``\\x1b[?1000l`` switches X10 mouse reporting off
+on Windows ConPTY (and most modern emulators), at which point the wheel
+stops working in every scroll surface in the app simultaneously.
+
+The chat pane already protects everything that flows through
+``ChatMessageWidget.buffer`` and the ``add_renderable`` path, but modal
+screens (``ChoiceModal`` / ``ConfirmModal`` / ``TextInputModal``)
+historically built their ``Label`` / ``Static`` content from raw
+agent-provided strings — including the diff preview shown when an edit
+needs approval. Files containing escape bytes (colored scripts, captured
+terminal output, accidentally-saved binaries) flowed straight through to
+the terminal. Hence Layer 10: lift these helpers out of ``chat.py`` and
+apply them at every modal composition point too.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+
+# C0 controls (0x00-0x1F) and DEL (0x7F) are dropped on the way to the
+# terminal, EXCEPT ``\n`` and ``\t`` which carry semantic meaning to
+# markdown-it, Rich, and Textual layout. Implementation note:
+# ``str.translate`` is implemented in C and runs in microseconds for
+# multi-KB inputs — applying it at every boundary is essentially free.
+_CTRL_CHAR_TRANSLATION: dict[int, None] = {
+    c: None for c in range(32) if chr(c) not in ("\n", "\t")
+}
+_CTRL_CHAR_TRANSLATION[0x7F] = None
+
+
+def sanitize_for_terminal(raw: str) -> str:
+    """Remove non-printable C0 controls so rogue ANSI escapes can't reach the tty.
+
+    Keeps ``\\n`` and ``\\t``; drops everything else in the C0 range plus DEL.
+    Apply this at every boundary where externally-sourced text becomes a
+    Rich renderable / Textual widget content.
+    """
+    return raw.translate(_CTRL_CHAR_TRANSLATION)
+
+
+class SanitizedRenderable:
+    """Wraps a Rich renderable so its output segments are stripped of C0 bytes.
+
+    ``sanitize_for_terminal`` covers every plain string we render. Arbitrary
+    Rich renderables (panels, diff previews, plan summaries, the startup
+    logo) skip that path and would mount as ``Static(renderable)`` whose
+    segments hit the compositor unmodified — including any rogue escapes
+    embedded in the inner text.
+
+    This wrapper closes that gap at the segment level: ``console.render``
+    yields segments from the inner renderable, we strip C0 bytes from any
+    segment whose ``.text`` contains them, and re-emit the cleaned stream.
+    Rich's ``Segment`` is a ``NamedTuple`` so ``seg._replace(text=...)`` is
+    a cheap immutable swap. Unchanged segments are re-emitted unmodified —
+    the hot path is a single ``str.translate`` per segment which typically
+    no-ops.
+    """
+
+    def __init__(self, inner: Any) -> None:
+        self._inner = inner
+
+    def __rich_console__(self, console: Any, options: Any) -> Any:
+        for seg in console.render(self._inner, options):
+            if seg.text:
+                clean = sanitize_for_terminal(seg.text)
+                if clean != seg.text:
+                    yield seg._replace(text=clean)
+                    continue
+            yield seg

{aru_code-0.42.0 → aru_code-0.45.0}/aru/tui/screens/choice.py

@@ -12,6 +12,8 @@ from textual.screen import ModalScreen
 from textual.widgets import Label, OptionList, Static
 from textual.widgets.option_list import Option
 
+from aru.tui.sanitize import SanitizedRenderable, sanitize_for_terminal
+
 
 class ChoiceModal(ModalScreen[int | None]):
     """Numbered option menu. ``dismiss(int)`` returns the chosen index.
@@ -74,12 +76,27 @@ class ChoiceModal(ModalScreen[int | None]):
     def compose(self) -> ComposeResult:
         with Vertical(id="choice-box"):
             if self._title:
-                yield Label(self._title, id="choice-title")
+                # Sanitise: title may include agent-generated text (plan name,
+                # rejection reason, tool label) which can carry C0 escapes
+                # that would disable mouse tracking globally — see Layer 10
+                # in the chat.py post-mortem.
+                yield Label(
+                    sanitize_for_terminal(self._title),
+                    id="choice-title",
+                )
             if self._details is not None:
-                yield Static(self._details, id="choice-details")
+                # ``details`` is the diff preview / plan summary panel.
+                # Diffs over file content readily contain escape bytes when
+                # the file does (colored scripts, captured terminal output),
+                # making this the most likely entry point for the bug
+                # the periodic re-enable timer recovers from.
+                yield Static(
+                    SanitizedRenderable(self._details),
+                    id="choice-details",
+                )
             yield OptionList(
                 *[
-                    Option(label, id=str(i))
+                    Option(sanitize_for_terminal(label), id=str(i))
                     for i, label in enumerate(self._options)
                 ],
                 id="choice-options",

{aru_code-0.42.0 → aru_code-0.45.0}/aru/tui/screens/confirm.py

@@ -8,6 +8,8 @@ from textual.containers import Horizontal, Vertical
 from textual.screen import ModalScreen
 from textual.widgets import Button, Label
 
+from aru.tui.sanitize import sanitize_for_terminal
+
 
 class ConfirmModal(ModalScreen[bool]):
     """Yes / No dialog. ``dismiss(True)`` on yes, ``dismiss(False)`` on no.
@@ -53,7 +55,8 @@ class ConfirmModal(ModalScreen[bool]):
 
     def compose(self) -> ComposeResult:
         with Vertical(id="confirm-box"):
-            yield Label(self._prompt, id="confirm-prompt")
+            # Strip C0 controls — see Layer 10 in chat.py post-mortem.
+            yield Label(sanitize_for_terminal(self._prompt), id="confirm-prompt")
             with Horizontal(id="confirm-buttons"):
                 yield Button(
                     "Yes",

{aru_code-0.42.0 → aru_code-0.45.0}/aru/tui/screens/text_input.py

@@ -8,6 +8,8 @@ from textual.containers import Vertical
 from textual.screen import ModalScreen
 from textual.widgets import Input, Label
 
+from aru.tui.sanitize import sanitize_for_terminal
+
 
 class TextInputModal(ModalScreen[str | None]):
     """Single-line text prompt. ``dismiss(str)`` on Enter, ``dismiss(None)``
@@ -49,7 +51,8 @@ class TextInputModal(ModalScreen[str | None]):
 
     def compose(self) -> ComposeResult:
         with Vertical(id="text-box"):
-            yield Label(self._prompt, id="text-prompt")
+            # Strip C0 controls — see Layer 10 in chat.py post-mortem.
+            yield Label(sanitize_for_terminal(self._prompt), id="text-prompt")
             yield Input(
                 value=self._default,
                 placeholder=self._placeholder,