aru-code 0.55.0__tar.gz → 0.57.0__tar.gz

{aru_code-0.55.0/aru_code.egg-info → aru_code-0.57.0}/PKG-INFO

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

aru_code-0.57.0/aru/__init__.py

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

{aru_code-0.55.0 → aru_code-0.57.0}/aru/display.py

@@ -301,13 +301,16 @@ class ToolTracker:
         self._completed: list[tuple[str, float]] = []      # (label, duration)
 
     def start(self, tool_id: str, label: str):
-        self._active[tool_id] = (label, time.monotonic())
+        # perf_counter, not monotonic: on Windows monotonic() has ~15.6ms
+        # resolution, so a sub-tick tool call would report a 0.0 duration.
+        # perf_counter is monotonic too but high-resolution (~100ns).
+        self._active[tool_id] = (label, time.perf_counter())
 
     def complete(self, tool_id: str) -> tuple[str, float] | None:
         entry = self._active.pop(tool_id, None)
         if entry:
             label, start = entry
-            duration = time.monotonic() - start
+            duration = time.perf_counter() - start
             self._completed.append((label, duration))
             return label, duration
         return None
@@ -315,7 +318,7 @@ class ToolTracker:
     @property
     def active_labels(self) -> list[tuple[str, float]]:
         """Return (label, elapsed_seconds) for each active tool."""
-        now = time.monotonic()
+        now = time.perf_counter()
         return [(label, now - start) for label, start in self._active.values()]
 
     def pop_completed(self) -> list[tuple[str, float]]:

{aru_code-0.55.0 → aru_code-0.57.0}/aru/tools/plan_mode.py

@@ -24,6 +24,7 @@ specialized read-only tool set and instructions.
 
 from __future__ import annotations
 
+import asyncio
 import sys
 
 from rich.panel import Panel
@@ -197,7 +198,18 @@ async def exit_plan_mode(plan: str) -> str:
     session.set_plan(task=task_label, plan_content=plan_text)
     n_steps = len(session.plan_steps)
 
-    approved, feedback = _prompt_plan_approval(session.plan_steps, n_steps)
+    # ``exit_plan_mode`` is an async tool, so ``agent_factory`` awaits it
+    # directly on the event-loop thread (no ``_thread_tool`` worker hop like
+    # sync tools get). ``_prompt_plan_approval`` is synchronous and in TUI
+    # mode invokes ``TuiUI.ask_choice`` → ``App.call_from_thread``, which
+    # raises "must run in a different thread from the app" when called from
+    # the loop thread it targets. Hop to a worker thread first so the modal
+    # dispatch path matches the sync-tool and runner-auto-exit paths
+    # (``runner.py`` does the same). ``asyncio.to_thread`` copies the
+    # contextvars snapshot, so ``get_ctx()`` inside still resolves.
+    approved, feedback = await asyncio.to_thread(
+        _prompt_plan_approval, session.plan_steps, n_steps
+    )
 
     # The approval prompt already rendered the plan panel inline, so suppress
     # the runner's coalesced end-of-batch render to avoid a duplicate.

{aru_code-0.55.0 → aru_code-0.57.0}/aru/tui/app.py

@@ -873,14 +873,45 @@ class AruApp(App):
         return False
 
     def _run_bridged_slash(self, name: str, body: str) -> None:
-        """Execute a bridged REPL handler and show its output in ChatPane."""
+        """Execute a bridged REPL handler and show its output in ChatPane.
+
+        Dispatched as a coroutine worker so the handler runs OFF the
+        event-loop thread. Some bridged handlers prompt — ``/memory clear``
+        calls ``ctx.ui.confirm``, which bridges to the App loop via
+        ``App.call_from_thread`` and therefore *must* be invoked from a
+        thread other than the loop (otherwise it raises, or degrades to the
+        cancel default — see ``TuiUI._on_app_thread``). The worker hops the
+        handler to a thread via ``asyncio.to_thread`` so the loop stays free
+        to draw and service the modal, then marshals the captured output
+        back to the ChatPane.
+        """
+        from aru.tui.slash_bridge import BRIDGED_COMMANDS
+
+        if name.lower() not in BRIDGED_COMMANDS:
+            return
+        self.run_worker(
+            self._run_bridged_slash_async(name, body),
+            name=f"slash-{name}",
+            group="slash-bridge",
+            exclusive=False,
+        )
+
+    async def _run_bridged_slash_async(self, name: str, body: str) -> None:
+        """Worker body for :meth:`_run_bridged_slash` — see its docstring."""
         from aru.tui.slash_bridge import run_bridged
 
