aru-code 0.15.0__tar.gz → 0.17.0__tar.gz

{aru_code-0.15.0/aru_code.egg-info → aru_code-0.17.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aru-code
-Version: 0.15.0
+Version: 0.17.0
 Summary: A Claude Code clone built with Agno agents
 Author-email: Estevao <estevaofon@gmail.com>
 License-Expression: MIT
@@ -56,7 +56,7 @@ An intelligent coding assistant for the terminal, powered by LLMs and [Agno](htt
 - **Multi-Agent Architecture** — Specialized agents for planning, execution, and conversation
 - **Interactive CLI** — Streaming responses, multi-line paste, session management
 - **Image Support** — Attach images via `@` mentions for multimodal analysis (Claude, GPT-4o, Gemini)
-- **16 Integrated Tools** — File operations, code search, shell, web search, task delegation
+- **11 Integrated Tools** — File operations, code search, shell, web search, task delegation
 - **Task Planning** — Break down complex tasks into steps with automatic execution
 - **Multi-Provider** — Anthropic, OpenAI, Ollama, Groq, OpenRouter, DeepSeek, and others via custom configuration
 - **Custom Commands, Skills, and Agents** — Extend aru via the `.agents/` directory
@@ -479,15 +479,14 @@ Aru can load tools from MCP servers. Configure in `.aru/mcp_config.json`:
 
 ### File Operations
 - `read_file` — Reads files with line range support and binary detection
-- `read_file_smart` — Smart file reading focused on relevant snippets for the query
-- `write_file` — Writes files
-- `edit_file` — Find-replace edits
+- `read_file_smart` — Answers specific questions about a file without returning raw content
+- `write_file` — Writes content to files, creating directories as needed
+- `edit_file` — Find-and-replace edits on files
 
 ### Search & Discovery
 - `glob_search` — Find files by pattern (respects .gitignore)
 - `grep_search` — Content search with regex and file filtering
 - `list_directory` — Directory listing with gitignore filtering
-- `rank_files` — Multi-factor file relevance ranking (name, structure, recency)
 
 ### Shell & Web
 - `bash` — Executes shell commands with permission gates
@@ -517,7 +516,7 @@ aru-code/
 │   │   ├── planner.py      # Planning agent
 │   │   └── executor.py     # Execution agent
 │   └── tools/
-│       ├── codebase.py     # 16 core tools
+│       ├── codebase.py     # 11 core tools
 │       ├── ast_tools.py    # Tree-sitter code analysis
 │       ├── ranker.py       # File relevance ranking
 │       ├── mcp_client.py   # MCP client

{aru_code-0.15.0 → aru_code-0.17.0}/README.md

@@ -9,7 +9,7 @@ An intelligent coding assistant for the terminal, powered by LLMs and [Agno](htt
 - **Multi-Agent Architecture** — Specialized agents for planning, execution, and conversation
 - **Interactive CLI** — Streaming responses, multi-line paste, session management
 - **Image Support** — Attach images via `@` mentions for multimodal analysis (Claude, GPT-4o, Gemini)
-- **16 Integrated Tools** — File operations, code search, shell, web search, task delegation
+- **11 Integrated Tools** — File operations, code search, shell, web search, task delegation
 - **Task Planning** — Break down complex tasks into steps with automatic execution
 - **Multi-Provider** — Anthropic, OpenAI, Ollama, Groq, OpenRouter, DeepSeek, and others via custom configuration
 - **Custom Commands, Skills, and Agents** — Extend aru via the `.agents/` directory
@@ -432,15 +432,14 @@ Aru can load tools from MCP servers. Configure in `.aru/mcp_config.json`:
 
 ### File Operations
 - `read_file` — Reads files with line range support and binary detection
-- `read_file_smart` — Smart file reading focused on relevant snippets for the query
-- `write_file` — Writes files
-- `edit_file` — Find-replace edits
+- `read_file_smart` — Answers specific questions about a file without returning raw content
+- `write_file` — Writes content to files, creating directories as needed
+- `edit_file` — Find-and-replace edits on files
 
 ### Search & Discovery
 - `glob_search` — Find files by pattern (respects .gitignore)
 - `grep_search` — Content search with regex and file filtering
 - `list_directory` — Directory listing with gitignore filtering
-- `rank_files` — Multi-factor file relevance ranking (name, structure, recency)
 
 ### Shell & Web
 - `bash` — Executes shell commands with permission gates
@@ -470,7 +469,7 @@ aru-code/
 │   │   ├── planner.py      # Planning agent
 │   │   └── executor.py     # Execution agent
 │   └── tools/
-│       ├── codebase.py     # 16 core tools
+│       ├── codebase.py     # 11 core tools
 │       ├── ast_tools.py    # Tree-sitter code analysis
 │       ├── ranker.py       # File relevance ranking
 │       ├── mcp_client.py   # MCP client

aru_code-0.17.0/aru/__init__.py

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

{aru_code-0.15.0 → aru_code-0.17.0}/aru/agent_factory.py

@@ -21,10 +21,9 @@ def create_general_agent(
             in the system prompt. Placed in instructions so it's cacheable.
     """
     from agno.agent import Agent
-    from agno.compression.manager import CompressionManager
 
     from aru.tools.codebase import GENERAL_TOOLS
-    from aru.runtime import get_ctx
+    tools = GENERAL_TOOLS
 
     extra = config.get_extra_instructions() if config else ""
     if env_context:
@@ -34,15 +33,9 @@ def create_general_agent(
     return Agent(
         name="Aru",
         model=create_model(model_ref, max_tokens=8192),
-        tools=GENERAL_TOOLS,
+        tools=tools,
         instructions=_build_instructions("general", extra),
         markdown=True,
-        compress_tool_results=True,
-        compression_manager=CompressionManager(
-            model=create_model(get_ctx().small_model_ref, max_tokens=1024),
-            compress_tool_results=True,
-            compress_tool_results_limit=25,
-        ),
         tool_call_limit=20,
     )
 
@@ -52,10 +45,8 @@ def create_custom_agent_instance(agent_def: CustomAgent, session: Session,
                                   env_context: str = ""):
     """Create an Agno Agent from a CustomAgent definition."""
     from agno.agent import Agent
-    from agno.compression.manager import CompressionManager
     from aru.agents.base import BASE_INSTRUCTIONS
     from aru.tools.codebase import resolve_tools
-    from aru.runtime import get_ctx
 
     model_ref = agent_def.model or session.model_ref
     tools = resolve_tools(agent_def.tools)
@@ -74,11 +65,5 @@ def create_custom_agent_instance(agent_def: CustomAgent, session: Session,
         tools=tools,
         instructions=instructions,
         markdown=True,
-        compress_tool_results=True,
-        compression_manager=CompressionManager(
-            model=create_model(get_ctx().small_model_ref, max_tokens=1024),
-            compress_tool_results=True,
-            compress_tool_results_limit=25,
-        ),
         tool_call_limit=agent_def.max_turns or 20,
     )

{aru_code-0.15.0 → aru_code-0.17.0}/aru/agents/base.py

@@ -48,12 +48,12 @@ Default shows 10 lines of context — use `context_lines=30` for full function b
 2. **Understand a file** → `read_file_smart(path, query)` — returns a concise answer, not raw content
 3. **Need raw content** → `read_file(path)` — returns first chunk + outline for large files
 
-**Stop early**: Once you have enough information to write the plan, STOP making tool calls \
-immediately. Do not exhaustively explore.
-
 **Batch independent tool calls**: When you need answers from multiple independent sources, \
 emit ALL those tool calls in a single response.
 
+**Stop early**: Once you have enough information to write the plan, stop exploring and write it. \
+Do not exhaustively read every file — batch what you need, then produce the plan.
+
 ## Output format — STRICT
 
 Your ONLY output is the plan below. Do NOT write analysis, coverage reports, summaries of
@@ -182,7 +182,8 @@ Every tool call accumulates its result in your context window. Use the minimum n
 
 **Batch independent tool calls**: emit ALL independent tool calls in a single response.
 
-**Stop early**: Once you have enough information to do the work, STOP exploring and start working.
+**Stop early**: Once you have enough information to act, stop exploring and start working. \
+Batch what you need upfront, then execute.
 
 **When adding or modifying unit tests, ALWAYS run them to verify they pass before finishing.**
 

aru_code-0.17.0/aru/cache_patch.py

@@ -0,0 +1,201 @@
+"""Monkey-patch Agno's model layer to reduce token consumption.
+
+Three optimizations:
+
+1. **Tool result pruning** (ALL providers): After each tool execution, old tool
+   results in the message list are truncated to a short summary. This prevents
+   O(n²) token growth where each API call re-sends all previous tool results.
+
+2. **Cache breakpoints** (Anthropic only): Marks the last 2 messages with
+   cache_control for Anthropic's prompt caching.
+
+3. **Per-call metrics** (ALL providers): Captures input/output tokens of the
+   last API call (context window size), exposed via get_last_call_metrics().
+
+These patches intercept Agno's internal loop so they work transparently
+regardless of which provider is used.
+"""
+
+from __future__ import annotations
+
+# Token-budget pruning (aligned with OpenCode's strategy):
+# - Protect recent tool results within a token budget
+# - Only prune if there's enough to free (avoid churn)
+# - Walk backwards, protecting recent content first
+# OpenCode uses 40K protect / 20K minimum; we use chars (~4 chars/token)
+_PRUNE_PROTECT_CHARS = 160_000   # ~40K tokens — recent content always kept
+_PRUNE_MINIMUM_CHARS = 80_000    # ~20K tokens — only prune if this much is freeable
+_PRUNED_PLACEHOLDER = "[Old tool result cleared]"
+
+# Last API call metrics (updated on every internal API call)
+_last_call_input_tokens: int = 0
+_last_call_output_tokens: int = 0
+_last_call_cache_read: int = 0
+_last_call_cache_write: int = 0
+
+
+def get_last_call_metrics() -> tuple[int, int, int, int]:
+    """Return (input, output, cache_read, cache_write) from the most recent API call."""
+    return _last_call_input_tokens, _last_call_output_tokens, _last_call_cache_read, _last_call_cache_write
+
+
+def _prune_tool_messages(messages):
+    """Clear old tool result content using a token-budget approach.
+
+    Walks backwards through messages, protecting recent content up to
+    PRUNE_PROTECT_CHARS. Older tool results beyond that budget are replaced
+    with a short placeholder. Only prunes if total freeable chars exceed
+    PRUNE_MINIMUM_CHARS (avoids unnecessary churn on small conversations).
+
+    Aligned with OpenCode's strategy: budget-based, not fixed-N.
+    """
+    # Collect tool message indices and their content sizes
+    tool_indices = []
+    for i, msg in enumerate(messages):
+        if getattr(msg, "role", None) == "tool":
+            content = getattr(msg, "content", None)
+            content_len = len(str(content)) if content is not None else 0
+            tool_indices.append((i, content_len))
+
+    if not tool_indices:
+        return
+
+    # Walk backwards, accumulating protected chars
+    protected_chars = 0
+    prune_candidates = []  # (index, content_len) of messages outside protection
+
+    for idx, content_len in reversed(tool_indices):
+        if protected_chars + content_len <= _PRUNE_PROTECT_CHARS:
+            protected_chars += content_len
+        else:
+            prune_candidates.append((idx, content_len))
+
+    # Only prune if there's enough to free
+    freeable = sum(cl for _, cl in prune_candidates)
+    if freeable < _PRUNE_MINIMUM_CHARS:
+        return
+
+    # Replace old tool results with placeholder
+    for idx, _ in prune_candidates:
+        msg = messages[idx]
+        content = getattr(msg, "content", None)
+        if content is None:
+            continue
+        # Skip if already pruned
+        if str(content) == _PRUNED_PLACEHOLDER:
+            continue
+        try:
+            msg.content = _PRUNED_PLACEHOLDER
+            if hasattr(msg, "compressed_content"):
+                msg.compressed_content = None
+        except (AttributeError, TypeError):
+            pass
+
+
+def apply_cache_patch():
+    """Apply all patches to reduce Agno's token consumption."""
+    _patch_tool_result_pruning()
+    _patch_claude_cache_breakpoints()
+    _patch_per_call_metrics()
+
+
+def _patch_tool_result_pruning():
+    """Patch format_function_call_results to prune old tool results.
+
+    This is called after each tool execution, right before the next API call.
+    Works for ALL providers (Claude, OpenAI, Qwen, etc.) since it patches
+    the base Model class.
+    """
+    from agno.models.base import Model
+
+    _original_format_results = Model.format_function_call_results
+
+    def _patched_format_results(self, messages, function_call_results, **kwargs):
+        # First: prune old tool results already in messages
+        _prune_tool_messages(messages)
+        # Then: add new results normally
+        return _original_format_results(self, messages, function_call_results, **kwargs)
+
+    Model.format_function_call_results = _patched_format_results
+
+
+def _patch_claude_cache_breakpoints():
+    """Patch Claude's format_messages to add cache breakpoints.
+
+    Marks the last 2 messages with cache_control for Anthropic's prompt
+    caching. Non-Anthropic providers ignore these fields.
+    """
+    try:
+        import agno.utils.models.claude as claude_utils
+    except ImportError:
+        return
+
+    _original_format = claude_utils.format_messages
+
+    def _patched_format_messages(messages, compress_tool_results=False):
+        chat_messages, system_message = _original_format(
+            messages, compress_tool_results=compress_tool_results
+        )
+
+        if not chat_messages:
+            return chat_messages, system_message
+
+        # Add cache_control to last 2 messages
+        cache_marker = {"type": "ephemeral"}
+        marked = 0
+        for msg in reversed(chat_messages):
+            if marked >= 2:
+                break
+            content = msg.get("content")
+            if isinstance(content, list) and content:
+                last_item = content[-1]
+                if isinstance(last_item, dict):
+                    last_item["cache_control"] = cache_marker
+                    marked += 1
+                elif hasattr(last_item, "type"):
+                    try:
+                        as_dict = last_item.model_dump() if hasattr(last_item, "model_dump") else dict(last_item)
+                        as_dict["cache_control"] = cache_marker
+                        content[-1] = as_dict
+                        marked += 1
+                    except Exception:
+                        pass
+            elif isinstance(content, str):
+                msg["content"] = [{"type": "text", "text": content, "cache_control": cache_marker}]
+                marked += 1
+
+        return chat_messages, system_message
+
+    claude_utils.format_messages = _patched_format_messages
+
+
+def _patch_per_call_metrics():
+    """Patch accumulate_model_metrics to capture per-API-call token counts.
+
+    After each internal API call, Agno calls this function to sum tokens
+    into RunMetrics. We intercept it to snapshot the last call's tokens,
+    giving us the actual context window size (comparable to OpenCode/Claude Code).
+    """
+    from agno.metrics import accumulate_model_metrics as _original_accumulate
+
+    import agno.metrics as _metrics_module
+
+    def _patched_accumulate(model_response, model, model_type, run_metrics=None):
+        global _last_call_input_tokens, _last_call_output_tokens
+        global _last_call_cache_read, _last_call_cache_write
+        usage = getattr(model_response, "response_usage", None)
+        if usage is not None:
+            _last_call_input_tokens = getattr(usage, "input_tokens", 0) or 0
+            _last_call_output_tokens = getattr(usage, "output_tokens", 0) or 0
+            _last_call_cache_read = getattr(usage, "cache_read_tokens", 0) or 0
+            _last_call_cache_write = getattr(usage, "cache_write_tokens", 0) or 0
+        return _original_accumulate(model_response, model, model_type, run_metrics)
+
+    _metrics_module.accumulate_model_metrics = _patched_accumulate
+
+    # Also patch the reference in base.py since it may have imported directly
+    try:
+        import agno.models.base as _base_module
+        _base_module.accumulate_model_metrics = _patched_accumulate
+    except (ImportError, AttributeError):
+        pass

{aru_code-0.15.0 → aru_code-0.17.0}/aru/cli.py

@@ -14,6 +14,7 @@ import os
 import sys
 
 from rich.markdown import Markdown
+from rich.panel import Panel
 
 # ── Re-exports for backward compatibility ─────────────────────────────
 # Tests and external code import these from aru.cli; keep them accessible.
@@ -50,6 +51,7 @@ from aru.display import (  # noqa: F401
 from aru.completers import (  # noqa: F401
     AruCompleter,
     FileMentionCompleter,
+    MentionResult,
     PasteState,
     SlashCommandCompleter,
     TIPS,
@@ -110,6 +112,11 @@ async def run_cli(skip_permissions: bool = False, resume_id: str | None = None):
     from aru.permissions import parse_permission_config, reset_session as perm_reset_session
     from aru.tools.codebase import cleanup_processes
 
+    # Inject cache breakpoints into Agno's Claude API calls — reduces token
+    # consumption by ~40% on multi-tool-call interactions via prompt caching.
+    from aru.cache_patch import apply_cache_patch
+    apply_cache_patch()
+
     ctx = init_ctx(console=console, skip_permissions=skip_permissions)
 
     store = SessionStore()
@@ -253,16 +260,19 @@ async def run_cli(skip_permissions: bool = False, resume_id: str | None = None):
 
         # Resolve @file mentions (skip known agent names)
         _agent_names = set(config.custom_agents.keys()) if config.custom_agents else set()
-        resolved, injected, attached_images = _resolve_mentions(user_input, os.getcwd(), _agent_names)
-        if injected > 0:
+        mention_result = _resolve_mentions(user_input, os.getcwd(), _agent_names)
+        attached_images = mention_result.images
+        # File contents go into history as separate prunable messages (not inline)
+        mention_file_msgs = mention_result.file_messages
+        if mention_result.count > 0:
             parts = []
-            text_count = injected - len(attached_images)
+            text_count = mention_result.count - len(attached_images)
             if text_count > 0:
                 parts.append(f"{text_count} file(s)")
             if attached_images:
                 parts.append(f"{len(attached_images)} image(s)")
             console.print(f"[dim]Attached {', '.join(parts)} from @ mentions[/dim]")
-            user_input = resolved
+            user_input = mention_result.text
 
         if paste_state.pasted_content and user_text:
             console.print(
@@ -276,6 +286,14 @@ async def run_cli(skip_permissions: bool = False, resume_id: str | None = None):
         if not user_input:
             continue
 
+        # Inject @file contents as prunable history entries BEFORE the user message.
+        # These look like simulated read_file tool calls and can be pruned/compacted
+        # normally, unlike inline content which bloats the user message permanently.
+        if mention_file_msgs:
+            for msg in mention_file_msgs:
+                session.add_message(msg["role"], msg["content"])
+            mention_file_msgs = []  # consumed
+
         # Reset "allow all" approvals for each new user message
         perm_reset_session()
 
@@ -396,6 +414,15 @@ async def run_cli(skip_permissions: bool = False, resume_id: str | None = None):
             _show_help(config)
             continue
 
+        if user_input.lower() == "/cost":
+            console.print(Panel(
+                session.cost_summary,
+                title="[bold]Token Usage & Cost[/bold]",
+                border_style="cyan",
+                padding=(1, 2),
+            ))
+            continue
+
         if user_input.startswith("! "):
             cmd = user_input[2:].strip()
             if not cmd:
@@ -501,7 +528,7 @@ async def run_cli(skip_permissions: bool = False, resume_id: str | None = None):
                         session.add_message("assistant", run_result.with_tools_summary())
             else:
                 console.print(f"[yellow]Unknown command: /{cmd_name}[/yellow]")
-                console.print(f"[dim]Built-in: /plan, /model, /sessions, /commands, /skills, /agents, /quit[/dim]")
+                console.print(f"[dim]Built-in: /plan, /model, /sessions, /commands, /skills, /agents, /cost, /quit[/dim]")
                 if config.commands:
                     console.print(f"[dim]Custom: {', '.join(f'/{k}' for k in config.commands)}[/dim]")
                 if config.skills:

{aru_code-0.15.0 → aru_code-0.17.0}/aru/commands.py

@@ -21,6 +21,7 @@ SLASH_COMMANDS = [
     ("/skills", "List available skills", "/skills"),
     ("/agents", "List custom agents", "/agents"),
     ("/mcp", "List loaded MCP tools", "/mcp"),
+    ("/cost", "Show detailed token usage and cost", "/cost"),
     ("/quit", "Exit aru", "/quit"),
 ]
 

{aru_code-0.15.0 → aru_code-0.17.0}/aru/completers.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 
 import os
 import re
+from dataclasses import dataclass
 
 from prompt_toolkit import PromptSession
 from prompt_toolkit.completion import Completer, Completion
@@ -18,24 +19,36 @@ from aru.commands import SLASH_COMMANDS
 from aru.config import AgentConfig
 
 _MENTION_RE = re.compile(r'(?<!\S)@([a-zA-Z0-9_./\\:-]+)')
-_MENTION_MAX_SIZE = 30_000  # bytes, same limit as read_file
+_MENTION_MAX_SIZE = 10_000  # bytes — smaller to protect context (model uses read_file for large files)
 _IMAGE_EXTENSIONS = {".png", ".jpg", ".jpeg", ".gif", ".webp", ".bmp"}
 _IMAGE_MAX_SIZE = 20 * 1024 * 1024  # 20MB
 
 
-def _resolve_mentions(text: str, cwd: str, agent_names: set[str] | None = None) -> tuple[str, int, list[Image]]:
-    """Resolve @file mentions by appending file contents to the message.
+@dataclass
+class MentionResult:
+    """Result of resolving @file mentions."""
+    text: str                          # User text (without file contents)
+    file_messages: list[dict[str, str]]  # Simulated tool-call pairs for history
+    images: list[Image]
+    count: int                         # Total attached (files + images)
 
-    Image files (png, jpg, etc.) are returned as Image objects instead of text.
+
+def _resolve_mentions(text: str, cwd: str, agent_names: set[str] | None = None) -> MentionResult:
+    """Resolve @file mentions as simulated read_file tool calls.
+
+    Instead of inlining file contents into the user message (which bloats
+    history and can't be pruned), we return separate assistant+tool_result
+    message pairs that the session can prune/compact like normal tool outputs.
+
+    Image files are returned as Image objects.
     Skips @mentions that match known agent names.
-    Returns (resolved_text, number_of_files_attached, images).
     """
     agent_names = agent_names or set()
     matches = list(_MENTION_RE.finditer(text))
     if not matches:
-        return text, 0, []
+        return MentionResult(text=text, file_messages=[], images=[], count=0)
 
-    appendix_parts = []
+    file_messages: list[dict[str, str]] = []
     images: list[Image] = []
     seen = set()
     for m in matches:
@@ -64,21 +77,18 @@ def _resolve_mentions(text: str, cwd: str, agent_names: set[str] | None = None)
             size = os.path.getsize(abs_path)
             with open(abs_path, "r", encoding="utf-8", errors="replace") as f:
                 content = f.read(_MENTION_MAX_SIZE)
-            if size > _MENTION_MAX_SIZE:
-                appendix_parts.append(
-                    f"\n\n---\nContents of {rel_path} (truncated to {_MENTION_MAX_SIZE // 1000}KB):\n```\n{content}\n```"
-                )
-            else:
-                appendix_parts.append(
-                    f"\n\n---\nContents of {rel_path}:\n```\n{content}\n```"
-                )
+            truncated = size > _MENTION_MAX_SIZE
+            label = f"[read_file: {rel_path}]"
+            if truncated:
+                label += f" (truncated to {_MENTION_MAX_SIZE // 1000}KB of {size // 1000}KB — use read_file for the rest)"
+            # Simulated tool call pair — can be pruned like normal tool outputs
+            file_messages.append({"role": "assistant", "content": label})
+            file_messages.append({"role": "user", "content": content})
         except OSError:
             continue
 
-    attached = len(appendix_parts) + len(images)
-    if appendix_parts:
-        return text + "".join(appendix_parts), attached, images
-    return text, attached, images
+    count = len(file_messages) // 2 + len(images)
+    return MentionResult(text=text, file_messages=file_messages, images=images, count=count)
 
 
 def _extract_agent_mention(