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

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

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

aru_code-0.18.0/aru/__init__.py

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

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

@@ -27,7 +27,22 @@ NEVER create documentation files (*.md) unless the user explicitly asks for them
 Focus on writing working code, not documentation.
 Deliver EXACTLY what was asked — no more, no less. \
 One function requested = one function written. Helper functions, tests, utilities, and "while I'm here" \
-improvements are out of scope unless the user names them explicitly.\
+improvements are out of scope unless the user names them explicitly.
+
+## Reasoning rules
+
+**Verify before asserting.** If you describe what a function, module, or system does, \
+you must have actually read the relevant code in this conversation. Inferring behavior \
+from a call site, function name, or adjacent code counts as hallucination — "it probably \
+does X" is not a valid source. When you are about to make a claim about unread code, \
+stop and `grep_search` or `read_file` first. Reading is cheaper than being wrong.
+
+**Adopt user scope corrections immediately.** When the user redirects the conversation \
+("actually, look at X instead", "that one is a different context", "o scheduler que eu \
+disse é Y"), drop the previous frame completely. Do not hedge with caveats about the \
+earlier topic ("Porém, se também considerarmos...") unless the user explicitly asks for \
+them. The user's correction is authoritative — respond as if the earlier framing never \
+happened.\
 """
 
 # Planner-specific additions (read-only exploration + output format)
@@ -45,8 +60,8 @@ Every tool call accumulates its result in your context window. Use the minimum n
 
 1. **Find files/patterns** → `grep_search(pattern, file_glob="*.py")` or `glob_search`. \
 Default shows 10 lines of context — use `context_lines=30` for full function bodies.
-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
+2. **Understand a file** → `read_file_smart(file_path, query)` — returns a concise answer, not raw content
+3. **Need raw content** → `read_file(file_path)` — returns first chunk + outline for large files
 
 **Batch independent tool calls**: When you need answers from multiple independent sources, \
 emit ALL those tool calls in a single response.