-        handled, text = run_bridged(name, body, self)
+        # Hop to a worker thread: the handler may block on a ``ctx.ui``
+        # prompt whose ModalScreen dispatch needs the loop to stay
+        # responsive. ``asyncio.to_thread`` copies the contextvars snapshot
+        # so the handler's ``get_ctx()`` still resolves.
+        handled, text = await asyncio.to_thread(run_bridged, name, body, self)
         if not handled:
             return
-        chat = self.query_one(ChatPane)
-        # Prefix with the command so the user has context.
+        # Back on the loop after the await — safe to touch widgets.
+        try:
+            chat = self.query_one(ChatPane)
+        except Exception:
+            return
         header = f"/{name}" + (f" {body}" if body else "")
         chat.add_system_message(f"$ {header}\n{text}" if text else f"$ {header}")
 

{aru_code-0.55.0 → aru_code-0.57.0}/aru/tui/slash_bridge.py

@@ -119,7 +119,17 @@ def run_bridged(name: str, body: str, app: Any) -> tuple[bool, str]:
 
     import aru.commands as cmds_module
     original_console = cmds_module.console
-    temp = Console(record=True, width=100, force_terminal=True, color_system=None)
+    # ``file=StringIO()`` keeps the live output off the raw terminal — we
+    # only want the recorded copy (``export_text`` below), which we mirror
+    # into the ChatPane. Writing to stdout here is pointless under Textual
+    # (it owns the screen) and outright unsafe now that the handler runs on
+    # a worker thread; ``record=True`` still captures everything regardless
+    # of the file target.
+    import io
+    temp = Console(
+        record=True, width=100, force_terminal=True, color_system=None,
+        file=io.StringIO(),
+    )
     cmds_module.console = temp
     try:
         handler(*args, **kwargs)

{aru_code-0.55.0 → aru_code-0.57.0}/aru/tui/ui.py

@@ -23,10 +23,14 @@ Contract notes:
 
 from __future__ import annotations
 
+import asyncio
+import logging
 from typing import Any, Sequence
 
 from aru.tui.screens import ChoiceModal, ConfirmModal, TextInputModal
 
+_log = logging.getLogger("aru.tui.ui")
+
 
 class TuiUI:
     """UIAdapter backed by Textual ModalScreens."""
@@ -34,6 +38,28 @@ class TuiUI:
     def __init__(self, app: Any) -> None:
         self.app = app
 
