aru-code 0.24.0__tar.gz → 0.24.2__tar.gz

{aru_code-0.24.0/aru_code.egg-info → aru_code-0.24.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aru-code
-Version: 0.24.0
+Version: 0.24.2
 Summary: A Claude Code clone built with Agno agents
 Author-email: Estevao <estevaofon@gmail.com>
 License-Expression: MIT
@@ -53,7 +53,7 @@ An intelligent coding assistant for the terminal, powered by LLMs and [Agno](htt
 
 ## Highlights
 
-- **Multi-Agent Architecture** — Specialized agents for planning, execution, and conversation
+- **Multi-Agent Architecture** — Specialized agents for planning, execution, exploration, and conversation
 - **Interactive CLI** — Streaming responses, multi-line paste, session management
 - **Image Support** — Attach images via `@` mentions for multimodal analysis (Claude, GPT-4o, Gemini)
 - **11 Integrated Tools** — File operations, code search, shell, web search, task delegation
@@ -513,6 +513,7 @@ Aru can load tools from MCP servers. Configure in `.aru/mcp_config.json`:
 | **Planner** | Analyzes codebase, creates structured implementation plans | Read-only tools, search, web |
 | **Executor** | Implements code changes based on plans or instructions | All tools including delegation |
 | **General** | Handles conversation and simple operations | All tools including delegation |
+| **Explorer** | Fast, read-only codebase exploration and search | Read-only tools, search, bash (read-only) |
 
 ## Tools
 
@@ -553,7 +554,8 @@ aru-code/
 │   ├── permissions.py      # Granular permission system (allow/ask/deny)
 │   ├── agents/
 │   │   ├── planner.py      # Planning agent
-│   │   └── executor.py     # Execution agent
+│   │   ├── executor.py     # Execution agent
+│   │   └── explorer.py     # Explorer agent (fast, read-only codebase search)
 │   └── tools/
 │       ├── codebase.py     # 11 core tools
 │       ├── ast_tools.py    # Tree-sitter code analysis

{aru_code-0.24.0 → aru_code-0.24.2}/README.md

@@ -6,7 +6,7 @@ An intelligent coding assistant for the terminal, powered by LLMs and [Agno](htt
 
 ## Highlights
 
-- **Multi-Agent Architecture** — Specialized agents for planning, execution, and conversation
+- **Multi-Agent Architecture** — Specialized agents for planning, execution, exploration, and conversation
 - **Interactive CLI** — Streaming responses, multi-line paste, session management
 - **Image Support** — Attach images via `@` mentions for multimodal analysis (Claude, GPT-4o, Gemini)
 - **11 Integrated Tools** — File operations, code search, shell, web search, task delegation
@@ -466,6 +466,7 @@ Aru can load tools from MCP servers. Configure in `.aru/mcp_config.json`:
 | **Planner** | Analyzes codebase, creates structured implementation plans | Read-only tools, search, web |
 | **Executor** | Implements code changes based on plans or instructions | All tools including delegation |
 | **General** | Handles conversation and simple operations | All tools including delegation |
+| **Explorer** | Fast, read-only codebase exploration and search | Read-only tools, search, bash (read-only) |
 
 ## Tools
 
@@ -506,7 +507,8 @@ aru-code/
 │   ├── permissions.py      # Granular permission system (allow/ask/deny)
 │   ├── agents/
 │   │   ├── planner.py      # Planning agent
-│   │   └── executor.py     # Execution agent
+│   │   ├── executor.py     # Execution agent
+│   │   └── explorer.py     # Explorer agent (fast, read-only codebase search)
 │   └── tools/
 │       ├── codebase.py     # 11 core tools
 │       ├── ast_tools.py    # Tree-sitter code analysis

aru_code-0.24.2/aru/__init__.py

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

{aru_code-0.24.0 → aru_code-0.24.2}/aru/cli.py

@@ -199,7 +199,8 @@ async def run_cli(skip_permissions: bool = False, resume_id: str | None = None):
     # Apply tree_depth from config
     session._tree_max_depth = config.tree_depth
 
-    # Wire file-mutation callback and atexit cleanup
+    # Wire session and file-mutation callback
+    ctx.session = session
     ctx.on_file_mutation = session.invalidate_context_cache
     atexit.register(lambda: cleanup_processes(ctx.tracked_processes))
 
@@ -745,6 +746,7 @@ async def run_oneshot(prompt: str, print_only: bool = False, skip_permissions: b
     if config.default_model:
         session.model_ref = config.default_model
 
+    ctx.session = session
     ctx.model_id = session.model_id
     small_ref = config.model_aliases.get("small") if config else None
     if not small_ref:

{aru_code-0.24.0 → aru_code-0.24.2}/aru/display.py

@@ -253,6 +253,34 @@ def _format_tool_label(tool_name: str, tool_args: dict | None) -> str:
     return display
 
 
+def subagent_progress(label: str, tool_name: str, tool_args: dict | None,
+                      duration: float | None = None):
+    """Print sub-agent tool completion into the active Live context (or console).
+
+    Only called on tool completion — shows a single ✓ line per tool call,
+    keeping the output compact (no duplicate start/complete lines).
+    """
+    from aru.runtime import get_ctx
+    try:
+        ctx = get_ctx()
+    except LookupError:
+        return
+    tool_label = _format_tool_label(tool_name, tool_args)
+    dur_str = f" {duration:.1f}s" if duration and duration >= 0.5 else ""
+    line = Text.assemble(
+        ("    ", ""),
+        ("\u2713 ", "bold green"),
+        (f"[{label}] ", "dim"),
+        (tool_label, "dim"),
+        (dur_str, "dim cyan"),
+    )
+    target = ctx.live if ctx.live else None
+    if target:
+        target.console.print(line)
+    else:
+        ctx.console.print(line)
+
+
 class ToolTracker:
     """Tracks active tool calls with timing, displayed inside the Live area."""
 

{aru_code-0.24.0 → aru_code-0.24.2}/aru/runner.py

@@ -462,6 +462,24 @@ def _build_file_context(file_paths: list[str], max_total: int = 20_000) -> str:
     return "## Pre-loaded file contents (do NOT re-read these files)\n\n" + "\n\n".join(parts)
 
 
+_MODIFY_VERBS = frozenset({
+    "add", "create", "write", "edit", "modify", "update", "implement",
+    "fix", "replace", "rename", "move", "refactor", "remove", "delete",
+})
+_MUTATION_LABELS = frozenset({"Write", "Edit", "Bash"})
+
+
+def _step_expected_mutation(description: str) -> bool:
+    """Check if step description implies file modifications."""
+    first_word = description.strip().split()[0].lower().rstrip(":")
+    return first_word in _MODIFY_VERBS
+
+
+def _has_mutation_tool(tool_calls: list[str]) -> bool:
+    """Check if any tool call is a write/edit/bash operation."""
+    return any(tc.split("(")[0] in _MUTATION_LABELS for tc in tool_calls)
+
+
 async def execute_plan_steps(session, executor_factory) -> str | None:
     """Execute plan steps one by one with live progress tracking."""
     plan_files = _extract_plan_file_paths(session.current_plan)
@@ -586,12 +604,57 @@ async def execute_plan_steps(session, executor_factory) -> str | None:
                 )
 
             if step_failed:
-                step.status = "failed"
+                # Auto-retry once with error context before asking the user
                 fail_msg = content[:200] if content else f"{tasks_failed}/{tasks_total} subtasks failed"
-                console.print(f"\n[red]Step {step.index} failed: {fail_msg}[/red]")
-                if not get_skip_permissions() and not ask_yes_no("Continue with remaining steps?"):
-                    break
-            elif content or tasks_all_done:
+                console.print(f"\n[yellow]Step {step.index} failed, retrying automatically...[/yellow]")
+                reset_task_store()
+                retry_prompt = (
+                    step_prompt
+                    + f"\n\n## Previous Attempt Failed\nError: {fail_msg}\n"
+                    + "Fix the issues from the previous attempt. Do NOT repeat the same mistake."
+                )
+                executor = executor_factory()
+                retry_result = await run_agent_capture(executor, retry_prompt, session, lightweight=True)
+                content = retry_result.content
+                run_result = retry_result
+
+                # Re-evaluate after retry
+                store = get_task_store()
+                all_tasks = store.get_all()
+                tasks_completed = sum(1 for t in all_tasks if t["status"] == "completed")
+                tasks_failed = sum(1 for t in all_tasks if t["status"] == "failed")
+                tasks_total = len(all_tasks)
+                tasks_all_done = tasks_total > 0 and (tasks_completed + tasks_failed == tasks_total)
+
+                still_failed = False
+                if tasks_all_done and tasks_failed > 0 and tasks_completed == 0:
+                    still_failed = True
+                elif content:
+                    still_failed = (
+                        content.startswith("Error")
+                        or "Error from OpenAI API" in content
+                        or "Error in Agent run" in content
+                    )
+
+                if still_failed:
+                    step.status = "failed"
+                    fail_msg = content[:200] if content else f"{tasks_failed}/{tasks_total} subtasks failed"
+                    console.print(f"\n[red]Step {step.index} failed after retry: {fail_msg}[/red]")
+                    if not get_skip_permissions() and not ask_yes_no("Continue with remaining steps?"):
+                        break
+                else:
+                    # Retry succeeded — fall through to success handling
+                    step_failed = False
+
+            # Mutation validation warning (non-blocking)
+            if not step_failed and not run_result.stalled:
+                if _step_expected_mutation(step.description) and not _has_mutation_tool(run_result.tool_calls):
+                    console.print(
+                        f"[yellow]\u26a0 Step {step.index} was expected to modify files "
+                        f"but no write tools were called.[/yellow]"
+                    )
+
+            if not step_failed and (content or tasks_all_done):
                 step.status = "completed"
                 summary = content or f"All {tasks_completed} subtasks completed."
                 step_text = f"### Step {step.index}: {step.description}\n{summary}"
@@ -609,8 +672,26 @@ async def execute_plan_steps(session, executor_factory) -> str | None:
             if not get_skip_permissions() and not ask_yes_no("Continue with remaining steps?"):
                 break
         except Exception as e:
+            # Auto-retry once on exception
+            console.print(f"\n[yellow]Step {step.index} error: {e}. Retrying...[/yellow]")
+            try:
+                reset_task_store()
+                retry_prompt = (
+                    step_prompt
+                    + f"\n\n## Previous Attempt Error\n{e}\n"
+                    + "Fix the issues and complete this step."
+                )
+                executor = executor_factory()
+                retry_result = await run_agent_capture(executor, retry_prompt, session, lightweight=True)
+                if retry_result.content and not retry_result.content.startswith("Error"):
+                    step.status = "completed"
+                    all_results.append(f"### Step {step.index}: {step.description}\n{retry_result.content}")
+                    completed_context += f"\n- Step {step.index} ({step.description}): Done (after retry)"
+                    continue
+            except Exception:
+                pass
             step.status = "failed"
-            console.print(f"\n[red]Step {step.index} failed: {e}[/red]")
+            console.print(f"\n[red]Step {step.index} failed after retry: {e}[/red]")
             if not get_skip_permissions() and not ask_yes_no("Continue with remaining steps?"):
                 break
 

{aru_code-0.24.0 → aru_code-0.24.2}/aru/runtime.py

@@ -122,6 +122,9 @@ class RuntimeContext:
     # -- Plugins --
     plugin_manager: Any = None  # aru.plugins.manager.PluginManager (lazy to avoid circular)
 
+    # -- Session --
+    session: Any = None  # aru.session.Session (set by CLI, used for sub-agent cost tracking)
+
     # -- Checkpoints --
     checkpoint_manager: Any = None  # aru.checkpoints.CheckpointManager (lazy)
 

{aru_code-0.24.0 → aru_code-0.24.2}/aru/tools/codebase.py

@@ -381,7 +381,22 @@ def edit_file(file_path: str, old_string: str, new_string: str) -> str:
 
         count = content.count(old_string)
         if count == 0:
-            return f"Error: old_string not found in {file_path}"
+            # Provide context: show closest matching region to help the LLM retry
+            import difflib
+            lines = content.splitlines(keepends=True)
+            old_lines = old_string.splitlines(keepends=True)
+            matcher = difflib.SequenceMatcher(None, lines, old_lines)
+            best = matcher.find_longest_match(0, len(lines), 0, len(old_lines))
+            if best.size > 0:
+                # Show surrounding context around the best match
+                ctx_start = max(0, best.a - 2)
+                ctx_end = min(len(lines), best.a + best.size + 2)
+                snippet = "".join(f"{ctx_start + i + 1:4d} | {lines[ctx_start + i]}" for i in range(ctx_end - ctx_start))
+                return f"Error: old_string not found in {file_path}. Closest match region:\n{snippet}"
+            else:
+                # No match at all — show first 20 lines for context
+                snippet = "".join(f"{i + 1:4d} | {l}" for i, l in enumerate(lines[:20]))
+                return f"Error: old_string not found in {file_path}. File starts with:\n{snippet}"
         if count > 1:
             return f"Error: old_string found {count} times in {file_path}. Must be unique."
 
@@ -1193,11 +1208,15 @@ def _fetch_direct(url: str, max_chars: int) -> str:
     return _truncate_output(text, source_tool="web_fetch")
 
 
+_subagent_counter = 0
+_subagent_counter_lock = threading.Lock()
+
+
 def _next_subagent_id() -> int:
-    ctx = get_ctx()
-    with ctx.subagent_counter_lock:
-        ctx.subagent_counter += 1
-        return ctx.subagent_counter
+    global _subagent_counter
+    with _subagent_counter_lock:
+        _subagent_counter += 1
+        return _subagent_counter
 
 
 # Import new tools
@@ -1285,15 +1304,91 @@ Do not create documentation files unless explicitly asked.
             )
 
         label = f"Explorer-{agent_id}" if _agent_name == "explorer" else f"SubAgent-{agent_id}"
+
+        async def _execute_with_streaming(agent_instance) -> str:
+            """Run a sub-agent with streaming events for live progress display."""
+            import time as _time
+            from agno.run.agent import (
+                RunContentEvent,
+                RunOutput,
+                ToolCallCompletedEvent,
+                ToolCallStartedEvent,
+            )
+            from aru.display import subagent_progress
+
+            result_content = ""
+            run_output = None
+            _tool_starts: dict[str, float] = {}
+
+            async for event in agent_instance.arun(task, stream=True, stream_events=True, yield_run_output=True):
+                if isinstance(event, RunOutput):
+                    run_output = event
+                    break
+                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")
+                    else:
+                        t_id = getattr(event, "tool_call_id", None) or getattr(event, "tool_name", "tool")
+                    _tool_starts[t_id] = _time.monotonic()
+                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")
+                        t_name = event.tool.tool_name or "tool"
+                        t_args = event.tool.tool_args
+                    else:
+                        t_id = getattr(event, "tool_call_id", None) or getattr(event, "tool_name", "tool")
+                        t_name = getattr(event, "tool_name", "tool")
+                        t_args = getattr(event, "tool_args", None)
+                    dur = _time.monotonic() - _tool_starts.pop(t_id, _time.monotonic())
+                    subagent_progress(label, t_name, t_args if isinstance(t_args, dict) else None, duration=dur)
+                elif isinstance(event, RunContentEvent):
+                    if hasattr(event, "content") and event.content:
+                        result_content += event.content
+
+            # Track sub-agent token usage in the session so cost is not underestimated.
+            if run_output and hasattr(run_output, "metrics") and run_output.metrics:
+                try:
+                    session = get_ctx().session
+                    if session is not None:
+                        m = run_output.metrics
+                        session.total_input_tokens += getattr(m, "input_tokens", 0) or 0
+                        session.total_output_tokens += getattr(m, "output_tokens", 0) or 0
+                        session.total_cache_read_tokens += getattr(m, "cache_read_tokens", 0) or 0
+                        session.total_cache_write_tokens += getattr(m, "cache_write_tokens", 0) or 0
+                        session.api_calls += 1
+                except (LookupError, AttributeError):
+                    pass
+
+            final_text = run_output.content if run_output and run_output.content else result_content
+            if final_text:
+                return _truncate_output(f"[{label}] {final_text}")
+            return f"[{label}] Task completed but no output was returned."
+
         try:
             from aru.permissions import permission_scope
             with permission_scope(agent_perm):
-                result = await sub.arun(task, stream=False)
-            if result and result.content:
-                return _truncate_output(f"[{label}] {result.content}")
-            return f"[{label}] Task completed but no output was returned."
+                return await _execute_with_streaming(sub)
         except Exception as e:
-            return f"[{label}] Error: {e}"
+            # Auto-retry once with a fresh agent instance
+            try:
+                from aru.permissions import permission_scope as _ps
+                # Recreate the agent for a clean retry
+                if _agent_name == "explorer":
+                    from aru.agents.explorer import create_explorer
+                    sub_retry = create_explorer(task, context)
+                    sub_retry.name = f"Explorer-{agent_id}"
+                else:
+                    sub_retry = Agent(
+                        name=sub.name,
+                        model=sub.model,
+                        tools=sub.tools,
+                        instructions=sub.instructions,
+                        markdown=True,
+                    )
+                with _ps(agent_perm):
+                    return await _execute_with_streaming(sub_retry)
+            except Exception as e2:
+                return f"[{label}] Error (after retry): {e2}"
 
     # Run in a separate asyncio Task so each sub-agent gets its own
     # contextvars snapshot — essential for parallel permission_scope isolation.

{aru_code-0.24.0 → aru_code-0.24.2/aru_code.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aru-code
-Version: 0.24.0
+Version: 0.24.2
 Summary: A Claude Code clone built with Agno agents
 Author-email: Estevao <estevaofon@gmail.com>
 License-Expression: MIT
@@ -53,7 +53,7 @@ An intelligent coding assistant for the terminal, powered by LLMs and [Agno](htt
 
 ## Highlights
 
-- **Multi-Agent Architecture** — Specialized agents for planning, execution, and conversation
+- **Multi-Agent Architecture** — Specialized agents for planning, execution, exploration, and conversation
 - **Interactive CLI** — Streaming responses, multi-line paste, session management
 - **Image Support** — Attach images via `@` mentions for multimodal analysis (Claude, GPT-4o, Gemini)
 - **11 Integrated Tools** — File operations, code search, shell, web search, task delegation
@@ -513,6 +513,7 @@ Aru can load tools from MCP servers. Configure in `.aru/mcp_config.json`:
 | **Planner** | Analyzes codebase, creates structured implementation plans | Read-only tools, search, web |
 | **Executor** | Implements code changes based on plans or instructions | All tools including delegation |
 | **General** | Handles conversation and simple operations | All tools including delegation |
+| **Explorer** | Fast, read-only codebase exploration and search | Read-only tools, search, bash (read-only) |
 
 ## Tools
 
@@ -553,7 +554,8 @@ aru-code/
 │   ├── permissions.py      # Granular permission system (allow/ask/deny)
 │   ├── agents/
 │   │   ├── planner.py      # Planning agent
-│   │   └── executor.py     # Execution agent
+│   │   ├── executor.py     # Execution agent
+│   │   └── explorer.py     # Explorer agent (fast, read-only codebase search)
 │   └── tools/
 │       ├── codebase.py     # 11 core tools
 │       ├── ast_tools.py    # Tree-sitter code analysis

{aru_code-0.24.0 → aru_code-0.24.2}/pyproject.toml

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

aru_code-0.24.0/aru/__init__.py

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