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

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

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

aru_code-0.14.0/aru/__init__.py

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

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

@@ -3,9 +3,26 @@
 # Common rules shared across all agents (planner, executor, general).
 # Each agent appends its role-specific instructions to this base.
 BASE_INSTRUCTIONS = """\
-Be concise and direct. Focus on doing the work, not explaining what you'll do.
+## Output rules — CRITICAL for token efficiency
+
+Minimize output tokens. Your responses should be fewer than 4 lines unless the user \
+asks for detail or you are writing code. One word answers are best when they suffice.
+
+Do NOT add unnecessary preamble or postamble. Avoid introductions, conclusions, \
+and explanations of what you will do or just did. Do not add code explanation \
+summaries unless the user requests them. Only address the specific query or task at hand.
+
 NEVER write narration before calling tools. Do NOT say "I will analyze...", "Let me check...", \
 "Now I will...", or any similar preamble. Call the tool immediately and silently.
+
+Examples of ideal responses:
+- user: "2 + 2" → assistant: "4"
+- user: "is 11 prime?" → assistant: "Yes"
+- user: "what command lists files?" → assistant: "ls"
+- user: "fix the typo in line 5" → [call edit_file immediately, no narration]
+
+## Scope rules
+
 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. \

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

@@ -18,12 +18,17 @@ PRUNED_PLACEHOLDER = "[previous output cleared to save context]"
 PRUNE_USER_MSG_THRESHOLD = 2_000  # ~570 tokens — catches @file mentions
 # How many chars to keep from the start of a pruned user message
 PRUNE_USER_MSG_KEEP = 500  # ~140 tokens — enough to understand the request
+# Minimum number of recent user turns always protected (regardless of char budget)
+PRUNE_PROTECT_TURNS = 2
+# Tool result markers that should never be pruned (critical context)
+PRUNE_PROTECTED_MARKERS = {"[SubAgent-", "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_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
@@ -70,15 +75,26 @@ MODEL_CONTEXT_LIMITS: dict[str, int] = {
 }
 
 COMPACTION_TEMPLATE = """\
-Summarize this conversation concisely. Preserve:
-1. **Goal**: What the user wants to accomplish
-2. **Key decisions**: Important choices made during the conversation
-3. **Discoveries**: What was learned about the codebase or problem
-4. **Accomplished**: What has been done so far (be specific about files changed)
-5. **Relevant files**: File paths that are important for continuing the work
-6. **Next steps**: What remains to be done
+Summarize this conversation into the EXACT sections below. Be concise but complete — \
+this summary replaces the full conversation history. Output ONLY these sections:
 
-Be concise but complete. This summary replaces the full conversation history."""
+## Goal
+What the user is trying to accomplish (1-2 sentences).
+
+## Instructions
+Important instructions or preferences the user stated (bullet list). \
+If none, write "None stated."
+
+## Discoveries
+Notable things learned about the codebase, bugs, or architecture (bullet list). \
+If none, write "None."
+
+## Accomplished
+What was done so far — be specific about files created/changed and functions added/modified. \
+List what is in progress and what remains (bullet list).
+
+## Relevant files / directories
+Structured list of file paths relevant to continuing the work (one per line)."""
 
 
 # ── Layer 1: Pruning ──────────────────────────────────────────────
