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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aru-code
-Version: 0.14.0
+Version: 0.15.0
 Summary: A Claude Code clone built with Agno agents
 Author-email: Estevao <estevaofon@gmail.com>
 License-Expression: MIT
@@ -369,7 +369,7 @@ Custom agents are Markdown files with YAML frontmatter stored in `.agents/agents
 name: Code Reviewer
 description: Review code for quality, bugs, and best practices
 model: anthropic/claude-sonnet-4-5
-tools: read_file, grep_search, glob_search, code_structure
+tools: read_file, grep_search, glob_search
 max_turns: 15
 mode: primary
 ---
@@ -480,8 +480,8 @@ 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` / `write_files` — Writes single or batch files
-- `edit_file` / `edit_files` — Find-replace edits across multiple files
+- `write_file` — Writes files
+- `edit_file` — Find-replace edits
 
 ### Search & Discovery
 - `glob_search` — Find files by pattern (respects .gitignore)
@@ -489,10 +489,6 @@ Aru can load tools from MCP servers. Configure in `.aru/mcp_config.json`:
 - `list_directory` — Directory listing with gitignore filtering
 - `rank_files` — Multi-factor file relevance ranking (name, structure, recency)
 
-### Code Analysis
-- `code_structure` — Extracts classes, functions, imports via tree-sitter AST
-- `find_dependencies` — Analyzes import relationships between files
-
 ### Shell & Web
 - `bash` — Executes shell commands with permission gates
 - `web_search` — Web search via DuckDuckGo

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

@@ -322,7 +322,7 @@ Custom agents are Markdown files with YAML frontmatter stored in `.agents/agents
 name: Code Reviewer
 description: Review code for quality, bugs, and best practices
 model: anthropic/claude-sonnet-4-5
-tools: read_file, grep_search, glob_search, code_structure
+tools: read_file, grep_search, glob_search
 max_turns: 15
 mode: primary
 ---
@@ -433,8 +433,8 @@ 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` / `write_files` — Writes single or batch files
-- `edit_file` / `edit_files` — Find-replace edits across multiple files
+- `write_file` — Writes files
+- `edit_file` — Find-replace edits
 
 ### Search & Discovery
 - `glob_search` — Find files by pattern (respects .gitignore)
@@ -442,10 +442,6 @@ Aru can load tools from MCP servers. Configure in `.aru/mcp_config.json`:
 - `list_directory` — Directory listing with gitignore filtering
 - `rank_files` — Multi-factor file relevance ranking (name, structure, recency)
 
-### Code Analysis
-- `code_structure` — Extracts classes, functions, imports via tree-sitter AST
-- `find_dependencies` — Analyzes import relationships between files
-
 ### Shell & Web
 - `bash` — Executes shell commands with permission gates
 - `web_search` — Web search via DuckDuckGo

aru_code-0.15.0/aru/__init__.py

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

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