@@ -127,12 +142,12 @@ split into subtasks grouped by concern (e.g. "Create model files", "Create route
 
 ## Reading strategy — read, edit, test
 
-1. **Know the file + have a question?** → `read_file_smart(path, query)`
+1. **Know the file + have a question?** → `read_file_smart(file_path, query)`
 2. **Need a specific pattern?** → `grep_search(pattern, file_glob="*.py")` — default 10 lines context. \
 Use `context_lines=30` for full function bodies.
-3. **Need lines for editing?** → `read_file(path, start_line=N, end_line=M)` using line numbers from grep
-4. **Need the whole file?** → `read_file(path)` — returns first chunk + outline for large files
-5. **Need the COMPLETE file (>60KB)?** → `read_file(path, max_size=0)` — reads in chunks. Use rarely.
+3. **Need lines for editing?** → `read_file(file_path, start_line=N, end_line=M)` using line numbers from grep
+4. **Need the whole file?** → `read_file(file_path)` — returns first chunk + outline for large files
+5. **Need the COMPLETE file (>60KB)?** → `read_file(file_path, max_size=0)` — reads in chunks. Use rarely.
 
 **NEVER read the same file twice.** If you already have the file content in context, use it.
 
@@ -171,10 +186,10 @@ Skip exploration when the task is clear and the relevant files are obvious.
 Every tool call accumulates its result in your context window. Use the minimum needed:
 
 1. **Don't know which file?** → `grep_search` / `glob_search` for patterns, \
-`read_file_smart(path, query)` when you know the file.
-2. **Know the file + have a question?** → `read_file_smart(path, query)`
-3. **Need specific lines?** → `read_file(path, start_line=N, end_line=M)`
-4. **Need the whole file?** → `read_file(path)` — returns first chunk + outline for large files.
+`read_file_smart(file_path, query)` when you know the file.
+2. **Know the file + have a question?** → `read_file_smart(file_path, query)`
+3. **Need specific lines?** → `read_file(file_path, start_line=N, end_line=M)`
+4. **Need the whole file?** → `read_file(file_path)` — returns first chunk + outline for large files.
 
 **NEVER read the same file twice.** Check if you already have the content in context.
 

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

@@ -497,9 +497,7 @@ async def run_cli(skip_permissions: bool = False, resume_id: str | None = None):
                 else:
                     agent = create_general_agent(session, config, env_context=env_ctx)
                 session.add_message("user", user_input)
-                run_result = await run_agent_capture(agent, prompt, session, images=attached_images or None)
-                if run_result.content:
-                    session.add_message("assistant", run_result.with_tools_summary())
+                await run_agent_capture(agent, prompt, session, images=attached_images or None)
             elif cmd_name in config.skills:
                 skill = config.skills[cmd_name]
                 if not skill.user_invocable:
@@ -510,9 +508,7 @@ async def run_cli(skip_permissions: bool = False, resume_id: str | None = None):
 
                     agent = create_general_agent(session, config, env_context=_build_env_ctx())
                     session.add_message("user", user_input)
-                    run_result = await run_agent_capture(agent, prompt, session, images=attached_images or None)
-                    if run_result.content:
-                        session.add_message("assistant", run_result.with_tools_summary())
+                    await run_agent_capture(agent, prompt, session, images=attached_images or None)
             elif cmd_name in config.custom_agents:
                 agent_def = config.custom_agents[cmd_name]
                 if agent_def.mode == "subagent":
@@ -523,9 +519,7 @@ async def run_cli(skip_permissions: bool = False, resume_id: str | None = None):
                     agent = create_custom_agent_instance(agent_def, session, config, env_context=_build_env_ctx())
                     session.add_message("user", user_input)
                     with permission_scope(agent_def.permission):
-                        run_result = await run_agent_capture(agent, cmd_args or user_input, session, images=attached_images or None)
-                    if run_result.content:
-                        session.add_message("assistant", run_result.with_tools_summary())
+                        await run_agent_capture(agent, cmd_args or user_input, session, images=attached_images or None)
             else:
                 console.print(f"[yellow]Unknown command: /{cmd_name}[/yellow]")
                 console.print(f"[dim]Built-in: /plan, /model, /sessions, /commands, /skills, /agents, /cost, /quit[/dim]")
@@ -551,15 +545,11 @@ async def run_cli(skip_permissions: bool = False, resume_id: str | None = None):
                 agent = create_custom_agent_instance(agent_def, session, config, env_context=_build_env_ctx())
                 session.add_message("user", user_input)
                 with permission_scope(agent_def.permission):
-                    run_result = await run_agent_capture(agent, message_text, session, images=attached_images or None)
-                if run_result.content:
-                    session.add_message("assistant", run_result.with_tools_summary())
+                    await run_agent_capture(agent, message_text, session, images=attached_images or None)
             else:
                 agent = create_general_agent(session, config, env_context=_build_env_ctx())
                 session.add_message("user", user_input)
-                run_result = await run_agent_capture(agent, user_input, session, images=attached_images or None)
-                if run_result.content:
-                    session.add_message("assistant", run_result.with_tools_summary())
+                await run_agent_capture(agent, user_input, session, images=attached_images or None)
 
         # Show token usage and auto-save
         if session.token_summary:

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

@@ -2,9 +2,11 @@
 
 from __future__ import annotations
 
+import inspect
 import os
 import re
 from dataclasses import dataclass
+from functools import lru_cache
 
 from prompt_toolkit import PromptSession
 from prompt_toolkit.completion import Completer, Completion
@@ -24,11 +26,28 @@ _IMAGE_EXTENSIONS = {".png", ".jpg", ".jpeg", ".gif", ".webp", ".bmp"}
 _IMAGE_MAX_SIZE = 20 * 1024 * 1024  # 20MB
 
 
+@lru_cache(maxsize=1)
+def _read_file_arg_name() -> str:
+    """Return the name of the first parameter of the real `read_file` tool.
+
+    Used by `_resolve_mentions` to forge tool_use blocks whose `input` dict
+    key matches the real tool signature exactly. If `read_file` is ever
+    renamed or its signature changes, this introspection picks up the new
+    name automatically — eliminating the entire class of "forged example
+    drifted from real tool" bugs.
+
+    Cached via lru_cache so the introspection runs once per process.
+    Imported lazily to avoid any import-time coupling with aru.tools.
+    """
+    from aru.tools.codebase import read_file
+    return next(iter(inspect.signature(read_file).parameters))
+
+
 @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
+    file_messages: list[dict]          # Block-shaped tool_use/tool_result pairs for history
     images: list[Image]
     count: int                         # Total attached (files + images)
 
@@ -37,20 +56,25 @@ def _resolve_mentions(text: str, cwd: str, agent_names: set[str] | None = None)
     """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.
+    history and can't be pruned), we return real block-shaped tool_use /
+    tool_result message pairs with synthetic tool_use_ids. The prune
+    pipeline in `aru.context.prune_history` then treats them as atomic
+    pairs — label and content can't be cut apart.
 
     Image files are returned as Image objects.
     Skips @mentions that match known agent names.
     """
+    from aru.history_blocks import tool_use_block, tool_result_block
+
     agent_names = agent_names or set()
     matches = list(_MENTION_RE.finditer(text))
     if not matches:
         return MentionResult(text=text, file_messages=[], images=[], count=0)
 
-    file_messages: list[dict[str, str]] = []
+    file_messages: list[dict] = []
     images: list[Image] = []
     seen = set()
+    mention_idx = 0
     for m in matches:
         rel_path = m.group(1)
         if rel_path.lower() in agent_names:
@@ -78,12 +102,30 @@ def _resolve_mentions(text: str, cwd: str, agent_names: set[str] | None = None)
             with open(abs_path, "r", encoding="utf-8", errors="replace") as f:
                 content = f.read(_MENTION_MAX_SIZE)
             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})
+                content += (
+                    f"\n\n[truncated to {_MENTION_MAX_SIZE // 1000}KB of "
+                    f"{size // 1000}KB — use read_file for the rest]"
+                )
+            # Synthetic tool_use_id so the prune pipeline can pair the
+            # assistant tool_use block with its matching tool_result.
+            # The `input` dict key is derived at runtime from the real
+            # read_file signature via `_read_file_arg_name()` — this makes
+            # the forgery drift-proof: if `read_file` is ever renamed or
+            # its first parameter changes, the forged example automatically
+            # tracks the new name. Without this, the model would see its
+            # own prior "tool calls" in history using a stale arg name and
+            # copy that stale pattern, producing Pydantic validation errors.
+            tu_id = f"mention_{mention_idx}_{abs(hash(rel_path)) & 0xFFFFFF:06x}"
+            mention_idx += 1
+            file_messages.append({
+                "role": "assistant",
+                "content": [tool_use_block(tu_id, "read_file", {_read_file_arg_name(): rel_path})],
+            })
+            file_messages.append({
+                "role": "tool",
+                "content": [tool_result_block(tu_id, content)],
+            })
         except OSError:
             continue