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

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

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

aru_code-0.48.0/aru/__init__.py

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

{aru_code-0.46.0 → aru_code-0.48.0}/aru/runner.py

@@ -695,8 +695,14 @@ async def run_agent_capture(agent, message: str, session=None, lightweight: bool
             sink.exit()
         except Exception:
             pass
-        from rich.markup import escape
-        console.print(f"[red]Error: {escape(str(e))}[/red]")
+        # Route via the sink so the message reaches the right surface:
+        # REPL → Rich console; TUI → ChatPane system message (Textual
+        # hijacks stderr/stdout, so ``console.print`` would be invisible).
+        try:
+            sink.on_error(str(e))
+        except Exception:
+            from rich.markup import escape
+            console.print(f"[red]Error: {escape(str(e))}[/red]")
 
     # Final guard: if a plan is active and the agent ended its turn with
     # pending steps (without stalling), mark the session so the next turn's

{aru_code-0.46.0 → aru_code-0.48.0}/aru/session.py

@@ -565,7 +565,19 @@ class Session:
         self._live_cache_write_added = 0
 
     def _get_pricing(self) -> tuple[float, float, float, float]:
-        """Get per-million-token pricing for the current model."""
+        """Get per-million-token pricing for the current model.
+
+        Free models (e.g. OpenRouter `:free` variants like
+        `openrouter/minimax/minimax-m2.5:free`) report no cost. Detected by
+        the literal token "free" in the model ref or id — covers the `:free`
+        suffix convention plus any future provider that adopts the same
+        naming. None of the major paid models contain "free" in their id,
+        so false positives are negligible.
+        """
+        ref = (self.model_ref or "").lower()
+        mid = (self.model_id or "").lower()
+        if "free" in ref or "free" in mid:
+            return (0.0, 0.0, 0.0, 0.0)
         model_id = self.model_id
         # Try exact match, then prefix match, then fallback
         for prefix, pricing in MODEL_PRICING.items():

{aru_code-0.46.0 → aru_code-0.48.0}/aru/sinks.py

@@ -238,6 +238,11 @@ class RichLiveSink:
         else:
             target.print(message)
 
+    def on_error(self, message: str) -> None:
+        from rich.markup import escape
+        target = self._live.console if self._live is not None else self.console
+        target.print(f"[red]Error: {escape(message)}[/red]")
+
     def on_stream_finished(self, *, final_content: str) -> None:
         # Nothing to do here — runner flushes trailing markdown after exit()
         # using the accumulated content + display._flushed_len.

{aru_code-0.46.0 → aru_code-0.48.0}/aru/streaming.py

@@ -121,6 +121,14 @@ class StreamSink(Protocol):
         """Best-effort sideband user message (warnings etc.)."""
         ...
 
+    def on_error(self, message: str) -> None:
+        """Terminal error — runner caught an exception from the agent run.
+
+        REPL renders via Rich console; TUI must route to the ChatPane so
+        the user actually sees it (Textual hijacks stderr/stdout).
+        """
+        ...
+
     def on_stream_finished(self, *, final_content: str) -> None:
         """Run finished — sink may render any trailing markdown."""
         ...

{aru_code-0.46.0 → aru_code-0.48.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."
@@ -856,22 +877,76 @@ class AruApp(App):
         if session is None:
             self._push_chat("No session.", "model")
             return
+        from aru.providers import (
+            MODEL_ALIASES,
+            get_provider,
+            list_providers,
+            resolve_model_ref,
+        )
+
+        config = self.config
+        config_aliases = (getattr(config, "model_aliases", None) or {}) if config else {}
+
         body = body.strip()
         if not body:
-            current = getattr(session, "model_ref", "?")
-            self._push_chat(
-                f"Current model: {current}\n"
-                f"Usage: /model <provider/name>  (e.g. /model anthropic/claude-sonnet-4-5)",
-                "model",
-            )
+            lines = [
+                f"Current model: {session.model_display} ({session.model_id})",
+                "",
+            ]
+            if config_aliases:
+                lines.append("Model aliases (aru.json):")
+                for alias, ref in config_aliases.items():
+                    lines.append(f"  {alias} → {ref}")
+                lines.append("")
+            lines.append("Built-in aliases:")
+            for alias, ref in MODEL_ALIASES.items():
+                lines.append(f"  {alias} → {ref}")
+            lines.append("")
+            lines.append("Providers:")
+            for pkey, pconfig in list_providers().items():
+                dflt = pconfig.default_model or "—"
+                lines.append(f"  {pkey} ({pconfig.name}) — default: {dflt}")
+            lines.append("")
+            lines.append("Usage: /model <provider/name>  (e.g. /model anthropic/claude-sonnet-4-5, /model minimax)")
+            self._push_chat("\n".join(lines), "model")
             return
+
         try:
-            session.model_ref = body
+            arg_lower = body.lower()
+            resolved_ref = config_aliases.get(arg_lower, arg_lower) if config_aliases else arg_lower
+            provider_key, _ = resolve_model_ref(resolved_ref)
+            if get_provider(provider_key) is None:
+                available = ", ".join(sorted(list_providers().keys()))
+                self._push_chat(
+                    f"Unknown provider '{provider_key}'. Available: {available}",
+                    "model",
+                )
+                return
+            # Normalize to the fully-qualified ref so model_display + create_model
+            # see the right provider/model pair.
+            session.model_ref = resolved_ref if "/" in resolved_ref else (
+                MODEL_ALIASES.get(resolved_ref, resolved_ref)
+            )
             if self.ctx is not None:
                 self.ctx.model_id = session.model_id
+                small_ref = config_aliases.get("small")
+                if not small_ref:
+                    sp_key, _ = resolve_model_ref(session.model_ref)
+                    _small_defaults = {
+                        "anthropic": "anthropic/claude-haiku-4-5",
+                        "openai": "openai/gpt-4o-mini",
+                        "groq": "groq/llama-3.1-8b-instant",
+                        "deepseek": "deepseek/deepseek-chat",
+                        "ollama": "ollama/llama3.1",
+                    }
+                    small_ref = _small_defaults.get(sp_key, session.model_ref)
+                self.ctx.small_model_ref = small_ref
             status = self.query_one(StatusPane)
             status._refresh_from_session()
-            self._push_chat(f"Model switched to: {body}", "model")
+            self._push_chat(
+                f"Switched to {session.model_display} ({session.model_id})",
+                "model",
+            )
         except Exception as exc:
             self._push_chat(f"model switch failed: {exc}", "model")
 
@@ -963,6 +1038,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 +1204,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
@@ -1914,9 +2105,24 @@ async def run_tui(
     ctx.tui_app = app
     ctx.ui = TuiUI(app)
 
+    # Bridge logging → ChatPane so Agno's ERROR records (rate limits,
+    # provider errors, etc.) are visible to the user instead of vanishing
+    # into Textual's captured stderr. Detached in the finally block.
+    log_bridge_handlers: list = []
+    try:
+        from aru.tui.log_bridge import install_chat_log_bridge
+        log_bridge_handlers = install_chat_log_bridge(app)
+    except Exception:
+        pass
+
     try:
         await app.run_async()
     finally:
+        try:
+            from aru.tui.log_bridge import uninstall_chat_log_bridge
+            uninstall_chat_log_bridge(log_bridge_handlers)
+        except Exception:
+            pass
         ctx.tui_app = None
         ctx.ui = None
         try:

aru_code-0.48.0/aru/tui/log_bridge.py

@@ -0,0 +1,128 @@
+"""Logging → ChatPane bridge for TUI mode.
+
+Background
+----------
+Agno (and other libraries) report API errors via Python's ``logging``
+module — for example, an OpenRouter rate-limit looks like::
+
+    ERROR    Rate limit error from OpenAI API: Error code: 429 ...
+    ERROR    Error in Agent run: Provider returned error
+
+In REPL mode these records reach the user because Python's default log
+handler writes to ``sys.stderr`` and the terminal renders it directly.
+In TUI mode Textual takes over the alternate screen and captures stdout
+/ stderr — those ERROR lines vanish, leaving the user staring at a
+spinner that eventually stops without any message.
+
+This module installs a ``logging.Handler`` that forwards qualifying
+records into the running ``AruApp``'s ``ChatPane`` as system messages
+via ``app.call_from_thread``. The handler is idempotent (a marker
+attribute on each target logger prevents double-attachment when
+``run_tui`` is invoked twice in the same process, e.g. tests).
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+# Loggers we forward to chat. Keep this tight — capturing the root logger
+# would also pick up debug noise from libraries that log at WARNING for
+# routine state. We only want clearly-actionable messages.
+_BRIDGE_LOGGERS: tuple[str, ...] = ("agno", "aru")
+
+# Records below this level are dropped. ERROR is the right floor:
+# WARNING from Agno is often non-actionable (e.g. "tool call schema
+# coerced"). The user explicitly asked for transparency about *errors*.
+_BRIDGE_LEVEL = logging.ERROR
+
+# Sentinel attribute name set on a logger after we've attached our
+# handler, so re-running the install is a no-op.
+_INSTALLED_FLAG = "_aru_chat_bridge_installed"
+
+
+class _ChatPaneLogHandler(logging.Handler):
+    """Forward logging records into the TUI ChatPane.
+
+    Holds a weak reference semantically (we let the App outlive the
+    handler — the handler is detached in ``uninstall_chat_log_bridge``).
+    Failures inside ``emit`` are swallowed: a logging handler must never
+    raise, and the user can still see the error via Textual's own dev
+    log if they really need it.
+    """
+
+    def __init__(self, app: Any) -> None:
+        super().__init__(level=_BRIDGE_LEVEL)
+        self._app = app
+        self.setFormatter(logging.Formatter("%(name)s: %(message)s"))
+
+    def emit(self, record: logging.LogRecord) -> None:
+        try:
+            text = self.format(record)
+        except Exception:
+            try:
+                text = record.getMessage()
+            except Exception:
+                return
+        try:
+            from aru.tui.widgets.chat import ChatPane
+            chat = self._app.query_one(ChatPane)
+        except Exception:
+            return
+        try:
+            self._app.call_from_thread(
+                chat.add_system_message, f"Error: {text}"
+            )
+        except Exception:
+            # Last-resort direct call — safe when already on the loop
+            # and the App is still running. If even this raises, drop
+            # the record silently rather than crashing the producer.
+            try:
+                chat.add_system_message(f"Error: {text}")
+            except Exception:
+                return
+
+
+def install_chat_log_bridge(app: Any) -> list[logging.Handler]:
+    """Attach a ChatPane bridge to each target logger.
+
+    Returns the list of installed handlers so ``uninstall_chat_log_bridge``
+    can remove them on teardown. Idempotent per logger — if a previous
+    bridge from the same process is still attached, that logger is
+    skipped and only loggers without a bridge get a new handler.
+    """
+    installed: list[logging.Handler] = []
+    for name in _BRIDGE_LOGGERS:
+        logger = logging.getLogger(name)
+        if getattr(logger, _INSTALLED_FLAG, False):
+            continue
+        handler = _ChatPaneLogHandler(app)
+        logger.addHandler(handler)
+        # Make sure ERROR records actually fire — Agno ships at WARNING
+        # by default in cli.py, but a downstream user could lower it.
+        if logger.level == logging.NOTSET or logger.level > _BRIDGE_LEVEL:
+            logger.setLevel(_BRIDGE_LEVEL)
+        setattr(logger, _INSTALLED_FLAG, True)
+        installed.append(handler)
+    return installed
+
+
+def uninstall_chat_log_bridge(handlers: list[logging.Handler]) -> None:
+    """Detach the bridge handlers and clear the per-logger marker."""
+    for name in _BRIDGE_LOGGERS:
+        logger = logging.getLogger(name)
+        for h in list(logger.handlers):
+            if isinstance(h, _ChatPaneLogHandler):
+                logger.removeHandler(h)
+        if getattr(logger, _INSTALLED_FLAG, False):
+            try:
+                delattr(logger, _INSTALLED_FLAG)
+            except AttributeError:
+                pass
+    # Best-effort close so file descriptors etc. don't leak (we don't
+    # use any, but a custom subclass might).
+    for h in handlers:
+        try:
+            h.close()
+        except Exception:
+            pass

{aru_code-0.46.0 → aru_code-0.48.0}/aru/tui/sinks.py

@@ -130,6 +130,16 @@ class TextualBusSink:
         except Exception:
             pass
 
+    def on_error(self, message: str) -> None:
+        # Errors are routed to the ChatPane (persistent) instead of a
+        # Textual toast — under Textual, Agno's ERROR log lines never
+        # reach the terminal, so this is the user's only visible signal
+        # that something went wrong. Closing the active assistant bubble
+        # first prevents the streamed-but-empty assistant message from
+        # swallowing the error widget.
+        self._call(self.chat.finalize_assistant_message)
+        self._call(self.chat.add_system_message, f"Error: {message}")
+
     def on_stream_finished(self, *, final_content: str) -> None:
         self._call(self.chat.finalize_assistant_message, final_content or None)
 

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aru-code
-Version: 0.46.0
+Version: 0.48.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.48.0}/aru_code.egg-info/SOURCES.txt

@@ -69,6 +69,7 @@ aru/tools/web.py
 aru/tools/worktree.py
 aru/tui/__init__.py
 aru/tui/app.py
+aru/tui/log_bridge.py
 aru/tui/sanitize.py
 aru/tui/sinks.py
 aru/tui/slash_bridge.py
@@ -149,6 +150,7 @@ tests/test_runner_interrupt.py
 tests/test_runner_recovery.py
 tests/test_runtime.py
 tests/test_select.py
+tests/test_session_free_cost.py
 tests/test_skill_disallowed_tools.py
 tests/test_status_breakdown.py
 tests/test_status_cost.py
@@ -165,6 +167,7 @@ tests/test_tui_chat_adversarial.py
 tests/test_tui_completer.py
 tests/test_tui_completer_dynamic.py
 tests/test_tui_copy.py
+tests/test_tui_error_display.py
 tests/test_tui_input_behaviour.py
 tests/test_tui_layer12_recovery.py
 tests/test_tui_layer13_recovery.py
@@ -174,8 +177,10 @@ 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_slash_model.py
 tests/test_tui_snapshot_smoke.py
 tests/test_tui_thinking_and_boot.py
 tests/test_tui_widgets_visual.py

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

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

aru_code-0.48.0/tests/test_session_free_cost.py

@@ -0,0 +1,59 @@
+"""Free models must not accumulate dollar cost.
+
+Regression: ``Session._get_pricing`` previously fell through to
+``MODEL_PRICING["default"]`` (Sonnet-4.5 pricing) for any model id not
+present in the table. OpenRouter's `:free` variants like
+``openrouter/minimax/minimax-m2.5:free`` were therefore reported as
+quite expensive in the status bar and `/cost` panel even though the
+provider charges nothing.
+"""
+
+from __future__ import annotations
+
+import pytest
+
+from aru.session import Session
+
+
+def _consume(session: Session, *, inp: int, out: int) -> None:
+    session.total_input_tokens = inp
+    session.total_output_tokens = out
+
+
+def test_openrouter_free_variant_costs_zero():
+    session = Session()
+    session.model_ref = "openrouter/minimax/minimax-m2.5:free"
+    _consume(session, inp=100_000, out=50_000)
+    assert session.estimated_cost == 0.0
+
+
+def test_openrouter_free_nemotron_costs_zero():
+    session = Session()
+    session.model_ref = "openrouter/nvidia/nemotron-3-super-120b-a12b:free"
+    _consume(session, inp=200_000, out=10_000)
+    assert session.estimated_cost == 0.0
+
+
+def test_paid_anthropic_still_costs_real_money():
+    session = Session()
+    session.model_ref = "anthropic/claude-sonnet-4-5"
+    _consume(session, inp=100_000, out=50_000)
+    assert session.estimated_cost > 0.0
+
+
+def test_free_match_is_case_insensitive():
+    session = Session()
+    session.model_ref = "openrouter/minimax/minimax-m2.5:FREE"
+    _consume(session, inp=10_000, out=5_000)
+    assert session.estimated_cost == 0.0
+
+
+def test_free_with_cache_tokens_still_zero():
+    """All four price components must be zeroed, not just input/output."""
+    session = Session()
+    session.model_ref = "openrouter/minimax/minimax-m2.5:free"
+    session.total_input_tokens = 100_000
+    session.total_output_tokens = 50_000
+    session.total_cache_read_tokens = 30_000
+    session.total_cache_write_tokens = 20_000
+    assert session.estimated_cost == 0.0

{aru_code-0.46.0 → aru_code-0.48.0}/tests/test_streaming_sink.py

@@ -46,6 +46,9 @@ class RecordingSink:
     def notify(self, message: str, style: str = "") -> None:
         self.events.append(("notify", {"msg": message}))
 
+    def on_error(self, message: str) -> None:
+        self.events.append(("error", {"msg": message}))
+
     def on_stream_finished(self, *, final_content: str) -> None:
         self.events.append(("stream_finished", {"final": final_content}))