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

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

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

aru_code-0.51.0/aru/__init__.py

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

{aru_code-0.47.0 → aru_code-0.51.0}/aru/config.py

@@ -180,6 +180,16 @@ class AgentConfig:
     # Formatter config per language (Tier 3 #1). Same shape as `lsp`, plus
     # an `enabled` top-level boolean to flip auto-format on/off in aggregate.
     format: dict[str, Any] = field(default_factory=dict)
+    # TUI theme name (one of the presets in `aru/tui/themes.py`). When unset
+    # the App keeps Textual's default. Hot-reloadable via the `/theme` slash
+    # command, but the persisted choice lives in `aru.json`.
+    theme: str = ""
+    # OS notification policy: "off" | "background" | "long" | "always".
+    # See `aru/tui/notifications.py` for the threshold logic.
+    notify: str = "background"
+    # Minimum turn duration (seconds) to ring the bell when `notify: long`
+    # or `notify: always`. Default 30s — short turns don't warrant a chime.
+    notify_threshold_sec: float = 30.0
 
     @property
     def has_instructions(self) -> bool:
@@ -545,6 +555,19 @@ def _apply_config_data(config: AgentConfig, data: dict, root: Path) -> None:
         config.lsp = data["lsp"]
     if "format" in data and isinstance(data["format"], dict):
         config.format = data["format"]
+    if "theme" in data and isinstance(data["theme"], str):
+        config.theme = data["theme"].strip()
+    if "notify" in data and isinstance(data["notify"], str):
+        nv = data["notify"].strip().lower()
+        if nv in ("off", "background", "long", "always"):
+            config.notify = nv
+    if "notify_threshold_sec" in data:
+        try:
+            v = float(data["notify_threshold_sec"])
+            if v > 0:
+                config.notify_threshold_sec = v
+        except (TypeError, ValueError):
+            pass
     if "instructions" in data and isinstance(data["instructions"], list):
         entries = [str(e) for e in data["instructions"] if isinstance(e, str)]
         config.rules_instructions = _resolve_instructions(entries, root)

{aru_code-0.47.0 → aru_code-0.51.0}/aru/display.py

@@ -25,7 +25,7 @@ aru_logo = """
 """
 
 neon_green = "#39ff14"
-shadow_green = "#042800"
+shadow_green = "#073e00"
 
 
 def _build_logo_with_shadow(logo_text: str) -> Text:

aru_code-0.51.0/aru/doom_loop.py