+    @staticmethod
+    def _on_app_thread() -> bool:
+        """True when the caller is running on an asyncio event-loop thread.
+
+        ``TuiUI``'s blocking prompts bridge to the App loop via
+        ``App.call_from_thread``, which *requires* the caller to be on a
+        DIFFERENT thread than the loop (otherwise it raises rather than
+        deadlock). The correct callers reach us from ``asyncio.to_thread`` /
+        ``_thread_tool`` workers — plain threads with no running loop. If a
+        loop IS running in this thread, we are on the App's own event-loop
+        thread and must not block: that would freeze the loop so the prompt
+        could never be drawn or answered. The guards below degrade safely in
+        that case instead of surfacing the cryptic ``call_from_thread``
+        ``RuntimeError``. The real fix for any such caller is to wrap the
+        call in ``await asyncio.to_thread(ctx.ui.<method>, ...)``.
+        """
+        try:
+            asyncio.get_running_loop()
+            return True
+        except RuntimeError:
+            return False
+
     # ── choice ────────────────────────────────────────────────────────
 
     def ask_choice(
@@ -88,6 +114,19 @@ class TuiUI:
         user answers, mirroring ``_run_modal`` so the sync call sites
         (``check_permission``, plan approval) keep their contract.
         """
+        if self._on_app_thread():
+            # Contract violation (see ``_on_app_thread``): a caller dispatched
+            # this blocking prompt from the App's own event-loop thread. We
+            # cannot show it here, so degrade to ``cancel_value`` rather than
+            # crash the turn with ``call_from_thread``'s RuntimeError.
+            _log.warning(
+                "TuiUI.ask_choice invoked on the event-loop thread; returning "
+                "cancel_value=%r without prompting. Wrap the call site in "
+                "asyncio.to_thread.",
+                cancel_value,
+            )
+            return cancel_value
+
         import threading
 
         from aru.tui.widgets.chat import ChatPane
@@ -252,6 +291,18 @@ class TuiUI:
         we work without an active Textual worker context. Designed to be
         called from ``asyncio.to_thread`` tool threads.
         """
+        if self._on_app_thread():
+            # See ``_on_app_thread``: blocking on the loop thread would
+            # freeze the App. Degrade to ``None`` (callers map this to their
+            # default / cancel outcome) instead of raising.
+            _log.warning(
+                "TuiUI modal (%s) invoked on the event-loop thread; "
+                "dismissing without prompting. Wrap the call site in "
+                "asyncio.to_thread.",
+                type(modal).__name__,
+            )
+            return None
+
         import threading
 
         done = threading.Event()

{aru_code-0.55.0 → aru_code-0.57.0/aru_code.egg-info}/PKG-INFO

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

{aru_code-0.55.0 → aru_code-0.57.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "aru-code"
-version = "0.55.0"
+version = "0.57.0"
 description = "A Claude Code clone built with Agno agents"
 readme = "README.md"
 license = "MIT"

{aru_code-0.55.0 → aru_code-0.57.0}/tests/test_plan_mode_refactor.py

@@ -245,6 +245,60 @@ class TestExitPlanMode:
         assert "needs more detail" in result
         assert "STILL in plan mode" in result
 
+    @pytest.mark.asyncio
+    async def test_approval_prompt_runs_off_event_loop_thread(self):
+        """Regression: the approval prompt must run on a worker thread, never
+        the event-loop thread.
+
+        ``exit_plan_mode`` is an async tool awaited directly on the loop. In
+        TUI mode ``_prompt_plan_approval`` reaches ``TuiUI.ask_choice`` →
+        ``App.call_from_thread``, which raises "must run in a different
+        thread from the app" when called on the loop thread. The fix hops to
+        a worker via ``asyncio.to_thread``; this test asserts the prompt
+        observes a thread id different from the loop's. Before the fix the
+        ids matched and TUI users hit the RuntimeError.
+        """
+        import threading
+
+        from aru.runtime import RuntimeContext, _runtime_ctx as _ctx
+        from aru.tools import plan_mode as plan_mode_module
+
+        loop_thread_id = threading.get_ident()
+        captured: dict = {}
+
+        def _fake_prompt(plan_steps, n_steps):
+            # Runs inside exit_plan_mode's approval call. Record the thread.
+            captured["thread_id"] = threading.get_ident()
+            # Also prove get_ctx() still resolves across the to_thread hop.
+            from aru.runtime import get_ctx
+            captured["has_ctx_session"] = get_ctx().session is not None
+            return (True, "")
+
+        session = Session()
+        session.plan_mode = True
+        ctx = RuntimeContext()
+        ctx.session = session
+        token = _ctx.set(ctx)
+        with patch.object(plan_mode_module, "_prompt_plan_approval", _fake_prompt):
+            try:
+                result = await plan_mode_module.exit_plan_mode(
+                    plan="## Steps\n1. do thing\n2. other thing"
+                )
+            finally:
+                _ctx.reset(token)
+
+        assert "thread_id" in captured, "approval prompt was never invoked"
+        assert captured["thread_id"] != loop_thread_id, (
+            "approval prompt ran on the event-loop thread — "
+            "TuiUI.ask_choice's call_from_thread would raise in TUI mode"
+        )
+        assert captured["has_ctx_session"], (
+            "contextvars must propagate across asyncio.to_thread so the "
+            "prompt can still read ctx.session"
+        )
+        assert session.plan_mode is False
+        assert "approved" in result.lower()
+
 
 # ── Tool-wrapper plan-mode gate ───────────────────────────────────────
 

{aru_code-0.55.0 → aru_code-0.57.0}/tests/test_tui_permission_flow.py

@@ -9,6 +9,33 @@ import pytest
 pytest.importorskip("textual")
 
 
+async def _wait_for_inline_focus(app, pilot, *, max_iter: int = 50):
+    """Block until the InlineChoicePrompt's OptionList owns focus.
+
+    ``query(InlineChoicePrompt)`` returns the widget as soon as it is in
+    the DOM, but the OptionList only gains focus (and its default
+    highlight) inside ``InlineChoicePrompt.on_mount`` — a message
+    dispatched *after* mount completes. Pressing Enter / arrow keys
+    before that lands sends the key nowhere useful: ``OptionSelected``
+    never fires and the worker thread blocks until its timeout. In
+    isolation the gap is sub-tick so the press always lands; under a
+    loaded suite the mount lifecycle slips behind detection and the test
+    flakes with a TimeoutError. Waiting for focus closes the race.
+    """
+    from textual.widgets import OptionList
+
+    from aru.tui.widgets.inline_choice import InlineChoicePrompt
+
+    for _ in range(max_iter):
+        prompts = list(app.query(InlineChoicePrompt))
+        if prompts:
+            opts = list(prompts[0].query(OptionList))
+            if opts and app.focused is opts[0] and opts[0].highlighted is not None:
+                return opts[0]
+        await pilot.pause(0.05)
+    raise AssertionError("InlineChoicePrompt OptionList never took focus")
+
+
 @pytest.mark.asyncio
 async def test_tui_ask_choice_from_worker_resolves_via_modal():
     """TuiUI.ask_choice invoked from a worker thread returns modal result.
@@ -106,6 +133,9 @@ async def test_ask_choice_with_details_uses_inline_prompt_not_modal():
             "expected InlineChoicePrompt in ChatPane"
         )
         # Press Enter — OptionList focuses on mount, default=0 highlighted.
+        # Wait for that focus to actually land first; querying the prompt
+        # only proves it is in the DOM (see _wait_for_inline_focus).
+        await _wait_for_inline_focus(app, pilot)
         await pilot.press("enter")
         await asyncio.wait_for(task, timeout=5.0)
     assert holder["choice"] == 0
@@ -156,6 +186,7 @@ async def test_inline_prompt_hides_input_bar_and_restores_on_answer():
         assert inp.has_class("-hidden"), (
             "input should be hidden while InlineChoicePrompt is mounted"
         )
+        await _wait_for_inline_focus(app, pilot)
         await pilot.press("enter")
         await asyncio.wait_for(task, timeout=5.0)
         # After the user answers, the input bar is restored.
@@ -199,6 +230,7 @@ async def test_ask_choice_inline_esc_cancels_with_cancel_value():
             await pilot.pause(0.05)
             if list(app.query_one(ChatPane).query(InlineChoicePrompt)):
                 break
+        await _wait_for_inline_focus(app, pilot)
         await pilot.press("escape")
         await asyncio.wait_for(task, timeout=5.0)
     assert holder["choice"] == 99
@@ -257,6 +289,7 @@ async def test_auto_accept_inline_choice_updates_status_pane_mode():
             if list(chat.query(InlineChoicePrompt)):
                 break
         # Option index 1 = "Yes, and auto-accept edits".
+        await _wait_for_inline_focus(app, pilot)
         await pilot.press("down")
         await pilot.press("enter")
         await asyncio.wait_for(task, timeout=5.0)
@@ -320,6 +353,7 @@ async def test_thinking_spinner_hidden_while_prompt_open():
             "spinner must be hidden while the permission prompt is open"
         )
 
+        await _wait_for_inline_focus(app, pilot)
         await pilot.press("enter")
         await asyncio.wait_for(task, timeout=5.0)
         for _ in range(20):
@@ -332,6 +366,53 @@ async def test_thinking_spinner_hidden_while_prompt_open():
     assert holder["choice"] == 0
 
 
+@pytest.mark.asyncio
+async def test_blocking_prompt_on_event_loop_thread_degrades_not_raises():
+    """Defense-in-depth (bug class): a blocking TuiUI prompt invoked directly
+    on the App's event-loop thread must NOT raise the cryptic
+    'call_from_thread must run in a different thread' RuntimeError.
+
+    The correct fix for any *known* caller is to hop to a worker thread
+    (asyncio.to_thread) — this guard is the safety net that keeps a stray
+    on-loop call (e.g. the /memory clear slash bridge) from crashing a turn.
+    It degrades to cancel_value / the caller default instead.
+    """
+    from rich.panel import Panel
+
+    from aru.tui.ui import TuiUI
+
+    class _DummyApp:
+        # If the guard fails, _run_inline_choice/_run_modal would reach this
+        # and we'd see the assertion instead of a clean degrade.
+        def call_from_thread(self, *args, **kwargs):
+            raise AssertionError(
+                "call_from_thread must not be reached on the loop thread"
+            )
+
+    ui = TuiUI(_DummyApp())
+    # This coroutine runs on the event loop, so we ARE on the loop thread.
+    assert TuiUI._on_app_thread() is True
+
+    # Inline path (details present) — the exact shape of the plan-approval /
+    # edit-permission prompt. Degrades to cancel_value.
+    inline = ui.ask_choice(
+        ["Yes", "No"],
+        title="Approve?",
+        default=0,
+        cancel_value=99,
+        details=Panel("preview"),
+    )
+    assert inline == 99
+
+    # Modal path (no details) — degrades to None.
+    modal = ui.ask_choice(["Yes", "No"], title="Pick", default=0, cancel_value=None)
+    assert modal is None
+
+    # confirm() maps the degraded None back to the caller's default.
+    assert ui.confirm("Proceed?", default=True) is True
+    assert ui.confirm("Proceed?", default=False) is False
+
+
 @pytest.mark.asyncio
 async def test_tui_confirm_from_worker_returns_bool():
     from aru.tui.app import AruApp
@@ -356,3 +437,67 @@ async def test_tui_confirm_from_worker_returns_bool():
         await pilot.press("y")
         await asyncio.wait_for(worker_task, timeout=5.0)
     assert result_holder["answer"] is True
+
+
+@pytest.mark.asyncio
+async def test_memory_clear_slash_shows_confirm_modal_and_clears():
+    """Regression: ``/memory clear`` in the TUI must actually show the
+    ConfirmModal (and clear on "yes"), not silently degrade.
+
+    The slash bridge used to run handlers inline on the event-loop thread,
+    so ``handle_memory_command`` → ``ui.confirm`` → ``call_from_thread``
+    raised / degraded to the cancel default and the modal never appeared.
+    The bridge now hops the handler to a worker thread (``_run_bridged_slash``
+    → ``asyncio.to_thread``), so the modal is dispatched correctly and the
+    user's answer is honoured.
+    """
+    from unittest.mock import patch
+
+    from aru.runtime import init_ctx, set_ctx
+    from aru.session import Session
+    from aru.tui.app import AruApp
+    from aru.tui.screens import ConfirmModal
+    from aru.tui.ui import TuiUI
+
+    ctx = init_ctx()
+    session = Session()
+    session.project_root = "/tmp/aru-memory-clear-test"
+    app = AruApp(ctx=ctx, session=session)
+    ctx.tui_app = app
+
+    cleared: dict = {}
+
+    def _fake_clear(project_root, *args, **kwargs):
+        cleared["root"] = project_root
+        return 3
+
+    async with app.run_test() as pilot:
+        await pilot.pause()
+        ctx.ui = TuiUI(app)
+        set_ctx(ctx)  # ensure the worker task + its to_thread child inherit ctx
+        # Patch the destructive clear so the test never touches real memory;
+        # the patch stays active across the awaits below, covering the
+        # handler's execution on the worker thread.
+        with patch("aru.memory.store.clear_memory", _fake_clear):
+            app._run_bridged_slash("memory", "clear")
+            # The crux of the fix: the modal actually appears. Before the
+            # fix the handler ran on the loop thread and degraded silently.
+            for _ in range(60):
+                await pilot.pause(0.05)
+                if app.screen_stack and isinstance(app.screen, ConfirmModal):
+                    break
+            assert isinstance(app.screen, ConfirmModal), (
+                "ConfirmModal never appeared — /memory clear degraded instead "
+                "of prompting (handler ran on the event-loop thread)"
+            )
+            # Answer "yes" and let the worker finish + run the (patched) clear.
+            await pilot.press("y")
+            for _ in range(60):
+                await pilot.pause(0.05)
+                if "root" in cleared:
+                    break
+
+    assert "root" in cleared, (
+        "clear_memory was never called — the 'yes' answer did not propagate "
+        "back through the worker to the handler"
+    )

aru_code-0.55.0/aru/__init__.py

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