@@ -35,7 +35,7 @@ PLANNER_ROLE = """\
 You are a software architect agent. Your job is to analyze codebases and create concise implementation plans.
 
 IMPORTANT: You are a READ-ONLY agent. You have NO tools to create, write, or edit files, or run shell commands. \
-Do NOT attempt to use write_file, edit_file, bash, run_command, or any write/exec tool — they do not exist in your toolkit. \
+Do NOT attempt to use write_file, edit_file, bash, or any write/exec tool — they do not exist in your toolkit. \
 To assess test coverage, read source files and test files directly — do NOT try to run pytest or any command. \
 Your sole output is the implementation plan. The executor agent will carry out the actual changes.
 
@@ -112,15 +112,12 @@ When all subtasks are done, STOP. Do not add extra actions beyond the task list.
 ## Subtask granularity — CRITICAL
 Each subtask should touch at most **3-4 files**. If the step involves many files, \
 split into subtasks grouped by concern (e.g. "Create model files", "Create route files", \
-"Update config and main"). Batch independent file writes using `write_files` or `edit_files` \
-to minimize tool calls. Batch independent file writes using `write_files` or `edit_files` to minimize tool calls.
+"Update config and main").
 
 ## Guidelines
 - Read files before editing them
 - Use edit_file for targeted changes (preferred over rewriting entire files)
 - Use write_file only for new files or complete rewrites
-- When creating or updating multiple independent files, use write_files to batch them
-- When making independent edits across files, use edit_files to batch them
 - Run existing tests after changes when applicable
 - **When adding or modifying unit tests, ALWAYS run them to verify they pass before finishing.**
 - Keep changes minimal and focused on the task
@@ -139,7 +136,7 @@ Use `context_lines=30` for full function bodies.
 
 **NEVER read the same file twice.** If you already have the file content in context, use it.
 
-**NEVER use bash/run_command to read files.** Always use `read_file` or `grep_search`.
+**NEVER use bash to read files.** Always use `read_file` or `grep_search`.
 
 **Batch independent tool calls**: emit ALL independent tool calls in a single response.
 
@@ -181,7 +178,7 @@ Every tool call accumulates its result in your context window. Use the minimum n
 
 **NEVER read the same file twice.** Check if you already have the content in context.
 
-**NEVER use bash/run_command to read files.** Always use `read_file` or `grep_search`.
+**NEVER use bash to read files.** Always use `read_file` or `grep_search`.
 
 **Batch independent tool calls**: emit ALL independent tool calls in a single response.
 
@@ -189,9 +186,7 @@ Every tool call accumulates its result in your context window. Use the minimum n
 
 **When adding or modifying unit tests, ALWAYS run them to verify they pass before finishing.**
 
-Use delegate_task to split work into independent subtasks for parallel execution.
-When creating or updating multiple independent files, use write_files to batch them.
-When making independent edits across files, use edit_files to batch them.\
+Use delegate_task to split work into independent subtasks for parallel execution.\
 """
 
 

{aru_code-0.14.0 → aru_code-0.15.0}/aru/context.py

@@ -11,7 +11,7 @@ from __future__ import annotations
 # ── Constants ──────────────────────────────────────────────────────
 
 # Pruning: minimum chars that must be freeable to justify a prune pass
-PRUNE_MINIMUM_CHARS = 20_000  # ~5.7K tokens
+PRUNE_MINIMUM_CHARS = 12_000  # ~3K tokens (lower = prune sooner)
 # Placeholder that replaces evicted content
 PRUNED_PLACEHOLDER = "[previous output cleared to save context]"
 # User messages larger than this threshold are truncated when outside protection window
@@ -22,18 +22,23 @@ PRUNE_USER_MSG_KEEP = 500  # ~140 tokens — enough to understand the request
 PRUNE_PROTECT_TURNS = 2
 # Tool result markers that should never be pruned (critical context)
 PRUNE_PROTECTED_MARKERS = {"[SubAgent-", "delegate_task"}
+# Tool names whose outputs should never be pruned (like OpenCode's PRUNE_PROTECTED_TOOLS)
+# These are checked as substrings in message content (tool results include the tool name)
+PRUNE_PROTECTED_TOOLS = {"delegate_task"}
 
 # Truncation: universal limits for any tool output
-TRUNCATE_MAX_LINES = 500
-TRUNCATE_MAX_BYTES = 20 * 1024  # 20 KB
-TRUNCATE_KEEP_START = 350  # lines to keep from the start
-TRUNCATE_KEEP_END = 100  # lines to keep from the end
+TRUNCATE_MAX_LINES = 300
+TRUNCATE_MAX_BYTES = 15 * 1024  # 15 KB (was 20KB — tighter to prevent context bloat)
+TRUNCATE_KEEP_START = 200  # lines to keep from the start
+TRUNCATE_KEEP_END = 60  # lines to keep from the end
 TRUNCATE_MAX_LINE_LENGTH = 2000  # chars per individual line (prevents minified files)
 
 # Compaction: trigger when per-run input tokens exceed this fraction of model limit
