aru-code 0.26.0__tar.gz → 0.26.1__tar.gz

{aru_code-0.26.0/aru_code.egg-info → aru_code-0.26.1}/PKG-INFO

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

aru_code-0.26.1/aru/__init__.py

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

{aru_code-0.26.0 → aru_code-0.26.1}/aru/agent_factory.py

@@ -6,9 +6,6 @@ import functools
 import inspect
 import logging
 
-from agno.compression.manager import CompressionManager
-from agno.utils.log import log_warning
-
 from aru.agents.base import build_instructions as _build_instructions
 from aru.agents.catalog import AGENTS, AgentSpec
 from aru.config import AgentConfig, CustomAgent
@@ -17,29 +14,6 @@ from aru.session import Session
 
 logger = logging.getLogger("aru.agent_factory")
 
-# Max chars for truncation fallback when compression fails
-_TRUNCATE_FALLBACK = 3000
-
-
-class _SafeCompressionManager(CompressionManager):
-    """CompressionManager that truncates on failure instead of leaving messages uncompressed.
-
-    Agno's default behavior: if compression returns None, the message stays with
-    compressed_content=None → should_compress() fires again → infinite retry loop.
-    This subclass marks failed messages with a truncated version so the loop moves on.
-    """
-
-    async def acompress(self, messages, run_metrics=None):
-        before = {id(m) for m in messages if m.role == "tool" and m.compressed_content is None}
-        await super().acompress(messages, run_metrics=run_metrics)
-        for msg in messages:
-            if id(msg) in before and msg.compressed_content is None:
-                content_str = str(msg.content or "")
-                msg.compressed_content = content_str[:_TRUNCATE_FALLBACK] + (
-                    "... [truncated, compression failed]" if len(content_str) > _TRUNCATE_FALLBACK else ""
-                )
-                log_warning(f"Compression fallback (truncate) for {msg.tool_name}")
-
 
 def _wrap_tools_with_hooks(tools: list) -> list:
     """Wrap tool functions to fire tool.execute.before/after plugin hooks.
@@ -175,16 +149,6 @@ def _apply_chat_hooks(instructions: str, model_ref: str, agent_name: str,
     return instructions, model_ref, max_tokens
 
 
-def _make_compression_manager() -> _SafeCompressionManager:
-    """Construct the safe compression manager used for every native agent."""
-    from aru.runtime import get_ctx
-    return _SafeCompressionManager(
-        model=create_model(get_ctx().small_model_ref, max_tokens=2048),
-        compress_tool_results=True,
-        compress_tool_results_limit=25,
-    )
-
-
 def create_agent_from_spec(
     spec: AgentSpec,
     session: Session | None = None,
@@ -194,8 +158,10 @@ def create_agent_from_spec(
     """Build an Agno Agent from a catalog spec.
 
     Single construction path for all native agents (build/plan/executor/explorer).