@@ -0,0 +1,137 @@
+"""Doom-loop detection: catch agents stuck repeating identical tool calls.
+
+A *doom-loop* is the agent invoking the same tool with the same arguments
+N times in a row, with no intervening different call. The model has lost
+the plot — typically because a tool kept failing and the model forgot it
+already tried that exact thing — and without intervention the run will
+just burn budget until the context window fills.
+
+This module gives the runner a cheap, deterministic detector. The
+heuristic mirrors OpenCode's ``session/processor.ts:188-211``:
+
+* keep a sliding window of the last N (tool_name, sorted-args) pairs;
+* when the window is full and every entry equals the latest one, fire.
+
+When detection fires the runner pauses, asks the user "continue or
+abort?", and either resets the buffer for that tool (allowing the model
+a fresh chance) or aborts the run.
+
+Threshold is **3** by default — same as OpenCode. Override per-process
+via the ``ARU_DOOM_LOOP_THRESHOLD`` env var (must be ≥ 2; values below
+fall back to the default to avoid pathologically eager prompts).
+
+Args equality uses ``json.dumps(..., sort_keys=True)`` so two calls with
+the same logical args but differing key order — ``{"a": 1, "b": 2}`` vs
+``{"b": 2, "a": 1}`` — are correctly treated as identical. ``default=str``
+keeps non-JSON values (e.g. Path) from raising; the resulting string is
+still a stable signature for equality.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+from collections import deque
+from typing import Any
+
+
+DEFAULT_THRESHOLD = 3
+_ENV_VAR = "ARU_DOOM_LOOP_THRESHOLD"
+
+
+def _stable_signature(tool_name: str, tool_args: Any) -> tuple[str, str]:
+    """Return a hashable equality signature for a tool invocation.
+
+    The args portion is a JSON dump with ``sort_keys=True`` so two calls
+    that differ only by key order in the args dict are treated as equal.
+    Non-JSON values (Paths, datetimes, etc.) are stringified so the dump
+    never raises — the goal is a stable signature, not a round-trippable
+    payload.
+    """
+    if isinstance(tool_args, dict):
+        try:
+            args_repr = json.dumps(tool_args, sort_keys=True, default=str)
+        except Exception:
+            # json.dumps can still fail on truly exotic values (e.g.
+            # circular refs). Fallback to repr — less stable but never
+            # raises, and the detector tolerates occasional mismatches.
+            args_repr = repr(sorted(tool_args.items()))
+    elif tool_args is None:
+        args_repr = "null"
+    else:
+        # Non-dict args (rare — Agno usually wraps in a dict) — just str.
+        args_repr = str(tool_args)
+    return (tool_name or "", args_repr)
+
+
+def threshold_from_env() -> int:
+    """Read ``ARU_DOOM_LOOP_THRESHOLD`` or return the default.
+
+    Values < 2 fall back to the default — a threshold of 1 would fire on
+    the very first call which is meaningless, and a threshold of 0 makes
+    the deque() unbounded. Invalid values (non-int) also fall back.
+    """
+    raw = os.environ.get(_ENV_VAR)
+    if raw is None:
+        return DEFAULT_THRESHOLD
+    try:
+        v = int(raw)
+    except ValueError:
+        return DEFAULT_THRESHOLD
+    if v < 2:
+        return DEFAULT_THRESHOLD
+    return v
+
+
+class DoomLoopDetector:
+    """Sliding-window detector for repeated identical tool calls.
+
+    Each ``record(tool_name, tool_args)`` call appends a signature to the
+    window and returns ``True`` iff the window is now full **and** every
+    entry in it is identical (i.e. the last N calls were the exact same
+    tool with the exact same args).
+
+    The detector is stateless beyond its window — there is no notion of
+    sessions or scopes. The runner instantiates one detector per turn of
+    the primary agent loop; sub-agents that run their own arun loop
+    (delegate.py) get their own detector via the same wiring.
+    """
+
+    def __init__(self, threshold: int | None = None) -> None:
+        self.threshold: int = threshold if threshold is not None else threshold_from_env()
+        self._recent: deque[tuple[str, str]] = deque(maxlen=self.threshold)
+
+    def record(self, tool_name: str, tool_args: Any) -> bool:
+        """Append a call's signature; return True if a doom-loop is now detected."""
+        sig = _stable_signature(tool_name, tool_args)
+        self._recent.append(sig)
+        if len(self._recent) < self.threshold:
+            return False
+        first = self._recent[0]
+        return all(s == first for s in self._recent)
+
+    def reset(self) -> None:
+        """Forget all recorded calls. Used after manual intervention."""
+        self._recent.clear()
+
+    def reset_for_tool(self, tool_name: str) -> None:
+        """Drop every entry whose tool_name equals *tool_name*.
+
+        Called after the user chooses *continue* on a doom-loop prompt:
+        the buffer is wiped for that specific tool so the very next call
+        doesn't immediately re-trigger the same prompt. Other tools'
+        history (which were not part of the loop) is preserved so a
+        secondary loop on a different tool still detects.
+        """
+        kept = [s for s in self._recent if s[0] != tool_name]
+        self._recent = deque(kept, maxlen=self.threshold)
+
+    def __len__(self) -> int:  # convenience for tests
+        return len(self._recent)
+
+
+__all__ = [
+    "DEFAULT_THRESHOLD",
+    "DoomLoopDetector",
+    "threshold_from_env",
+]

{aru_code-0.47.0 → aru_code-0.51.0}/aru/events.py

@@ -103,6 +103,31 @@ class SubagentCompleteEvent(BaseEvent):
     duration_ms: float = 0.0
 
 
+class SubagentToolStartedEvent(BaseEvent):
+    """A tool call started inside a running sub-agent.
+
+    Distinct from ``tool.called`` — that event fires from the orchestrator's
+    own tool loop. ``subagent.tool.started`` fires from inside a delegated
+    sub-agent's stream and carries the parent ``task_id`` so the TUI's
+    SubagentPanel can update the right row.
+    """
+
+    event_type: Literal["subagent.tool.started"] = "subagent.tool.started"
+    task_id: str = ""           # subagent's task_id (the row key)
+    tool_id: str = ""
+    tool_name: str = ""
+    tool_args_preview: str = ""  # first ~80 chars of args for the row label
+
+
+class SubagentToolCompletedEvent(BaseEvent):
+    event_type: Literal["subagent.tool.completed"] = "subagent.tool.completed"
+    task_id: str = ""
+    tool_id: str = ""
+    tool_name: str = ""
+    duration_ms: float = 0.0
+    error: str | None = None
+
+
 # ── Workspace / cwd ───────────────────────────────────────────────────
 
 
