aru-code 0.46.0__tar.gz → 0.47.0__tar.gz

{aru_code-0.46.0/aru_code.egg-info → aru_code-0.47.0}/PKG-INFO

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

aru_code-0.47.0/aru/__init__.py

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

{aru_code-0.46.0 → aru_code-0.47.0}/aru/tui/app.py

@@ -647,6 +647,27 @@ class AruApp(App):
         if text.startswith("/") and self._maybe_run_local_slash(text):
             return
 
+        # Shell escape: ``! <command>`` runs the command locally in the
+        # session cwd and streams output into the chat. Mirrors the REPL
+        # path in ``cli.py`` so users can do quick ``! git status`` or
+        # ``! ls`` without a round-trip to the agent. The leading ``!``
+        # must be followed by whitespace so plain text starting with ``!``
+        # (rare but possible) still reaches the agent.
+        if text.startswith("!"):
+            cmd = text[1:].lstrip()
+            if not cmd:
+                self.query_one(ChatPane).add_system_message(
+                    "Usage: ! <command>"
+                )
+                return
+            if self._busy:
+                self.query_one(ChatPane).add_system_message(
+                    "Busy — wait for the current task to finish."
+                )
+                return
+            self._dispatch_shell_command(cmd)
+            return
+
         if self._busy:
             self.query_one(ChatPane).add_system_message(
                 "Agent is busy — wait for the current turn to finish."
@@ -963,6 +984,7 @@ class AruApp(App):
             "  /clear           clear chat pane",
             "  /plan            toggle plan mode",
             "  /quit  /exit     save session and exit",
+            "  ! <command>      run a shell command (output streams to chat)",
             "",
             "Shortcuts:",
             "  Ctrl+Q           quit",
@@ -1128,6 +1150,121 @@ class AruApp(App):
             # without waiting for the periodic Layer 10 tick.
             self._reenable_mouse_tracking()
 
+    # ── Shell escape (``! <command>``) ───────────────────────────────
+
+    def _dispatch_shell_command(self, command: str) -> None:
+        """Run ``command`` in the session cwd and stream output to chat.
+
+        Parity with the REPL's ``! <cmd>`` path in ``cli.py``: we render
+        a syntax-highlighted header, run the command via the system
+        shell, then push stdout/stderr (interleaved) into a single
+        system message that grows as lines arrive. The exit code is
+        appended on completion so the user can tell success from
+        failure.
+
+        Output is NOT persisted to ``session.history`` — the agent never
+        sees ``!`` shell runs (it has its own ``bash`` tool). This is a
+        user convenience, not part of the conversation.
+        """
+        chat = self.query_one(ChatPane)
+        try:
+            from rich.panel import Panel
+            from rich.syntax import Syntax
+            chat.add_renderable(Panel(
+                Syntax(command, "bash", theme="monokai"),
+                title="[bold]Shell[/bold]",
+                border_style="dim",
+                expand=False,
+            ))
+        except Exception:
+            chat.add_system_message(f"$ {command}")
+
+        from aru.tui.widgets.chat import ChatMessageWidget
+        live = ChatMessageWidget(role="system", initial="")
+        chat.mount(live)
+        self._busy = True
+        try:
+            self.query_one(ThinkingIndicator).busy = True
+        except Exception:
+            pass
+        self.run_worker(
+            self._run_shell_command(command, live),
+            name="shell-cmd",
+            exclusive=False,
+            group="shell",
+        )
+
+    async def _run_shell_command(
+        self, command: str, live: "ChatMessageWidget"
+    ) -> None:
+        """Spawn ``command`` and stream output into ``live`` line by line."""
+        import asyncio
+
+        try:
+            from aru.runtime import get_cwd
+            cwd = get_cwd()
+        except Exception:
+            import os
+            cwd = os.getcwd()
+
+        try:
+            proc = await asyncio.create_subprocess_shell(
+                command,
+                stdout=asyncio.subprocess.PIPE,
+                stderr=asyncio.subprocess.STDOUT,
+                cwd=cwd,
+            )
+        except Exception as exc:
+            live.buffer = f"[shell error] {type(exc).__name__}: {exc}"
+            self._busy = False
+            try:
+                self.query_one(ThinkingIndicator).busy = False
+            except Exception:
+                pass
+            return
+
+        assert proc.stdout is not None
+        buffer_lines: list[str] = []
+        try:
+            while True:
+                raw = await proc.stdout.readline()
+                if not raw:
+                    break
+                line = raw.decode("utf-8", errors="replace").rstrip("\r\n")
+                buffer_lines.append(line)
+                # Cap displayed buffer so a runaway command doesn't grow
+                # the widget until the chat pane stalls. Mirrors the
+                # ``bash`` tool's 10K-char output truncation.
+                joined = "\n".join(buffer_lines)
+                if len(joined) > 10_000:
+                    head = joined[:10_000]
+                    live.buffer = head + "\n... (truncated, still running)"
+                else:
+                    live.buffer = joined
+            await proc.wait()
+        except asyncio.CancelledError:
+            try:
+                proc.kill()
+            except Exception:
+                pass
+            live.buffer = (live.buffer or "") + "\n[interrupted]"
+            raise
+        except Exception as exc:
+            live.buffer = (live.buffer or "") + (
+                f"\n[shell error] {type(exc).__name__}: {exc}"
+            )
+        finally:
+            rc = proc.returncode if proc.returncode is not None else "?"
+            tail = f"\n[exit {rc}]"
+            current = live.buffer or ""
+            if not current.endswith(tail):
+                live.buffer = current + tail
+            self._busy = False
+            try:
+                self.query_one(ThinkingIndicator).busy = False
+            except Exception:
+                pass
+
     # Layer 14 — full set of DEC private modes that ``WindowsDriver
     # .start_application_mode`` enables at boot, minus alt-screen
     # (``?1049``, not idempotent — would save/restore the display

{aru_code-0.46.0 → aru_code-0.47.0/aru_code.egg-info}/PKG-INFO

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

{aru_code-0.46.0 → aru_code-0.47.0}/aru_code.egg-info/SOURCES.txt

@@ -174,6 +174,7 @@ tests/test_tui_mode_cycle.py
 tests/test_tui_native_selection.py
 tests/test_tui_permission_flow.py
 tests/test_tui_plan_task_render.py
+tests/test_tui_shell_bang.py
 tests/test_tui_sidebar_toggle.py
 tests/test_tui_slash_bridge.py
 tests/test_tui_snapshot_smoke.py

{aru_code-0.46.0 → aru_code-0.47.0}/pyproject.toml

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

aru_code-0.47.0/tests/test_tui_shell_bang.py

@@ -0,0 +1,183 @@
+"""Tests for the ``! <command>`` shell escape in the TUI.
+
+The TUI mirrors the REPL's ``! cmd`` path: typing ``! echo hi`` runs
+``echo hi`` locally (in the session cwd), streams output into the chat
+pane, and reports the exit code — without invoking the agent.
+"""
+
+from __future__ import annotations
+
+import sys
+
+import pytest
+
+pytest.importorskip("textual")
+
+
+@pytest.mark.asyncio
+async def test_bang_dispatches_shell_not_agent():
+    """``! cmd`` should run via _dispatch_shell_command, NOT _dispatch_user_turn."""
+    from aru.tui.app import AruApp
+    from textual.widgets import Input
+
+    captured: dict = {}
+
+    class _Probe(AruApp):
+        def _dispatch_user_turn(self, text: str) -> None:  # type: ignore[override]
+            captured["agent_text"] = text
+
+        def _dispatch_shell_command(self, cmd: str) -> None:  # type: ignore[override]
+            captured["shell_cmd"] = cmd
+
+    app = _Probe()
+    async with app.run_test() as pilot:
+        await pilot.pause()
+        inp = app.query_one(Input)
+        inp.post_message(Input.Submitted(inp, value="! echo hi"))
+        await pilot.pause()
+
+    assert captured.get("shell_cmd") == "echo hi"
+    assert "agent_text" not in captured
+
+
+@pytest.mark.asyncio
+async def test_bang_empty_command_warns():
+    """``! `` alone should show a usage message and not dispatch anything."""
+    from aru.tui.app import AruApp
+    from aru.tui.widgets.chat import ChatMessageWidget, ChatPane
+    from textual.widgets import Input
+
+    captured: dict = {}
+
+    class _Probe(AruApp):
+        def _dispatch_user_turn(self, text: str) -> None:  # type: ignore[override]
+            captured["agent_text"] = text
+
+        def _dispatch_shell_command(self, cmd: str) -> None:  # type: ignore[override]
+            captured["shell_cmd"] = cmd
+
+    app = _Probe()
+    async with app.run_test() as pilot:
+        await pilot.pause()
+        inp = app.query_one(Input)
+        inp.post_message(Input.Submitted(inp, value="!   "))
+        await pilot.pause()
+        chat = app.query_one(ChatPane)
+        msgs = list(chat.query(ChatMessageWidget))
+        joined = " ".join(m.buffer for m in msgs)
+
+    assert "Usage:" in joined
+    assert "shell_cmd" not in captured
+    assert "agent_text" not in captured
+
+
+@pytest.mark.asyncio
+async def test_bang_busy_blocks_dispatch():
+    """If the app is already busy, ``! cmd`` should refuse to start."""
+    from aru.tui.app import AruApp
+    from textual.widgets import Input
+
+    captured: dict = {}
+
+    class _Probe(AruApp):
+        def _dispatch_shell_command(self, cmd: str) -> None:  # type: ignore[override]
+            captured["shell_cmd"] = cmd
+
+    app = _Probe()
+    async with app.run_test() as pilot:
+        await pilot.pause()
+        app._busy = True
+        inp = app.query_one(Input)
+        inp.post_message(Input.Submitted(inp, value="! echo hi"))
+        await pilot.pause()
+
+    assert "shell_cmd" not in captured
+
+
+@pytest.mark.asyncio
+async def test_bang_runs_real_command_and_streams_output():
+    """End-to-end: a real shell command's output reaches the chat pane."""
+    from aru.tui.app import AruApp
+    from aru.tui.widgets.chat import ChatMessageWidget, ChatPane
+    from textual.widgets import Input
+
+    # Pick a command that works on both Windows and POSIX. ``python -c``
+    # avoids shell-specific syntax (echo behaves differently between
+    # cmd.exe and bash) and forces a known output line.
+    py = sys.executable.replace("\\", "/")
+    command = f'{py} -c "print(\'aru-shell-marker\')"'
+
+    app = AruApp()
+    async with app.run_test() as pilot:
+        await pilot.pause()
+        inp = app.query_one(Input)
+        inp.post_message(Input.Submitted(inp, value=f"! {command}"))
+        # Wait for the worker to finish — _busy flips back to False once
+        # the subprocess exits and the finally block runs.
+        for _ in range(200):
+            await pilot.pause(0.05)
+            if not app._busy:
+                break
+        chat = app.query_one(ChatPane)
+        msgs = list(chat.query(ChatMessageWidget))
+        joined = "\n".join(m.buffer for m in msgs)
+
+    assert "aru-shell-marker" in joined
+    assert "[exit 0]" in joined
+
+
+@pytest.mark.asyncio
+async def test_bang_does_not_persist_to_session_history():
+    """Shell runs are local — they must not land in session.history.
+
+    Otherwise the agent would see ``! ls``-style turns on the next
+    prompt and try to reason about them as if the user had said them.
+    """
+    from aru.tui.app import AruApp
+    from aru.session import Session
+    from textual.widgets import Input
+
+    app = AruApp()
+    async with app.run_test() as pilot:
+        await pilot.pause()
+        app.session = Session(session_id="test-shell-no-history")
+        inp = app.query_one(Input)
+        inp.post_message(Input.Submitted(inp, value="! echo hi"))
+        # Don't even need to wait for the worker — persistence (or lack
+        # thereof) is decided synchronously during dispatch.
+        await pilot.pause()
+        # Stop the worker promptly so the test exits cleanly.
+        try:
+            for w in list(app.workers):
+                w.cancel()
+        except Exception:
+            pass
+
+    user_msgs = [m for m in app.session.history if m.get("role") == "user"]
+    assert user_msgs == []
+
+
+@pytest.mark.asyncio
+async def test_bang_failing_command_reports_nonzero_exit():
+    """A command that exits non-zero should still surface an exit-code line."""
+    from aru.tui.app import AruApp
+    from aru.tui.widgets.chat import ChatMessageWidget, ChatPane
+    from textual.widgets import Input
+
+    py = sys.executable.replace("\\", "/")
+    command = f'{py} -c "import sys; sys.exit(7)"'
+
+    app = AruApp()
+    async with app.run_test() as pilot:
+        await pilot.pause()
+        inp = app.query_one(Input)
+        inp.post_message(Input.Submitted(inp, value=f"! {command}"))
+        for _ in range(200):
+            await pilot.pause(0.05)
+            if not app._busy:
+                break
+        chat = app.query_one(ChatPane)
+        msgs = list(chat.query(ChatMessageWidget))
+        joined = "\n".join(m.buffer for m in msgs)
+
+    assert "[exit 7]" in joined

aru_code-0.46.0/aru/__init__.py

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