-    Resolves model, wraps tools with plugin hooks, applies chat.system.transform
-    and chat.params hooks, and attaches the safe compression manager.
+    Resolves model, wraps tools with plugin hooks, and applies chat.system.transform
+    and chat.params hooks. Context reduction is handled by aru's own layers
+    (`prune_history` for routine tool cleanup, `should_compact` near window limit),
+    so no Agno CompressionManager is attached.
 
     `session` may be None for subagent specs that always use the small model.
     """
@@ -222,8 +188,6 @@ def create_agent_from_spec(
         tools=tools,
         instructions=instructions,
         markdown=True,
-        compress_tool_results=True,
-        compression_manager=_make_compression_manager(),
         tool_call_limit=None,
     )
 

{aru_code-0.26.0 → aru_code-0.26.1}/aru/runner.py

@@ -42,6 +42,14 @@ def _build_plan_reminder(session) -> str | None:
     if not steps:
         return None
 
+    # Auto-retire plans that have nothing left to execute. Leaving a fully-
+    # terminal plan in the reminder makes the agent re-surface it on the next
+    # turn — it may even call update_plan_step on old steps, re-rendering the
+    # stale panel and confusing the user who already moved on to a new task.
+    if all(s.status in ("completed", "skipped", "failed") for s in steps):
+        session.clear_plan()
+        return None
+
     pending = sum(1 for s in steps if s.status == "pending")
     done = sum(1 for s in steps if s.status == "completed")
     lines = [
@@ -411,6 +419,15 @@ async def run_agent_capture(agent, message: str, session=None, lightweight: bool
                         # tool calls start a new round.
                         if tool_result_msgs and tool_result_msgs[-1]["_open"]:
                             tool_result_msgs[-1]["_open"] = False
+                        # Flush coalesced plan-panel render. Multiple
+                        # update_plan_step calls in the same batch (and any
+                        # enter_plan_mode that replaces the plan mid-batch)
+                        # collapse into a single panel showing final state.
+                        try:
+                            from aru.tools.tasklist import flush_plan_render
+                            flush_plan_render(session)
+                        except Exception:
+                            pass
                     live.update(display)
 
                 elif isinstance(event, RunContentEvent):

{aru_code-0.26.0 → aru_code-0.26.1}/aru/session.py

@@ -176,6 +176,14 @@ class Session:
         # Transient flag set by runner when a turn ends with pending plan steps;
         # surfaced as a warning in the next turn's plan reminder, then cleared.
         self._pending_plan_warning: bool = False
+        # Monotonic plan generation — bumped whenever the plan is replaced or
+        # cleared. update_plan_step captures this and only its rendering loop
+        # consults it; lets the runner tell stale renders apart from live ones.
+        self._plan_generation: int = 0
+        # Set by update_plan_step / set_plan / clear_plan whenever plan state
+        # changes and a render should happen. Runner flushes this once per
+        # tool batch so multiple mutations in one batch produce one panel.
+        self._plan_render_pending: bool = False
         self.model_ref: str = DEFAULT_MODEL  # provider/model format
         self.cwd: str = os.getcwd()
         self.created_at: str = datetime.now().isoformat(timespec="milliseconds")
@@ -230,13 +238,22 @@ class Session:
         self.current_plan = plan_content
         self.plan_task = task
         self.plan_steps = parse_plan_steps(plan_content)
+        self._plan_generation += 1
+        self._plan_render_pending = True
 
     def clear_plan(self):
         """Clear the active plan."""
+        had_plan = bool(self.plan_steps) or self.current_plan is not None
         self.current_plan = None
         self.plan_task = None
         self.plan_steps = []
         self._pending_plan_warning = False
+        if had_plan:
+            self._plan_generation += 1
+        # Clearing alone doesn't need a render — the replacement set_plan
+        # (or end-of-turn) will handle it. But mark pending so an explicit
+        # clear without a replacement still flushes any stale queued state.
+        self._plan_render_pending = False
 
     def track_tokens(self, metrics):
         """Accumulate token usage from a RunCompletedEvent.metrics."""

aru_code-0.26.1/aru/tools/plan_mode.py

@@ -0,0 +1,169 @@
+"""Plan mode control surface — agent-invokable tool to generate a structured plan.
+
+This is the autonomous counterpart to the `/plan` slash command. The build
+agent calls `enter_plan_mode(task)` when it detects a request requiring
+multiple coordinated changes; the tool runs the planner via runner.prompt,
+stores the plan in the session, and returns a summary so the build agent can
+immediately follow the resulting PLAN ACTIVE reminder.
+"""
+
+from __future__ import annotations
+
+import sys
+
+from rich.panel import Panel
+
+from aru.runtime import get_ctx
+
+
+def _prompt_plan_approval(plan_steps: list, n_steps: int) -> tuple[bool, str]:
+    """Show the plan panel and ask the user to approve execution.
+
+    Returns (approved, feedback). If the user types free text instead of y/n,
+    it is treated as feedback that the agent should use to adjust course.
+    Non-interactive sessions (no TTY) auto-approve.
+    """
+    # Auto-approve in non-interactive sessions — there's nobody to answer.
+    if not sys.stdin.isatty():
+        return True, ""
+
+    from aru.tools.tasklist import _render_plan_steps
+
+    ctx = get_ctx()
+
+    if ctx.live:
+        ctx.live.stop()
+    if ctx.display:
+        try:
+            ctx.display.flush()
+        except Exception:
+            pass
+
+    ctx.console.print()
+    ctx.console.print(_render_plan_steps(plan_steps))
+    ctx.console.print(Panel(
+        f"Proposed plan with [bold]{n_steps}[/bold] steps. Approve execution?",
+        title="[bold cyan]Plan approval[/bold cyan]",
+        border_style="cyan",
+        expand=False,
+    ))
+
+    try:
+        answer = ctx.console.input(
+            "[bold cyan](y)es / (n)o / type feedback to revise:[/bold cyan] "
+        ).strip()
+    except (EOFError, KeyboardInterrupt):
+        answer = "n"
+    finally:
+        if ctx.live:
+            try:
+                ctx.live.start()
+                ctx.live._live_render._shape = None
+            except Exception:
+                pass
+
+    low = answer.lower()
+    if not answer or low in ("y", "yes", "s", "sim", "ok"):
+        return True, ""
+    if low in ("n", "no", "não", "nao"):
+        return False, ""
+    return False, answer
+
+
+async def enter_plan_mode(task: str, force: bool = False) -> str:
+    """Generate a structured plan for a complex task and get user approval.
+
+    Use this when the user asks for work that requires 3+ coordinated changes
+    across files, or when they explicitly ask for a new plan. Generates a
+    read-only plan via the planner agent, shows it to the user, and asks for
+    explicit approval before execution proceeds.
+
+    IMPORTANT: the plan is NOT automatically executed. After this tool
+    returns, one of three things happened:
+      1. User approved — tool returns the plan and you should execute it,
+         calling update_plan_step(index, "completed") as you finish each step.
+      2. User rejected — tool returns a rejection message. Stop, do NOT
+         execute, and ask the user what they want instead.
+      3. User gave free-text feedback — tool returns the feedback. Stop,
+         do NOT execute, and either replan (enter_plan_mode again with the
+         revised task) or discuss with the user.
+
+    Behavior with an existing plan:
+      - If the previous plan is fully terminal (all steps done/skipped/
+        failed), it is automatically replaced.
+      - If the previous plan still has pending or in-progress steps, this
+        tool refuses UNLESS you pass force=True. Only pass force=True when
+        the user explicitly asked for a new plan. Do NOT call
+        update_plan_step to "close out" stale steps before replanning.
+
+    Args:
+        task: One-line description of what to plan.
+        force: Pass True to replace a plan that still has unfinished steps.
+    """
+    ctx = get_ctx()
+    session = ctx.session
+    if session is None:
+        return "Error: enter_plan_mode requires an active session."
+
+    existing_steps = getattr(session, "plan_steps", None) or []
+    if existing_steps:
+        unfinished = [s for s in existing_steps if s.status not in ("completed", "skipped", "failed")]
+        if unfinished and not force:
+            pending_list = ", ".join(f"#{s.index}" for s in unfinished)
+            return (
+                f"Error: a plan is already active with {len(unfinished)} unfinished "
+                f"step(s) ({pending_list}). If the user explicitly asked for a new "
+                f"plan, retry with force=True to discard the in-progress plan. Do "
+                f"NOT call update_plan_step to close out the old steps — that only "
+                f"re-renders the stale plan. Otherwise, execute the existing plan "
+                f"(see the PLAN ACTIVE reminder)."
+            )
+        session.clear_plan()
+
+    from aru.runner import PromptInput, prompt as runner_prompt
+
+    result = await runner_prompt(PromptInput(
+        session=session,
+        message=task,
+        agent_name="plan",
+        lightweight=True,
+    ))
+    plan_content = (result.content or "").strip()
+    if not plan_content:
+        return "Error: planner returned no content. Aborting plan_mode."
+
+    session.set_plan(task, plan_content)
+    n_steps = len(session.plan_steps)
+    if n_steps == 0:
+        return (
+            f"Plan generated but no steps were detected. The next turn will not "
+            f"see a PLAN ACTIVE reminder — execute manually based on this plan:\n\n"
+            f"{plan_content}"
+        )
+
+    approved, feedback = _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.
+    session._plan_render_pending = False
+
+    if not approved:
+        session.clear_plan()
+        if feedback:
+            return (
+                f"User rejected the plan and gave this feedback:\n\n  {feedback}\n\n"
+                f"Do NOT execute anything. Either call enter_plan_mode again with a "
+                f"revised task that incorporates the feedback, or ask the user for "
+                f"clarification. The previous plan has been discarded."
+            )
+        return (
+            "User rejected the plan. Do NOT execute anything. Ask the user what "
+            "they would like to change, then optionally call enter_plan_mode "
+            "again with a revised task. The previous plan has been discarded."
+        )
+
+    return (
+        f"User approved the plan ({n_steps} steps). Execute the steps in order "
+        f"and call update_plan_step(index, 'completed') after each.\n\n"
+        f"--- PLAN ---\n{plan_content}"
+    )

{aru_code-0.26.0 → aru_code-0.26.1}/aru/tools/tasklist.py

@@ -133,6 +133,22 @@ def update_task(index: int, status: str) -> str:
 _PLAN_STATUSES = ("in_progress", "completed", "failed", "skipped")
 
 
+def flush_plan_render(session) -> None:
+    """Render the plan panel once if the session has a pending update.
+
+    Called by the runner after each tool batch. Coalesces multiple
+    update_plan_step mutations into a single visible panel and ensures that
+    if enter_plan_mode replaced the plan mid-batch, only the new plan shows.
+    """
+    if session is None or not getattr(session, "_plan_render_pending", False):
+        return
+    session._plan_render_pending = False
+    steps = getattr(session, "plan_steps", None)
+    if not steps:
+        return
+    _show(_render_plan_steps(steps))
+
+
 def _render_plan_steps(steps: list) -> Panel:
     """Render the macro plan_steps list as a Rich panel."""
     icons = {
@@ -187,8 +203,11 @@ def update_plan_step(index: int, status: str) -> str:
         return f"Error: Plan step {index} not found. Valid indices: {valid}."
 
     target.status = status
-    panel = _render_plan_steps(session.plan_steps)
-    _show(panel)
+    # Defer rendering: mark the session so the runner flushes a single plan
+    # panel at the end of the current tool batch. Rendering per-call causes
+    # stale plans to reappear when enter_plan_mode is called in the same
+    # batch (the old plan renders, then gets replaced moments later).
+    session._plan_render_pending = True
 
     pending = [s for s in session.plan_steps if s.status == "pending"]
     if not pending:

{aru_code-0.26.0 → aru_code-0.26.1/aru_code.egg-info}/PKG-INFO

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

{aru_code-0.26.0 → aru_code-0.26.1}/pyproject.toml

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

aru_code-0.26.0/aru/__init__.py

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

aru_code-0.26.0/aru/tools/plan_mode.py

@@ -1,65 +0,0 @@
-"""Plan mode control surface — agent-invokable tool to generate a structured plan.
-
-This is the autonomous counterpart to the `/plan` slash command. The build
-agent calls `enter_plan_mode(task)` when it detects a request requiring
-multiple coordinated changes; the tool runs the planner via runner.prompt,
-stores the plan in the session, and returns a summary so the build agent can
-immediately follow the resulting PLAN ACTIVE reminder.
-"""
-
-from __future__ import annotations
-
-from aru.runtime import get_ctx
-
-
-async def enter_plan_mode(task: str) -> str:
-    """Generate a structured plan for a complex task before executing.
-
-    Use this when the user asks for work that requires 3+ coordinated changes
-    across files. Generates a read-only plan via the planner agent, stores it
-    in the session, and returns the plan text. After this returns, a PLAN
-    ACTIVE system reminder will appear in your context — follow it: execute
-    each step in order and call update_plan_step(index, "completed") as you go.
-
-    Do NOT call this if a plan is already active — execute the existing plan.
-
-    Args:
-        task: One-line description of what to plan.
-    """
-    ctx = get_ctx()
-    session = ctx.session
-    if session is None:
-        return "Error: enter_plan_mode requires an active session."
-
-    if getattr(session, "plan_steps", None):
-        return (
-            "Error: a plan is already active. Execute the existing plan steps "
-            "(see the PLAN ACTIVE reminder) instead of replanning."
-        )
-
-    from aru.runner import PromptInput, prompt as runner_prompt
-
-    result = await runner_prompt(PromptInput(
-        session=session,
-        message=task,
-        agent_name="plan",
-        lightweight=True,
-    ))
-    plan_content = (result.content or "").strip()
-    if not plan_content:
-        return "Error: planner returned no content. Aborting plan_mode."
-
-    session.set_plan(task, plan_content)
-    n_steps = len(session.plan_steps)
-    if n_steps == 0:
-        return (
-            f"Plan generated but no steps were detected. The next turn will not "
-            f"see a PLAN ACTIVE reminder — execute manually based on this plan:\n\n"
-            f"{plan_content}"
-        )
-    return (
-        f"Plan stored: {n_steps} steps. The PLAN ACTIVE reminder will appear in "
-        f"your next context window — execute steps in order and call "
-        f"update_plan_step(index, 'completed') after each.\n\n"
-        f"--- PLAN ---\n{plan_content}"
-    )