@@ -141,6 +166,29 @@ class PermissionModeChangedEvent(BaseEvent):
 # ── Intra-turn metrics ────────────────────────────────────────────────
 
 
+class TasklistUpdatedEvent(BaseEvent):
+    """Published whenever ``create_task_list`` / ``update_task`` mutates
+    the executor's subtask list. Lets the TUI ``TasklistPanel`` render
+    a live sidebar without reading the chat for the Rich panel.
+
+    ``tasks`` is the full list (newest snapshot) — subscribers do not
+    need to maintain incremental state. Empty list = list cleared.
+    """
+
+    event_type: Literal["tasklist.updated"] = "tasklist.updated"
+    tasks: list[dict[str, Any]] = Field(default_factory=list)
+
+
+class PlanUpdatedEvent(BaseEvent):
+    """Published when macro plan steps change (enter_plan_mode /
+    update_plan_step). Same shape contract as TasklistUpdatedEvent —
+    full snapshot, sidebar consumes directly.
+    """
+
+    event_type: Literal["plan.updated"] = "plan.updated"
+    steps: list[dict[str, Any]] = Field(default_factory=list)
+
+
 class MetricsUpdatedEvent(BaseEvent):
     """Published after each internal LLM API call (from ``cache_patch``).
 
@@ -176,11 +224,15 @@ AruEvent = Union[
     ToolCompletedEvent,
     SubagentStartEvent,
     SubagentCompleteEvent,
+    SubagentToolStartedEvent,
+    SubagentToolCompletedEvent,
     CwdChangedEvent,
     FileChangedEvent,
     PermissionDeniedEvent,
     PermissionModeChangedEvent,
     MetricsUpdatedEvent,
+    TasklistUpdatedEvent,
+    PlanUpdatedEvent,
 ]
 
 
@@ -196,11 +248,15 @@ EVENT_MODELS: dict[str, type[BaseEvent]] = {
     "tool.completed": ToolCompletedEvent,
     "subagent.start": SubagentStartEvent,
     "subagent.complete": SubagentCompleteEvent,
+    "subagent.tool.started": SubagentToolStartedEvent,
+    "subagent.tool.completed": SubagentToolCompletedEvent,
     "cwd.changed": CwdChangedEvent,
     "file.changed": FileChangedEvent,
     "permission.denied": PermissionDeniedEvent,
     "permission.mode.changed": PermissionModeChangedEvent,
     "metrics.updated": MetricsUpdatedEvent,
+    "tasklist.updated": TasklistUpdatedEvent,
+    "plan.updated": PlanUpdatedEvent,
 }
 
 

{aru_code-0.47.0 → aru_code-0.51.0}/aru/plugins/hooks.py

@@ -67,6 +67,8 @@ VALID_HOOKS = frozenset({
     # Sub-agent (Tier 2 #3)
     "subagent.start",            # After delegate_task spawns a sub-agent
     "subagent.complete",         # After sub-agent terminates (ok, error, cancelled)
+    "subagent.tool.started",     # Inside a sub-agent: a tool call started
+    "subagent.tool.completed",   # Inside a sub-agent: a tool call completed
 
     # Turn lifecycle (Tier 2 #3)
     "turn.start",                # Beginning of runner.prompt for a new user turn
@@ -76,6 +78,10 @@ VALID_HOOKS = frozenset({
     "metrics.updated",           # After every internal LLM API call (cache_patch);
                                  # lets the TUI refresh tokens/cost mid-turn so long
                                  # implementation runs don't sit silent for minutes.
+
+    # Tasklist / plan visibility (Tier 2 #6 sidebar)
+    "tasklist.updated",          # create_task_list / update_task — full snapshot
+    "plan.updated",              # enter_plan_mode / update_plan_step — full snapshot
 })
 
 

{aru_code-0.47.0 → aru_code-0.51.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.47.0 → aru_code-0.51.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.47.0 → aru_code-0.51.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.47.0 → aru_code-0.51.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."""
         ...
@@ -166,6 +174,7 @@ async def run_stream(
     )
     from aru.cache_patch import get_last_stop_reason, reset_last_stop_reason
     from aru.display import _format_tool_label