-COMPACTION_THRESHOLD_RATIO = 0.85
+COMPACTION_THRESHOLD_RATIO = 0.70  # was 0.85 — compact earlier to avoid hitting limits
 # Compaction: target post-compaction size as fraction of model context limit
 COMPACTION_TARGET_RATIO = 0.15
+# Compaction: reserve buffer for the compaction process itself (like OpenCode's 20K)
+COMPACTION_BUFFER_TOKENS = 20_000
 # Default model context limits (input tokens)
 MODEL_CONTEXT_LIMITS: dict[str, int] = {
     # Anthropic
@@ -103,13 +108,13 @@ def _get_prune_protect_chars(model_id: str = "default") -> int:
     """Scale protection window based on model context size.
 
     Larger models get more protection; smaller models prune more aggressively
-    to delay compaction. Returns ~10% of the model's context in chars (~3.5 chars/token).
+    to prevent context overflow. Returns ~7% of the model's context in chars.
     """
     limit = MODEL_CONTEXT_LIMITS.get(model_id, MODEL_CONTEXT_LIMITS["default"])
-    # ~3.5 chars per token, protect ~10% of context
-    protect = int(limit * 0.10 * 3.5)
-    # Clamp between 20K (minimum usable) and 80K (diminishing returns)
-    return max(20_000, min(protect, 80_000))
+    # ~4 chars per token, protect ~7% of context (was 10% — tighter budget)
+    protect = int(limit * 0.07 * 4)
+    # Clamp between 15K (minimum usable) and 60K (diminishing returns)
+    return max(15_000, min(protect, 60_000))
 
 
 def prune_history(
@@ -171,8 +176,10 @@ def prune_history(
             # Still within protection window
             protected += msg_len
         else:
-            # Check protected markers before pruning
-            if any(marker in msg["content"] for marker in PRUNE_PROTECTED_MARKERS):
+            # Check protected markers and tool names before pruning
+            content = msg["content"]
+            if (any(marker in content for marker in PRUNE_PROTECTED_MARKERS)
+                    or any(tool in content for tool in PRUNE_PROTECTED_TOOLS)):
                 protected += msg_len
                 continue
 
@@ -207,19 +214,59 @@ def _truncate_long_lines(lines: list[str]) -> list[str]:
     return result
 
 
-_TRUNCATION_HINT = (
-    "\n[Hint: Use grep_search to find specific content, or read_file with "
-    "start_line/end_line for incremental reading. "
-    "For large exploration tasks, use delegate_task to keep your context clean.]"
-)
+def _build_truncation_hint(
+    source_file: str = "",
+    source_tool: str = "",
+    lines_shown: int = 0,
+) -> str:
+    """Build a context-aware truncation hint that guides the LLM to save tokens.
 
+    When the source file is known, provides a direct read_file reference with
+    the next offset. Otherwise falls back to generic tool suggestions.
+    Always suggests delegate_task for large exploration work.
+    """
+    parts = ["\n[Hint: Output was truncated."]
+
+    if source_file:
+        # File-specific: tell the LLM exactly how to access the rest
+        next_line = lines_shown + 1 if lines_shown else 1
+        parts.append(
+            f' To see more: read_file("{source_file}", start_line={next_line}).'
+            f" Use grep_search to find specific content instead of reading everything."
+        )
+    elif source_tool == "bash":
+        parts.append(
+            " Use grep_search to find specific content in project files."
+            " Do NOT re-run the command to get full output."
+        )
+    else:
+        parts.append(
+            " Use grep_search to find specific content, or read_file with"
+            " start_line/end_line for incremental reading."
+        )
 
-def truncate_output(text: str) -> str:
+    # Always suggest delegation for large outputs
+    parts.append(
+        " For large exploration tasks, use delegate_task to keep your context clean.]"
+    )
+    return "".join(parts)
+
+
+def truncate_output(
+    text: str,
+    source_file: str = "",
+    source_tool: str = "",
+) -> str:
     """Universal truncation for tool outputs.
 
     Caps output at TRUNCATE_MAX_BYTES / TRUNCATE_MAX_LINES, keeping the
     start and end with a middle marker showing what was cut.
     Also truncates individual lines exceeding TRUNCATE_MAX_LINE_LENGTH.
+
+    Args:
+        text: The output text to truncate.
+        source_file: Optional file path that produced this output (for targeted hints).
+        source_tool: Optional tool name (e.g. "bash", "grep") for hint context.
     """
     if not text:
         return text
@@ -240,10 +287,11 @@ def truncate_output(text: str) -> str:
         head = lines[:TRUNCATE_KEEP_START]
         tail = lines[-TRUNCATE_KEEP_END:]
         omitted = line_count - TRUNCATE_KEEP_START - TRUNCATE_KEEP_END
+        hint = _build_truncation_hint(source_file, source_tool, TRUNCATE_KEEP_START)
         return (
             "".join(head)
             + f"\n\n[... {omitted:,} lines omitted ({line_count:,} total)]"
-            + _TRUNCATION_HINT + "\n\n"
+            + hint + "\n\n"
             + "".join(tail)
         )
 
@@ -258,11 +306,12 @@ def truncate_output(text: str) -> str:
         total += line_bytes
 
     remaining = line_count - len(kept_lines)
+    hint = _build_truncation_hint(source_file, source_tool, len(kept_lines))
     return (
         "".join(kept_lines)
         + f"\n\n[... truncated at ~{TRUNCATE_MAX_BYTES // 1024}KB — "
         f"{remaining:,} more lines]"
-        + _TRUNCATION_HINT + "\n"
+        + hint + "\n"
     )
 
 
@@ -278,7 +327,10 @@ def should_compact(
     history_or_tokens: int | list[dict[str, str]],
     model_id: str = "default",
 ) -> bool:
-    """Check if the conversation should be compacted (reactive, post-run).
+    """Check if the conversation should be compacted.
+
+    Uses OpenCode's approach: usable = model_limit - buffer, then
+    trigger when tokens >= usable * threshold_ratio.
 
     Accepts either an estimated token count (int) or the history list
     (from which tokens are estimated via char count).
@@ -288,7 +340,8 @@ def should_compact(
     else:
         tokens = history_or_tokens
     limit = MODEL_CONTEXT_LIMITS.get(model_id, MODEL_CONTEXT_LIMITS["default"])
-    threshold = int(limit * COMPACTION_THRESHOLD_RATIO)
+    usable = limit - COMPACTION_BUFFER_TOKENS
+    threshold = int(usable * COMPACTION_THRESHOLD_RATIO)
     return tokens >= threshold
 
 
@@ -340,9 +393,14 @@ def build_compaction_prompt(
     if plan_task:
         parts.append(f"**Active task:** {plan_task}\n\n")
 
+    import re as _re
+    _code_block_re = _re.compile(r"```[\s\S]*?```")
+
     for msg in old_msgs:
         role = msg["role"].upper()
         content = msg["content"]
+        # Strip large code blocks — compactor only needs to know what was done, not raw code
+        content = _code_block_re.sub("[code block removed]", content)
         # Cap individual messages in the compaction input to avoid blowing up
         if len(content) > 2000:
             content = content[:2000] + f"... [{len(content) - 2000} chars truncated]"
@@ -409,7 +467,12 @@ async def compact_conversation(
         compactor = Agent(
             name="Compactor",
             model=create_model(small_ref, max_tokens=2048),
-            instructions="You summarize conversations concisely. Output ONLY the summary, no preamble.",
+            instructions=(
+                "You summarize coding conversations concisely. Output ONLY the requested sections, no preamble. "
+                "Preserve: user goals, explicit instructions/preferences, file paths with line numbers, "
+                "function/class names that were modified, and what remains to be done. "
+                "Drop: raw code blocks, tool output details, greetings, reasoning."
+            ),
             markdown=True,
         )
 

{aru_code-0.14.0 → aru_code-0.15.0}/aru/display.py

@@ -198,15 +198,11 @@ TOOL_DISPLAY_NAMES = {
     "read_file": "Read",
     "read_file_smart": "ReadSmart",
     "write_file": "Write",
-    "write_files": "Write",
     "edit_file": "Edit",
-    "edit_files": "Edit",
     "glob_search": "Glob",
     "grep_search": "Grep",
     "list_directory": "List",
     "bash": "Bash",
-    "code_structure": "Structure",
-    "find_dependencies": "Deps",
     "rank_files": "Rank",
 }
 
@@ -219,8 +215,6 @@ TOOL_PRIMARY_ARG = {
     "grep_search": "pattern",
     "list_directory": "directory",
     "bash": "command",
-    "code_structure": "file_path",
-    "find_dependencies": "file_path",
     "rank_files": "task",
 }
 
@@ -231,13 +225,6 @@ def _format_tool_label(tool_name: str, tool_args: dict | None) -> str:
     if not tool_args:
         return display
 
-    if tool_name == "write_files":
-        files = tool_args.get("files", [])
-        return f"{display}({len(files)} files)"
-    if tool_name == "edit_files":
-        edits = tool_args.get("edits", [])
-        return f"{display}({len(edits)} edits)"
-
     primary_key = TOOL_PRIMARY_ARG.get(tool_name)
     if primary_key and primary_key in tool_args:
         value = str(tool_args[primary_key])

{aru_code-0.14.0 → aru_code-0.15.0}/aru/runner.py

@@ -23,7 +23,7 @@ from aru.permissions import get_skip_permissions
 
 
 # Categories of tools that modify files (for highlighting in history)
-_MUTATION_TOOLS = {"write_file", "write_files", "edit_file", "edit_files", "bash", "run_command"}
+_MUTATION_TOOLS = {"write_file", "edit_file", "bash"}
 
 
 def build_env_context(session, cwd: str | None = None) -> str:
@@ -249,12 +249,15 @@ async def run_agent_capture(agent, message: str, session=None, lightweight: bool
             run_input_tokens = getattr(run_output.metrics, "input_tokens", 0) or 0
             if should_compact(run_input_tokens, session.model_id):
                 try:
+                    # Always prune first to shrink history before compaction
+                    session.history = prune_history(session.history, model_id=session.model_id)
                     session.history = await compact_conversation(
                         session.history, session.model_ref, session.plan_task,
                         model_id=session.model_id,
                     )
                     console.print("[dim]Context compacted to save tokens.[/dim]")
                 except Exception:
+                    # Even if compaction fails, keep the pruned history
                     pass
 
         final_content = accumulated or final_content

{aru_code-0.14.0 → aru_code-0.15.0}/aru/tools/ast_tools.py

@@ -257,39 +257,6 @@ def _format_structure(structure: dict, file_path: str, total_lines: int) -> str:
     return "\n".join(parts)
 
 
-def code_structure(file_path: str) -> str:
-    """Analyze a file and return its structural overview: imports, classes, functions, and globals.
-
-    Useful for quickly understanding what a file contains without reading its full content.
-    Works best with Python files (using tree-sitter AST parsing), but falls back to
-    regex-based extraction for other languages.
-
-    Args:
-        file_path: Path to the file to analyze.
-    """
-    try:
-        with open(file_path, "r", encoding="utf-8", errors="ignore") as f:
-            content = f.read()
-    except FileNotFoundError:
-        return f"Error: File not found: {file_path}"
-    except Exception as e:
-        return f"Error reading file: {e}"
-
-    total_lines = content.count("\n") + 1
-    _, ext = os.path.splitext(file_path)
-
-    # Try tree-sitter for supported languages
-    if ext in SUPPORTED_EXTENSIONS and _TREE_SITTER_AVAILABLE:
-        source = content.encode("utf-8")
-        tree = _parse_python_tree(source)
-        if tree:
-            structure = _extract_structure_treesitter(tree, source, file_path)
-            return _format_structure(structure, file_path, total_lines)
-
-    # Fallback to regex
-    structure = _extract_structure_regex(content)
-    return _format_structure(structure, file_path, total_lines)
-
 
 def _resolve_import_to_file(import_text: str, project_root: str) -> str | None:
     """Try to resolve an import statement to a file path within the project."""
@@ -331,94 +298,3 @@ def _find_project_root(file_path: str) -> str:
         current = parent
 
 
-def find_dependencies(file_path: str, depth: int = 3) -> str:
-    """Trace the import dependency tree of a file within the project.
-
-    Resolves local imports (within the project) and shows which files depend on which.
-    Skips stdlib and third-party packages. Useful for understanding how files are connected.
-
-    Args:
-        file_path: Path to the file to analyze.
-        depth: Maximum recursion depth for tracing imports. Defaults to 3.
-    """
-    if not os.path.isfile(file_path):
-        return f"Error: File not found: {file_path}"
-
-    project_root = _find_project_root(file_path)
-    rel_start = os.path.relpath(file_path, project_root).replace("\\", "/")
-
-    visited: set[str] = set()
-    tree_lines: list[str] = []
-
-    def _trace(rel_path: str, current_depth: int, prefix: str = "", is_last: bool = True):
-        if rel_path in visited or current_depth > depth:
-            if rel_path in visited:
-                connector = "└── " if is_last else "├── "
-                tree_lines.append(f"{prefix}{connector}{rel_path} (circular)")
-            return
-
-        visited.add(rel_path)
-        connector = "└── " if is_last else "├── "
-
-        if current_depth == 0:
-            tree_lines.append(rel_path)
-        else:
-            tree_lines.append(f"{prefix}{connector}{rel_path}")
-
-        # Read file and extract imports
-        full_path = os.path.join(project_root, rel_path)
-        if not os.path.isfile(full_path):
-            return
-
-        try:
-            with open(full_path, "r", encoding="utf-8", errors="ignore") as f:
-                content = f.read()
-        except OSError:
-            return
-
-        # Extract imports (tree-sitter or regex)
-        _, ext = os.path.splitext(rel_path)
-        imports = []
-
-        if ext == ".py" and _TREE_SITTER_AVAILABLE:
-            source = content.encode("utf-8")
-            tree = _parse_python_tree(source)
-            if tree:
-                for child in tree.root_node.children:
-                    if child.type in ("import_statement", "import_from_statement"):
-                        text = source[child.start_byte:child.end_byte].decode("utf-8", errors="ignore").strip()
-                        imports.append(text)
-        else:
-            for line in content.split("\n"):
-                stripped = line.strip()
-                if stripped.startswith("import ") or stripped.startswith("from "):
-                    imports.append(stripped)
-
-        # Resolve imports to local files
-        local_deps = []
-        for imp in imports:
-            resolved = _resolve_import_to_file(imp, project_root)
-            if resolved and resolved != rel_path:
-                local_deps.append(resolved)
-
-        # Remove duplicates while preserving order
-        seen = set()
-        unique_deps = []
-        for dep in local_deps:
-            normalized = dep.replace("\\", "/")
-            if normalized not in seen:
-                seen.add(normalized)
-                unique_deps.append(normalized)
-
-        # Recurse into dependencies
-        child_prefix = prefix + ("    " if is_last else "│   ")
-        for i, dep in enumerate(unique_deps):
-            is_dep_last = (i == len(unique_deps) - 1)
-            _trace(dep, current_depth + 1, child_prefix if current_depth > 0 else "", is_dep_last)
-
-    _trace(rel_start, 0)
-
-    if not tree_lines:
-        return f"No dependencies found for: {file_path}"
-
-    return "\n".join(tree_lines)