@@ -104,9 +120,14 @@ def prune_history(
     Walks backward through history, protecting the most recent content
     (scaled to the model's context size). Older messages beyond that
     budget are pruned:
-    - Assistant messages: replaced entirely with placeholder
+    - Assistant messages: replaced entirely with placeholder (unless protected)
     - User messages over PRUNE_USER_MSG_THRESHOLD: truncated to first N chars
 
+    Protection layers:
+    1. Turn-based: last PRUNE_PROTECT_TURNS user turns always kept
+    2. Char-based: recent content within the protection window
+    3. Content-based: messages containing PRUNE_PROTECTED_MARKERS never pruned
+
     Returns a new list (does not mutate the input).
     """
     if len(history) <= 2:
@@ -121,6 +142,18 @@ def prune_history(
     if total_chars < protect_chars + PRUNE_MINIMUM_CHARS:
         return list(history)
 
+    # Identify indices of last N user turns (always protected)
+    turn_protected: set[int] = set()
+    user_turns_seen = 0
+    for i in range(len(history) - 1, -1, -1):
+        if history[i]["role"] == "user":
+            user_turns_seen += 1
+            if user_turns_seen <= PRUNE_PROTECT_TURNS:
+                turn_protected.add(i)
+                # Also protect the assistant response right after this user turn
+                if i + 1 < len(history):
+                    turn_protected.add(i + 1)
+
     # Walk backward, protecting recent content
     result = list(history)
     protected = 0
@@ -129,10 +162,20 @@ def prune_history(
         msg = result[i]
         msg_len = len(msg["content"])
 
+        # Turn-based protection: never prune last N user turns
+        if i in turn_protected:
+            protected += msg_len
+            continue
+
         if protected + msg_len <= protect_chars:
             # 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):
+                protected += msg_len
+                continue
+
             # Beyond protection window — prune
             if msg["role"] == "assistant":
                 if msg["content"] != PRUNED_PLACEHOLDER:
@@ -147,11 +190,36 @@ def prune_history(
 
 # ── Layer 2: Truncation ───────────────────────────────────────────
 
+def _truncate_long_lines(lines: list[str]) -> list[str]:
+    """Truncate individual lines that exceed MAX_LINE_LENGTH.
+
+    Prevents minified JS/CSS or log lines from consuming massive tokens.
+    """
+    result = []
+    for line in lines:
+        if len(line) > TRUNCATE_MAX_LINE_LENGTH:
+            result.append(
+                line[:TRUNCATE_MAX_LINE_LENGTH]
+                + f"... (line truncated to {TRUNCATE_MAX_LINE_LENGTH} chars)\n"
+            )
+        else:
+            result.append(line)
+    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 truncate_output(text: 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.
     """
     if not text:
         return text
@@ -161,8 +229,11 @@ def truncate_output(text: str) -> str:
     lines = text.splitlines(keepends=True)
     line_count = len(lines)
 
+    # Truncate individual long lines first
+    lines = _truncate_long_lines(lines)
+
     if byte_len <= TRUNCATE_MAX_BYTES and line_count <= TRUNCATE_MAX_LINES:
-        return text
+        return "".join(lines)
 
     # Truncate by lines
     if line_count > TRUNCATE_MAX_LINES:
@@ -171,8 +242,8 @@ def truncate_output(text: str) -> str:
         omitted = line_count - TRUNCATE_KEEP_START - TRUNCATE_KEEP_END
         return (
             "".join(head)
-            + f"\n\n[... {omitted:,} lines omitted ({line_count:,} total) — "
-            f"use offset/limit or a more specific query ...]\n\n"
+            + f"\n\n[... {omitted:,} lines omitted ({line_count:,} total)]"
+            + _TRUNCATION_HINT + "\n\n"
             + "".join(tail)
         )
 
@@ -190,7 +261,8 @@ def truncate_output(text: str) -> str:
     return (
         "".join(kept_lines)
         + f"\n\n[... truncated at ~{TRUNCATE_MAX_BYTES // 1024}KB — "
-        f"{remaining:,} more lines — use offset/limit to read further ...]\n"
+        f"{remaining:,} more lines]"
+        + _TRUNCATION_HINT + "\n"
     )
 
 
@@ -287,7 +359,7 @@ def apply_compaction(
 
     Uses the same protection window as pruning: recent messages within
     the window are preserved as-is, older messages are replaced by a
-    compaction summary. This preserves the natural conversation flow.
+    compaction summary. Replays the last user message to maintain continuity.
     """
     _, recent = _split_history(history, model_id)
 
@@ -296,6 +368,21 @@ def apply_compaction(
     ]
     compacted.extend(recent)
 
+    # Replay: ensure the last message is from the user so the LLM continues naturally
+    if not compacted or compacted[-1]["role"] != "user":
+        # Find last user message in original history for replay
+        last_user = None
+        for msg in reversed(history):
+            if msg["role"] == "user":
+                last_user = msg["content"]
+                break
+        if last_user:
+            # Truncate replayed message to avoid re-bloating context
+            replay = last_user[:1000] if len(last_user) > 1000 else last_user
+            compacted.append({"role": "user", "content": replay})
+        else:
+            compacted.append({"role": "user", "content": "Continue if you have next steps, or stop and ask for clarification."})
+
     return compacted
 
 

{aru_code-0.13.3 → aru_code-0.14.0}/aru/tools/codebase.py

@@ -321,6 +321,35 @@ def write_files(file_list: list[dict]) -> str:
     return "\n".join(parts) or "No files to write."
 
 
+def _compact_diff(old_string: str, new_string: str, file_path: str = "") -> str:
+    """Generate a compact unified diff string for the LLM context.
+
+    Returns only the changed lines (not the full file), saving tokens while
+    giving the LLM enough context to continue working.
+    """
+    old_lines = old_string.splitlines(keepends=True)
+    new_lines = new_string.splitlines(keepends=True)
+    # Ensure trailing newlines for clean diff
+    if old_lines and not old_lines[-1].endswith("\n"):
+        old_lines[-1] += "\n"
+    if new_lines and not new_lines[-1].endswith("\n"):
+        new_lines[-1] += "\n"
+
+    import difflib
+    diff_lines = list(difflib.unified_diff(
+        old_lines, new_lines,
+        fromfile=file_path, tofile=file_path,
+        lineterm="",
+    ))
+    if not diff_lines:
+        return ""
+    # Cap diff output to avoid huge diffs bloating context
+    MAX_DIFF_LINES = 40
+    if len(diff_lines) > MAX_DIFF_LINES:
+        return "\n".join(diff_lines[:MAX_DIFF_LINES]) + f"\n... ({len(diff_lines) - MAX_DIFF_LINES} more diff lines)"
+    return "\n".join(diff_lines)
+
+
 def edit_file(file_path: str, old_string: str, new_string: str) -> str:
     """Replace an exact string in a file. The old_string must appear exactly once.
 
@@ -347,7 +376,12 @@ def edit_file(file_path: str, old_string: str, new_string: str) -> str:
         with open(file_path, "w", encoding="utf-8") as f:
             f.write(new_content)
         _notify_file_mutation()
-        return f"Successfully edited {file_path}"
+
+        # Return compact diff instead of just success message
+        diff_text = _compact_diff(old_string, new_string, file_path)
+        if diff_text:
+            return f"Edited {file_path}\n{diff_text}"
+        return f"Edited {file_path}"
     except FileNotFoundError:
         return f"Error: File not found: {file_path}"
     except Exception as e:
@@ -423,7 +457,16 @@ def edit_files(edits: list[dict]) -> str:
     if results:
         _notify_file_mutation()
         unique = list(dict.fromkeys(results))  # preserve order, dedupe
-        parts.append(f"Successfully applied {len(results)} edits across {len(unique)} files: {', '.join(unique)}")
+        parts.append(f"Applied {len(results)} edits across {len(unique)} files: {', '.join(unique)}")
+        # Append compact diffs for each edit
+        for entry in edits:
+            old = entry.get("old_string", "")
+            new = entry.get("new_string", "")
+            path = entry.get("path", "")
+            if old and path in written:
+                diff_text = _compact_diff(old, new, path)
+                if diff_text:
+                    parts.append(diff_text)
     if errors:
         parts.append("\n".join(errors))
     return "\n".join(parts) or "No edits to apply."

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

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

{aru_code-0.13.3 → aru_code-0.14.0}/pyproject.toml

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

{aru_code-0.13.3 → aru_code-0.14.0}/tests/test_codebase.py

@@ -209,7 +209,7 @@ def test_edit_file_basic(tmp_path):
     finally:
         set_skip_permissions(False)
 
-    assert "Successfully edited" in result
+    assert "Edited" in result
     assert f.read_text() == "def hello():\n    return 'earth'\n"
 
 
@@ -234,7 +234,7 @@ def test_edit_file_search_replace(tmp_path):
     finally:
         set_skip_permissions(False)
 
-    assert "Successfully edited" in result
+    assert "Edited" in result
     updated = f.read_text()
     assert "DB_HOST = 'production.example.com'" in updated
     assert "DB_PORT = 5433" in updated
@@ -427,7 +427,7 @@ class TestEditFiles:
         finally:
             set_skip_permissions(False)
 
-        assert "Successfully" in result
+        assert "Applied" in result or "Edited" in result
         assert f1.read_text() == "alpha = 10"
         assert f2.read_text() == "beta = 20"
 
@@ -446,7 +446,7 @@ class TestEditFiles:
         finally:
             set_skip_permissions(False)
 
-        assert "Successfully" in result
+        assert "Applied" in result or "Edited" in result
         content = f.read_text()
         assert "HOST = 'prod.example.com'" in content
         assert "PORT = 8080" in content
@@ -501,7 +501,7 @@ class TestEditFiles:
         finally:
             set_skip_permissions(False)
 
-        assert "Successfully" in result
+        assert "Applied" in result or "Edited" in result
 
         content_a = f1.read_text()
         assert "import logging" in content_a

aru_code-0.13.3/aru/__init__.py

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