+    from aru.doom_loop import DoomLoopDetector
 
     state = StreamState()
     accumulated = ""
@@ -180,6 +189,14 @@ async def run_stream(
 
     # Track tool start times so the sink gets a duration on completion.
     tool_start_times: dict[str, float] = {}
+    # Cache args at started so the doom-loop detector and any other
+    # post-hoc check can read them at completed without depending on the
+    # provider always populating ``tool_args`` on the completed event.
+    tool_args_by_id: dict[str, Any] = {}
+    # Per-turn doom-loop detector — reset on each new run_stream call so
+    # repeating the same tool across separate user turns isn't a "loop".
+    # See ``aru/doom_loop.py`` for the heuristic.
+    doom_loop_detector = DoomLoopDetector()
     import time as _time
 
     while True:
@@ -221,6 +238,9 @@ async def run_stream(
                 pending_tool_uses[tool_id] = assistant_blocks[-1]
 
                 tool_start_times[tool_id] = _time.monotonic()
+                tool_args_by_id[tool_id] = (
+                    tool_args if isinstance(tool_args, dict) else None
+                )
                 sink.on_tool_started(
                     tool_id=tool_id,
                     tool_name=tool_name,
@@ -295,6 +315,35 @@ async def run_stream(
                     label=tool_name,  # sink caches its own label if needed
                 )
 
+                # Doom-loop check — if the model just made the same call
+                # for the Nth time in a row, pause and ask the user. The
+                # detector is per-turn (constructed at run_stream entry)
+                # so a legitimate repeat across separate turns doesn't
+                # fire. See ``aru/doom_loop.py``.
+                tool_args_for_detector = tool_args_by_id.pop(tool_id, None)
+                if doom_loop_detector.record(tool_name, tool_args_for_detector):
+                    if await _handle_doom_loop(
+                        sink=sink,
+                        tool_name=tool_name,
+                        tool_args=tool_args_for_detector,
+                    ):
+                        # User chose continue — wipe history for this
+                        # tool so the very next call doesn't immediately
+                        # re-prompt. Other tools' history is preserved.
+                        doom_loop_detector.reset_for_tool(tool_name)
+                    else:
+                        # User chose abort. Mark stalled, propagate the
+                        # abort signal to any in-flight sub-agents, and
+                        # break out of the stream — the outer recovery
+                        # loop's stop-reason check will then exit.
+                        state.stalled = True
+                        try:
+                            from aru.runtime import abort_current
+                            abort_current()
+                        except Exception:
+                            pass
+                        break
+
                 # When the last active tool in the round completed, close it
                 # and let the sink flush deferred renders (plan panel etc.).
                 if not pending_tool_uses:
@@ -344,3 +393,64 @@ async def run_stream(
     state.accumulated = accumulated
     sink.on_stream_finished(final_content=accumulated)
     return state
+
+
+async def _handle_doom_loop(
+    *,
+    sink: StreamSink,
+    tool_name: str,
+    tool_args: Any,
+) -> bool:
+    """Notify + prompt the user when a doom-loop fires. Returns True to continue.
+
+    Routed through ``ctx.ui.confirm`` so REPL gets the prompt_toolkit
+    yes/no and TUI gets a ``ConfirmModal`` — same code path as the
+    permission prompts. Wrapped in ``asyncio.to_thread`` because the UI
+    adapter is sync (it bridges to the Textual event loop internally via
+    ``call_from_thread`` and a ``threading.Event``); calling it directly
+    from the async loop would deadlock the TUI.
+    """
+    import asyncio
+    import json
+
+    try:
+        args_preview = json.dumps(
+            tool_args if isinstance(tool_args, dict) else {},
+            sort_keys=True, default=str,
+        )
+    except Exception:
+        args_preview = repr(tool_args)
+    if len(args_preview) > 120:
+        args_preview = args_preview[:117] + "..."
+
+    sink.notify(
+        f"Doom-loop detected: 3× identical {tool_name}({args_preview}). "
+        f"Pausing for user confirmation.",
+        style="bold yellow",
+    )
+
+    prompt = (
+        f"`{tool_name}` was called 3 times in a row with the same input "
+        f"({args_preview}). The agent may be stuck in a loop. Continue?"
+    )
+
+    try:
+        from aru.runtime import get_ctx
+        ctx = get_ctx()
+    except LookupError:
+        # No runtime ctx (test harness without init_ctx) — default to
+        # abort so the loop doesn't keep firing forever.
+        return False
+
+    ui = getattr(ctx, "ui", None)
+    if ui is None:
+        # No UI installed — same conservative default. abort.
+        return False
+
+    try:
+        return bool(await asyncio.to_thread(ui.confirm, prompt, False))
+    except Exception:
+        # If the prompt itself raises (timeout, missing app, etc.) we
+        # default to abort — the model is stuck and we can't ask the
+        # user, so continuing risks burning more budget for nothing.
+        return False

{aru_code-0.47.0 → aru_code-0.51.0}/aru/tools/delegate.py

@@ -421,11 +421,23 @@ Do not create documentation files unless explicitly asked.
                 "task": (task or "")[:500],
             })
 
+            from aru.runtime import _schedule_publish as _sched_t
             try:
                 async for event in agent_instance.arun(task, stream=True, stream_events=True, yield_run_output=True):
                     if is_aborted():
                         _trace.status = "cancelled"
                         _trace.ended_at = _time.monotonic()
+                        # Emit subagent.complete with status=cancelled so the
+                        # TUI's SubagentPanel can mark + reap the row instead
+                        # of leaving it stuck in "running". Mirrors the
+                        # complete path below.
+                        _sched_t("subagent.complete", {
+                            "task_id": _trace.task_id,
+                            "status": "cancelled",
+                            "duration": (_trace.ended_at or 0) - (_trace.started_at or 0),
+                            "tokens_in": _trace.tokens_in,
+                            "tokens_out": _trace.tokens_out,
+                        })
                         return f"[{label} | task_id={task_id_for_output}] Cancelled by user."
                     if isinstance(event, RunOutput):
                         run_output = event
@@ -433,9 +445,23 @@ Do not create documentation files unless explicitly asked.
                     elif isinstance(event, ToolCallStartedEvent):
                         if hasattr(event, "tool") and event.tool:
                             t_id = getattr(event.tool, "tool_call_id", None) or (event.tool.tool_name or "tool")
+                            t_name_start = event.tool.tool_name or "tool"
+                            t_args_start = getattr(event.tool, "tool_args", None)
                         else:
                             t_id = getattr(event, "tool_call_id", None) or getattr(event, "tool_name", "tool")
+                            t_name_start = getattr(event, "tool_name", "tool")
+                            t_args_start = getattr(event, "tool_args", None)
                         _tool_starts[t_id] = _time.monotonic()
+                        # Live TUI: tell the SubagentPanel which subagent is
+                        # currently running which tool, so a fan-out of N
+                        # delegates renders as N rows each showing its own
+                        # in-flight tool instead of opaque "running…".
+                        _sched_t("subagent.tool.started", {
+                            "task_id": _trace.task_id,
+                            "tool_id": str(t_id),
+                            "tool_name": t_name_start,
+                            "tool_args_preview": (str(t_args_start) if t_args_start else "")[:80],
+                        })
                     elif isinstance(event, ToolCallCompletedEvent):
                         if hasattr(event, "tool") and event.tool:
                             t_id = getattr(event.tool, "tool_call_id", None) or getattr(event.tool, "tool_name", "tool")
@@ -452,12 +478,29 @@ Do not create documentation files unless explicitly asked.
                             "args_preview": (str(t_args) if t_args else "")[:150],
                             "duration": round(dur, 3),
                         })
+                        _sched_t("subagent.tool.completed", {
+                            "task_id": _trace.task_id,
+                            "tool_id": str(t_id),
+                            "tool_name": t_name,
+                            "duration_ms": round(dur * 1000, 1),
+                            "error": None,
+                        })
                     elif isinstance(event, RunContentEvent):
                         if hasattr(event, "content") and event.content:
                             result_content += event.content
             except Exception:
                 _trace.status = "error"
                 _trace.ended_at = _time.monotonic()
+                # Same rationale as cancel: surface a complete event with
+                # status=error so the panel can stop the row instead of
+                # leaving it spinning forever.
+                _sched_t("subagent.complete", {
+                    "task_id": _trace.task_id,
+                    "status": "error",
+                    "duration": (_trace.ended_at or 0) - (_trace.started_at or 0),
+                    "tokens_in": _trace.tokens_in,
+                    "tokens_out": _trace.tokens_out,
+                })
                 raise
 
             if run_output and hasattr(run_output, "metrics") and run_output.metrics: