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

{aru_code-0.13.2/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.2
+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.2 → 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.2 → aru_code-0.14.0}/aru/context.py

@@ -10,8 +10,6 @@ from __future__ import annotations
 
 # ── Constants ──────────────────────────────────────────────────────
 
-# Pruning: protect the most recent N chars of content from eviction
-PRUNE_PROTECT_CHARS = 50_000  # ~14K tokens
 # Pruning: minimum chars that must be freeable to justify a prune pass
 PRUNE_MINIMUM_CHARS = 20_000  # ~5.7K tokens
 # Placeholder that replaces evicted content
@@ -20,15 +18,22 @@ 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 cumulative input tokens exceed this fraction of model limit
+# Compaction: trigger when per-run input tokens exceed this fraction of model limit
 COMPACTION_THRESHOLD_RATIO = 0.85
+# Compaction: target post-compaction size as fraction of model context limit
+COMPACTION_TARGET_RATIO = 0.15
 # Default model context limits (input tokens)
 MODEL_CONTEXT_LIMITS: dict[str, int] = {
     # Anthropic
@@ -70,40 +75,85 @@ 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 ──────────────────────────────────────────────
 
-def prune_history(history: list[dict[str, str]]) -> list[dict[str, str]]:
+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).
+    """
+    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))
+
+
+def prune_history(
+    history: list[dict[str, str]], model_id: str = "default"
+) -> list[dict[str, str]]:
     """Replace old messages with a short placeholder to reduce tokens.
 
     Walks backward through history, protecting the most recent content
-    (up to PRUNE_PROTECT_CHARS total across both roles). Older messages
-    beyond that budget are pruned:
-    - Assistant messages: replaced entirely with placeholder
+    (scaled to the model's context size). Older messages beyond that
+    budget are pruned:
+    - 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:
         return list(history)
 
+    protect_chars = _get_prune_protect_chars(model_id)
+
     # Calculate total prunable chars (both roles)
     total_chars = sum(len(msg["content"]) for msg in history)
 
     # Not enough to prune
-    if total_chars < PRUNE_PROTECT_CHARS + PRUNE_MINIMUM_CHARS:
+    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
@@ -112,17 +162,25 @@ def prune_history(history: list[dict[str, str]]) -> list[dict[str, str]]:
         msg = result[i]
         msg_len = len(msg["content"])
 
-        if protected + msg_len <= PRUNE_PROTECT_CHARS:
+        # 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:
                     result[i] = {"role": "assistant", "content": PRUNED_PLACEHOLDER}
             elif msg["role"] == "user" and msg_len > PRUNE_USER_MSG_THRESHOLD:
-                # Large user messages (e.g. @file mentions with file contents)
-                # are truncated to keep a brief summary of the original request
                 truncated = msg["content"][:PRUNE_USER_MSG_KEEP] + \
                     f"\n\n[... {msg_len - PRUNE_USER_MSG_KEEP:,} chars pruned to save context ...]"
                 result[i] = {"role": "user", "content": truncated}
@@ -132,11 +190,36 @@ def prune_history(history: list[dict[str, str]]) -> list[dict[str, str]]:
 
 # ── 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
@@ -146,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:
@@ -156,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)
         )
 
@@ -175,27 +261,86 @@ 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"
     )
 
 
 # ── Layer 3: Compaction ───────────────────────────────────────────
 
-def should_compact(total_input_tokens: int, model_id: str = "default") -> bool:
-    """Check if the conversation should be compacted based on token usage."""
+def estimate_history_tokens(history: list[dict[str, str]]) -> int:
+    """Estimate token count from conversation history chars (~3.5 chars/token)."""
+    total_chars = sum(len(msg["content"]) for msg in history)
+    return int(total_chars / 3.5)
+
+
+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).
+
+    Accepts either an estimated token count (int) or the history list
+    (from which tokens are estimated via char count).
+    """
+    if isinstance(history_or_tokens, list):
+        tokens = estimate_history_tokens(history_or_tokens)
+    else:
+        tokens = history_or_tokens
     limit = MODEL_CONTEXT_LIMITS.get(model_id, MODEL_CONTEXT_LIMITS["default"])
     threshold = int(limit * COMPACTION_THRESHOLD_RATIO)
-    return total_input_tokens >= threshold
+    return tokens >= threshold
+
+
+def would_prune(history: list[dict[str, str]], model_id: str = "default") -> bool:
+    """Check if prune_history would discard content from this history.
+
+    Uses the exact same criteria as prune_history: total chars exceed
+    the protection window + minimum prunable threshold.
+    """
+    if len(history) <= 2:
+        return False
+    total_chars = sum(len(msg["content"]) for msg in history)
+    protect_chars = _get_prune_protect_chars(model_id)
+    return total_chars >= protect_chars + PRUNE_MINIMUM_CHARS
+
+
+def _split_history(history: list[dict[str, str]], model_id: str = "default") -> tuple[list[dict[str, str]], list[dict[str, str]]]:
+    """Split history into old (to summarize) and recent (to keep intact).
+
+    Uses the same protection window as pruning.
+    """
+    protect_chars = _get_prune_protect_chars(model_id)
+    protected = 0
+    split_idx = len(history)
+    for i in range(len(history) - 1, -1, -1):
+        msg_len = len(history[i]["content"])
+        if protected + msg_len <= protect_chars:
+            protected += msg_len
+            split_idx = i
+        else:
+            break
+    return history[:split_idx], history[split_idx:]
+
+
+def build_compaction_prompt(
+    history: list[dict[str, str]],
+    plan_task: str | None = None,
+    model_id: str = "default",
+) -> str:
+    """Build the prompt sent to the compaction agent.
 
+    Only includes OLD messages (outside the protection window) for
+    summarization. Recent messages are kept intact by apply_compaction.
+    """
+    old_msgs, _ = _split_history(history, model_id)
 
-def build_compaction_prompt(history: list[dict[str, str]], plan_task: str | None = None) -> str:
-    """Build the prompt sent to the compaction agent to summarize the conversation."""
     parts = [COMPACTION_TEMPLATE, "\n\n---\n\n## Conversation to summarize:\n"]
 
     if plan_task:
         parts.append(f"**Active task:** {plan_task}\n\n")
 
-    for msg in history:
+    for msg in old_msgs:
         role = msg["role"].upper()
         content = msg["content"]
         # Cap individual messages in the compaction input to avoid blowing up
@@ -206,26 +351,37 @@ def build_compaction_prompt(history: list[dict[str, str]], plan_task: str | None
     return "".join(parts)
 
 
-def apply_compaction(history: list[dict[str, str]], summary: str) -> list[dict[str, str]]:
-    """Replace history with a compaction summary + the most recent exchange."""
+
+def apply_compaction(
+    history: list[dict[str, str]], summary: str, model_id: str = "default"
+) -> list[dict[str, str]]:
+    """Replace OLD messages with a summary, keep RECENT messages intact.
+
+    Uses the same protection window as pruning: recent messages within
+    the window are preserved as-is, older messages are replaced by a
+    compaction summary. Replays the last user message to maintain continuity.
+    """
+    _, recent = _split_history(history, model_id)
+
     compacted = [
         {"role": "user", "content": f"[Conversation compacted]\n\n{summary}"}
     ]
-    # Keep the last user message and last assistant message for continuity
-    last_user = None
-    last_assistant = None
-    for msg in reversed(history):
-        if msg["role"] == "user" and last_user is None:
-            last_user = msg
-        elif msg["role"] == "assistant" and last_assistant is None:
-            last_assistant = msg
-        if last_user and last_assistant:
-            break
-
-    if last_assistant:
-        compacted.append(last_assistant)
-    if last_user and last_user != compacted[0]:
-        compacted.append(last_user)
+    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
 
@@ -234,6 +390,7 @@ async def compact_conversation(
     history: list[dict[str, str]],
     model_ref: str,
     plan_task: str | None = None,
+    model_id: str = "default",
 ) -> list[dict[str, str]]:
     """Run the compaction agent to summarize and replace history.
 
@@ -243,7 +400,7 @@ async def compact_conversation(
     from aru.runtime import get_ctx
     from aru.providers import create_model
 
-    prompt = build_compaction_prompt(history, plan_task)
+    prompt = build_compaction_prompt(history, plan_task, model_id=model_id)
 
     try:
         from agno.agent import Agent
@@ -263,12 +420,12 @@ async def compact_conversation(
             # Fallback: simple mechanical summary
             summary = _fallback_summary(history, plan_task)
 
-        return apply_compaction(history, summary)
+        return apply_compaction(history, summary, model_id=model_id)
 
     except Exception:
         # Fallback if agent fails
         summary = _fallback_summary(history, plan_task)
-        return apply_compaction(history, summary)
+        return apply_compaction(history, summary, model_id=model_id)
 
 
 def _fallback_summary(history: list[dict[str, str]], plan_task: str | None = None) -> str:

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

@@ -115,11 +115,25 @@ async def run_agent_capture(agent, message: str, session=None, lightweight: bool
             run_message = message
 
         # Build conversation history as real messages for the LLM
-        from aru.context import prune_history
+        # Compact BEFORE pruning: if the history is large enough that pruning
+        # would discard content, compact first to preserve context via summary
+        # instead of losing it to placeholders.
+        from aru.context import prune_history, should_compact, compact_conversation, would_prune
+        if session and session.history and not lightweight:
+            if would_prune(session.history, model_id=session.model_id):
+                try:
+                    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:
+                    pass
+
         history_messages: list[Message] = []
         if session and session.history and not lightweight:
             prior_history = session.history[:-1]
-            pruned = prune_history(prior_history)
+            pruned = prune_history(prior_history, model_id=session.model_id)
             for msg in pruned:
                 history_messages.append(Message(role=msg["role"], content=msg["content"], from_history=True))
 
@@ -228,11 +242,16 @@ async def run_agent_capture(agent, message: str, session=None, lightweight: bool
         if run_output and session and hasattr(run_output, "metrics"):
             session.track_tokens(run_output.metrics)
 
-            from aru.context import should_compact, compact_conversation
-            if should_compact(session.total_input_tokens, session.model_id):
+            # Reactive compaction: use per-run input_tokens (sum of all API
+            # calls within this arun) as a conservative proxy for context pressure.
+            # session.history doesn't include tool results, so char-based estimates
+            # would miss the bulk of the context sent to the model.
+            run_input_tokens = getattr(run_output.metrics, "input_tokens", 0) or 0
+            if should_compact(run_input_tokens, session.model_id):
                 try:
                     session.history = await compact_conversation(
-                        session.history, session.model_ref, session.plan_task
+                        session.history, session.model_ref, session.plan_task,
+                        model_id=session.model_id,
                     )
                     console.print("[dim]Context compacted to save tokens.[/dim]")
                 except Exception:

{aru_code-0.13.2 → 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.2 → 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.2
+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.2 → aru_code-0.14.0}/pyproject.toml

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

{aru_code-0.13.2 → 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.2/aru/__init__.py

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