aru-code 0.20.0__tar.gz → 0.22.0__tar.gz

{aru_code-0.20.0/aru_code.egg-info → aru_code-0.22.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aru-code
-Version: 0.20.0
+Version: 0.22.0
 Summary: A Claude Code clone built with Agno agents
 Author-email: Estevao <estevaofon@gmail.com>
 License-Expression: MIT
@@ -312,8 +312,47 @@ Without any `aru.json` config, aru applies safe defaults:
 - Bash → ~40 safe command prefixes auto-allowed (`ls`, `git status`, `grep`, etc.), rest → `ask`
 - Sensitive files (`*.env`, `*.env.*`) → `deny` for read/edit/write (except `*.env.example`)
 
-> `aru.json` can also be placed at `.aru/config.json`.
->
+#### Config file locations
+
+Aru loads configuration from two levels, with project settings overriding global ones:
+
+| Level | Path | Purpose |
+|-------|------|---------|
+| **Global (user)** | `~/.aru/config.json` | Defaults that apply to all projects (model, aliases, permissions, providers) |
+| **Project** | `aru.json` or `.aru/config.json` | Project-specific overrides |
+
+Global config is loaded first, then the project config is **deep-merged** on top — scalar values and lists are replaced, nested objects (like `permission`, `providers`, `model_aliases`) are merged recursively. This means you can set your preferred model and aliases globally and only override what's different per project.
+
+**Example `~/.aru/config.json`:**
+
+```json
+{
+  "default_model": "anthropic/claude-sonnet-4-6",
+  "model_aliases": {
+    "sonnet": "anthropic/claude-sonnet-4-6",
+    "opus": "anthropic/claude-opus-4-6"
+  },
+  "permission": {
+    "read": "allow",
+    "glob": "allow",
+    "grep": "allow"
+  }
+}
+```
+
+Then a project `aru.json` only needs project-specific settings:
+
+```json
+{
+  "default_model": "ollama/codellama",
+  "permission": {
+    "bash": { "pytest *": "allow" }
+  }
+}
+```
+
+The result: `default_model` becomes `ollama/codellama`, `model_aliases` come from global, and `permission` merges both levels (`read`, `glob`, `grep` from global + `bash` from project).
+
 > A full `aru.json` config reference here: [`aru.json`](./aru.json)
 
 ### AGENTS.md

{aru_code-0.20.0 → aru_code-0.22.0}/README.md

@@ -265,8 +265,47 @@ Without any `aru.json` config, aru applies safe defaults:
 - Bash → ~40 safe command prefixes auto-allowed (`ls`, `git status`, `grep`, etc.), rest → `ask`
 - Sensitive files (`*.env`, `*.env.*`) → `deny` for read/edit/write (except `*.env.example`)
 
-> `aru.json` can also be placed at `.aru/config.json`.
->
+#### Config file locations
+
+Aru loads configuration from two levels, with project settings overriding global ones:
+
+| Level | Path | Purpose |
+|-------|------|---------|
+| **Global (user)** | `~/.aru/config.json` | Defaults that apply to all projects (model, aliases, permissions, providers) |
+| **Project** | `aru.json` or `.aru/config.json` | Project-specific overrides |
+
+Global config is loaded first, then the project config is **deep-merged** on top — scalar values and lists are replaced, nested objects (like `permission`, `providers`, `model_aliases`) are merged recursively. This means you can set your preferred model and aliases globally and only override what's different per project.
+
+**Example `~/.aru/config.json`:**
+
+```json
+{
+  "default_model": "anthropic/claude-sonnet-4-6",
+  "model_aliases": {
+    "sonnet": "anthropic/claude-sonnet-4-6",
+    "opus": "anthropic/claude-opus-4-6"
+  },
+  "permission": {
+    "read": "allow",
+    "glob": "allow",
+    "grep": "allow"
+  }
+}
+```
+
+Then a project `aru.json` only needs project-specific settings:
+
+```json
+{
+  "default_model": "ollama/codellama",
+  "permission": {
+    "bash": { "pytest *": "allow" }
+  }
+}
+```
+
+The result: `default_model` becomes `ollama/codellama`, `model_aliases` come from global, and `permission` merges both levels (`read`, `glob`, `grep` from global + `bash` from project).
+
 > A full `aru.json` config reference here: [`aru.json`](./aru.json)
 
 ### AGENTS.md

aru_code-0.22.0/aru/__init__.py

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

aru_code-0.22.0/aru/checkpoints.py

@@ -0,0 +1,189 @@
+"""File checkpoint system for undo/rewind support.
+
+Tracks file state before tool mutations so changes can be reverted.
+Inspired by Claude Code's fileHistory system.
+
+Architecture:
+- Each user message creates a "snapshot" identified by a turn index.
+- Before any file mutation (write_file, edit_file, bash), the pre-edit
+  content is saved as a versioned backup in .aru/file-history/{session_id}/.
+- On /undo, the most recent snapshot is applied: files are restored to
+  their pre-turn state and the conversation is rewound.
+
+Backup naming: {sha256(path)[:16]}@v{version}
+Snapshot: {turn_index: {file_path: BackupEntry}}
+"""
+
+from __future__ import annotations
+
+import hashlib
+import os
+import shutil
+import threading
+from dataclasses import dataclass, field
+
+
+@dataclass
+class BackupEntry:
+    """A single file backup."""
+    backup_path: str | None  # None = file didn't exist before this turn
+    version: int
+    original_path: str
+
+
+@dataclass
+class Snapshot:
+    """Checkpoint at a specific conversation turn."""
+    turn_index: int
+    backups: dict[str, BackupEntry] = field(default_factory=dict)  # abs_path → BackupEntry
+
+
+MAX_SNAPSHOTS = 100
+
+
+class CheckpointManager:
+    """Manages file checkpoints for a session.
+
+    Thread-safe: multiple tools may run in parallel within a turn.
+    """
+
+    def __init__(self, session_id: str, base_dir: str | None = None):
+        self._session_id = session_id
+        self._base_dir = base_dir or os.path.join(os.getcwd(), ".aru", "file-history", session_id)
+        self._lock = threading.Lock()
+        self._snapshots: list[Snapshot] = []
+        self._current_turn: int = 0
+        self._tracked_files: set[str] = set()
+        # Per-file version counter (monotonic)
+        self._file_versions: dict[str, int] = {}
+        self._dir_created = False
+
+    def _ensure_dir(self):
+        if not self._dir_created:
+            os.makedirs(self._base_dir, exist_ok=True)
+            self._dir_created = True
+
+    def _backup_filename(self, file_path: str, version: int) -> str:
+        path_hash = hashlib.sha256(file_path.encode("utf-8")).hexdigest()[:16]
+        return f"{path_hash}@v{version}"
+
+    def begin_turn(self, turn_index: int):
+        """Start a new turn — creates a fresh snapshot for this turn."""
+        with self._lock:
+            self._current_turn = turn_index
+            # Create snapshot for this turn (backups added lazily as files are edited)
+            snapshot = Snapshot(turn_index=turn_index)
+            self._snapshots.append(snapshot)
+            # Enforce cap
+            if len(self._snapshots) > MAX_SNAPSHOTS:
+                evicted = self._snapshots.pop(0)
+                self._cleanup_snapshot_backups(evicted)
+
+    def track_edit(self, file_path: str):
+        """Capture pre-edit state of a file before mutation.
+
+        Call this BEFORE writing/editing a file. If the file was already
+        captured in the current turn's snapshot, this is a no-op.
+        """
+        abs_path = os.path.abspath(file_path)
+
+        with self._lock:
+            if not self._snapshots:
+                return
+
+            current_snapshot = self._snapshots[-1]
+
+            # Already tracked in this turn
+            if abs_path in current_snapshot.backups:
+                return
+
+            # Increment version
+            version = self._file_versions.get(abs_path, 0) + 1
+            self._file_versions[abs_path] = version
+            self._tracked_files.add(abs_path)
+
+        # Read file outside lock (IO)
+        backup_path = None
+        if os.path.isfile(abs_path):
+            self._ensure_dir()
+            backup_name = self._backup_filename(abs_path, version)
+            backup_path = os.path.join(self._base_dir, backup_name)
+            try:
+                shutil.copy2(abs_path, backup_path)
+            except OSError:
+                backup_path = None
+
+        # Commit to snapshot
+        with self._lock:
+            if not self._snapshots:
+                return
+            entry = BackupEntry(
+                backup_path=backup_path,
+                version=version,
+                original_path=abs_path,
+            )
+            self._snapshots[-1].backups[abs_path] = entry
+
+    def undo_last_turn(self) -> tuple[list[str], int]:
+        """Revert files changed in the most recent snapshot.
+
+        Returns:
+            (list of restored file paths, turn_index that was undone)
+        """
+        with self._lock:
+            if not self._snapshots:
+                return [], 0
+            snapshot = self._snapshots.pop()
+
+        restored = []
+        for abs_path, entry in snapshot.backups.items():
+            try:
+                if entry.backup_path is None:
+                    # File didn't exist before — delete it
+                    if os.path.isfile(abs_path):
+                        os.unlink(abs_path)
+                        restored.append(abs_path)
+                elif os.path.isfile(entry.backup_path):
+                    # Restore from backup
+                    shutil.copy2(entry.backup_path, abs_path)
+                    restored.append(abs_path)
+            except OSError:
+                pass  # best effort
+
+        return restored, snapshot.turn_index
+
+    def get_snapshot_count(self) -> int:
+        with self._lock:
+            return len(self._snapshots)
+
+    def get_last_snapshot_files(self) -> list[str]:
+        """Return files that would be affected by undo."""
+        with self._lock:
+            if not self._snapshots:
+                return []
+            return list(self._snapshots[-1].backups.keys())
+
+    def _cleanup_snapshot_backups(self, snapshot: Snapshot):
+        """Remove backup files for an evicted snapshot (if not referenced by others)."""
+        # Collect all backup paths still referenced
+        referenced = set()
+        for s in self._snapshots:
+            for entry in s.backups.values():
+                if entry.backup_path:
+                    referenced.add(entry.backup_path)
+
+        # Delete unreferenced backups
+        for entry in snapshot.backups.values():
+            if entry.backup_path and entry.backup_path not in referenced:
+                try:
+                    os.unlink(entry.backup_path)
+                except OSError:
+                    pass
+
+    def cleanup(self):
+        """Remove all backup files for this session."""
+        try:
+            if os.path.isdir(self._base_dir):
+                shutil.rmtree(self._base_dir, ignore_errors=True)
+        except OSError:
+            pass

{aru_code-0.20.0 → aru_code-0.22.0}/aru/cli.py

@@ -203,6 +203,11 @@ async def run_cli(skip_permissions: bool = False, resume_id: str | None = None):
     ctx.on_file_mutation = session.invalidate_context_cache
     atexit.register(lambda: cleanup_processes(ctx.tracked_processes))
 
+    # Initialize checkpoint manager for undo/rewind support
+    from aru.checkpoints import CheckpointManager
+    ctx.checkpoint_manager = CheckpointManager(session.session_id)
+    _turn_counter = 0
+
     planner = None
     executor = None
     paste_state = PasteState()
@@ -329,6 +334,64 @@ async def run_cli(skip_permissions: bool = False, resume_id: str | None = None):
         # Reset "allow all" approvals for each new user message
         perm_reset_session()
 
+        if user_input.lower() == "/undo":
+            affected_files = ctx.checkpoint_manager.get_last_snapshot_files()
+            if not affected_files and not session.history:
+                console.print("[dim]Nothing to undo.[/dim]")
+                continue
+
+            # Show what will be reverted
+            if affected_files:
+                cwd = os.getcwd()
+                console.print("[bold]Files that will be restored:[/bold]")
+                for f in affected_files:
+                    rel = os.path.relpath(f, cwd) if f.startswith(cwd) else f
+                    console.print(f"  [cyan]{rel}[/cyan]")
+
+            console.print()
+            console.print("[bold]Restore options:[/bold]")
+            console.print("  [cyan](b)[/cyan] Restore code and conversation (both)")
+            console.print("  [cyan](c)[/cyan] Restore only code (keep conversation)")
+            console.print("  [cyan](v)[/cyan] Restore only conversation (keep code)")
+            console.print("  [cyan](n)[/cyan] Cancel")
+            try:
+                choice = console.input("[bold yellow]Choice (b/c/v/n):[/bold yellow] ").strip().lower()
+            except (EOFError, KeyboardInterrupt):
+                choice = "n"
+
+            if choice in ("n", ""):
+                console.print("[dim]Cancelled.[/dim]")
+                continue
+
+            restored_files = []
+            msgs_removed = 0
+
+            if choice in ("b", "c"):
+                # Restore files from checkpoint
+                restored_files, _ = ctx.checkpoint_manager.undo_last_turn()
+
+            if choice in ("b", "v"):
+                # Remove last turn from conversation
+                msgs_removed = session.undo_last_turn()
+
+            parts = []
+            if restored_files:
+                cwd = os.getcwd()
+                for f in restored_files:
+                    rel = os.path.relpath(f, cwd) if f.startswith(cwd) else f
+                    parts.append(f"  [cyan]{rel}[/cyan]")
+                console.print(f"[green]Restored {len(restored_files)} file(s):[/green]")
+                for p in parts:
+                    console.print(p)
+                session.invalidate_context_cache()
+            if msgs_removed:
+                console.print(f"[green]Removed {msgs_removed} message(s) from conversation.[/green]")
+            if not restored_files and not msgs_removed:
+                console.print("[dim]Nothing was changed.[/dim]")
+            else:
+                store.save(session)
+            continue
+
         if user_input.lower() in ("/quit", "/exit", "quit", "exit"):
             store.save(session)
             console.print(f"\n[dim]Session saved: {session.session_id}[/dim]")
@@ -455,6 +518,10 @@ async def run_cli(skip_permissions: bool = False, resume_id: str | None = None):
             ))
             continue
 
+        # Begin a new checkpoint turn for undo support
+        _turn_counter += 1
+        ctx.checkpoint_manager.begin_turn(_turn_counter)
+
         if user_input.startswith("! "):
             cmd = user_input[2:].strip()
             if not cmd:
@@ -609,6 +676,72 @@ def _list_sessions_and_exit():
     console.print(f"\n[dim]Resume with: aru --resume <id>[/dim]")
 
 
+async def run_oneshot(prompt: str, print_only: bool = False, skip_permissions: bool = False):
+    """Run a single prompt non-interactively and exit.
+
+    Args:
+        prompt: The user prompt to execute.
+        print_only: If True, run without tools (text-only response).
+        skip_permissions: If True, skip all permission checks.
+    """
+    from aru.runtime import init_ctx
+    from aru.config import load_config
+    from aru.cache_patch import apply_cache_patch
+
+    apply_cache_patch()
+    ctx = init_ctx(console=console, skip_permissions=skip_permissions)
+
+    config = load_config()
+    session = Session()
+    if config.default_model:
+        session.model_ref = config.default_model
+
+    ctx.model_id = session.model_id
+    small_ref = config.model_aliases.get("small") if config else None
+    if not small_ref:
+        from aru.providers import resolve_model_ref
+        provider_key, _ = resolve_model_ref(session.model_ref)
+        _small_defaults = {
+            "anthropic": "anthropic/claude-haiku-4-5",
+            "openai": "openai/gpt-4o-mini",
+            "groq": "groq/llama-3.1-8b-instant",
+            "deepseek": "deepseek/deepseek-chat",
+            "ollama": "ollama/llama3.1",
+        }
+        small_ref = _small_defaults.get(provider_key, session.model_ref)
+    ctx.small_model_ref = small_ref
+
+    extra_instructions = config.get_extra_instructions()
+
+    if print_only:
+        # Text-only mode: no tools, just a direct LLM call
+        from agno.agent import Agent
+        from aru.providers import create_model
+        from aru.agents.base import build_instructions
+
+        agent = Agent(
+            name="Aru",
+            model=create_model(session.model_ref, max_tokens=8192),
+            tools=[],
+            instructions=build_instructions("general", extra_instructions),
+            markdown=True,
+        )
+        response = await agent.arun(prompt)
+        if response and response.content:
+            # Print raw text to stdout for piping
+            print(response.content)
+    else:
+        # Full mode with tools
+        from aru.runner import build_env_context
+        env_ctx = build_env_context(session)
+        agent = create_general_agent(session, config, env_context=env_ctx)
+        session.add_message("user", prompt)
+        await run_agent_capture(agent, prompt, session)
+
+        if session.token_summary:
+            console.print(f"[dim]{session.token_summary}[/dim]")
+
+
 def main():
     """Entry point for the aru CLI."""
     from dotenv import load_dotenv
@@ -616,6 +749,7 @@ def main():
     load_dotenv()
     args = sys.argv[1:]
     skip_permissions = "--dangerously-skip-permissions" in args
+    print_only = "--print" in args or "-p" in args
 
     if "--list" in args:
         _list_sessions_and_exit()
@@ -629,6 +763,39 @@ def main():
         else:
             resume_id = "last"
 
+    # Collect positional arguments (non-flag, non-flag-value)
+    flags_with_value = {"--resume"}
+    positional = []
+    skip_next = False
+    for i, arg in enumerate(args):
+        if skip_next:
+            skip_next = False
+            continue
+        if arg.startswith("--") or arg.startswith("-"):
+            if arg in flags_with_value:
+                skip_next = True
+            continue
+        positional.append(arg)
+
+    # Piped stdin: echo "fix bug" | aru
+    if not sys.stdin.isatty() and not positional:
+        piped_input = sys.stdin.read().strip()
+        if piped_input:
+            positional = [piped_input]
+
+    # One-shot mode: aru "fix the bug" or aru --print "explain this"
+    if positional:
+        prompt = " ".join(positional)
+        try:
+            asyncio.run(run_oneshot(prompt, print_only=print_only, skip_permissions=skip_permissions))
+        except (KeyboardInterrupt, asyncio.CancelledError, SystemExit):
+            pass
+        except Exception as e:
+            from rich.markup import escape
+            console.print(f"\n[bold red]Fatal error: {escape(str(e))}[/bold red]")
+        return
+
+    # Interactive REPL mode
     try:
         asyncio.run(run_cli(skip_permissions=skip_permissions, resume_id=resume_id))
     except (KeyboardInterrupt, asyncio.CancelledError, SystemExit):

{aru_code-0.20.0 → aru_code-0.22.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"),
+    ("/undo", "Undo last turn — restore files and/or conversation", "/undo"),
     ("/cost", "Show detailed token usage and cost", "/cost"),
     ("/quit", "Exit aru", "/quit"),
 ]
@@ -83,6 +84,7 @@ def _show_help(config) -> None:
     table.add_row("/skills", "List available skills")
     table.add_row("/agents", "List custom agents")
     table.add_row("/mcp", "List loaded MCP tools")
+    table.add_row("/undo", "Undo last turn (restore files and/or conversation)")
     table.add_row("/help", "Show this help")
     table.add_row("/quit", "Exit aru")
     table.add_row("! <cmd>", "Run shell command")

{aru_code-0.20.0 → aru_code-0.22.0}/aru/config.py

@@ -436,6 +436,63 @@ def _discover_agents(search_roots: list[Path]) -> dict[str, CustomAgent]:
     return agents
 
 
+def _load_json_file(path: Path) -> dict | None:
+    """Read and parse a JSON file, returning None on any error."""
+    if not path.is_file():
+        return None
+    try:
+        content = path.read_text(encoding="utf-8")
+        data = json.loads(content)
+        return data if isinstance(data, dict) else None
+    except (OSError, UnicodeDecodeError, json.JSONDecodeError):
+        return None
+
+
+def _deep_merge(base: dict, override: dict) -> dict:
+    """Recursively merge override into base. Override values win for scalars;
+    dicts are merged recursively; lists are replaced (not concatenated)."""
+    result = base.copy()
+    for key, value in override.items():
+        if key in result and isinstance(result[key], dict) and isinstance(value, dict):
+            result[key] = _deep_merge(result[key], value)
+        else:
+            result[key] = value
+    return result
+
+
+def _apply_config_data(config: AgentConfig, data: dict, root: Path) -> None:
+    """Apply a merged config dict to an AgentConfig object."""
+    if "permission" in data:
+        config.permissions = data["permission"]
+    if "providers" in data:
+        from aru.providers import load_providers_from_config
+        load_providers_from_config(data)
+    if "default_model" in data:
+        config.default_model = data["default_model"]
+    if "model_aliases" in data and isinstance(data["model_aliases"], dict):
+        config.model_aliases = data["model_aliases"]
+    if "plan_reviewer" in data:
+        config.plan_reviewer = bool(data["plan_reviewer"])
+    if "tree_depth" in data:
+        td = data["tree_depth"]
+        if isinstance(td, int) and 0 <= td <= 5:
+            config.tree_depth = td
+    if "plugins" in data and isinstance(data["plugins"], list):
+        config.plugin_specs = data["plugins"]
+    if "tools" in data and isinstance(data["tools"], dict):
+        tools_cfg = data["tools"]
+        if "disabled" in tools_cfg and isinstance(tools_cfg["disabled"], list):
+            config.disabled_tools = [str(t) for t in tools_cfg["disabled"]]
+    if "instructions" in data and isinstance(data["instructions"], list):
+        entries = [str(e) for e in data["instructions"] if isinstance(e, str)]
+        config.rules_instructions = _resolve_instructions(entries, root)
+    if "agent" in data and isinstance(data["agent"], dict):
+        for agent_name, agent_data in data["agent"].items():
+            if agent_name in config.custom_agents and isinstance(agent_data, dict):
+                if "permission" in agent_data:
+                    config.custom_agents[agent_name].permission = agent_data["permission"]
+
+
 def load_config(cwd: str | None = None) -> AgentConfig:
     """Load agent configuration from AGENTS.md and .agents/ directory.
 
@@ -492,52 +549,27 @@ def load_config(cwd: str | None = None) -> AgentConfig:
     config.skills = _discover_skills(skill_roots)
     config.custom_agents = _discover_agents(skill_roots)
 
-    # Load opencode-style config (aru.json or .aru/config.json)
-    config_paths = [root / "aru.json", root / ".aru" / "config.json"]
-    for config_path in config_paths:
-        if config_path.is_file():
-            try:
-                content = config_path.read_text(encoding="utf-8")
-                data = json.loads(content)
-                if isinstance(data, dict):
-                    if "permission" in data:
-                        config.permissions = data["permission"]
-                    # Load provider configuration
-                    if "providers" in data:
-                        from aru.providers import load_providers_from_config
-                        load_providers_from_config(data)
-                    # Store default model and aliases for CLI
-                    if "default_model" in data:
-                        config.default_model = data["default_model"]
-                    if "model_aliases" in data and isinstance(data["model_aliases"], dict):
-                        config.model_aliases = data["model_aliases"]
-                    if "plan_reviewer" in data:
-                        config.plan_reviewer = bool(data["plan_reviewer"])
-                    if "tree_depth" in data:
-                        td = data["tree_depth"]
-                        if isinstance(td, int) and 0 <= td <= 5:
-                            config.tree_depth = td
-                    # Plugin specs
-                    if "plugins" in data and isinstance(data["plugins"], list):
-                        config.plugin_specs = data["plugins"]
-                    # Custom tools config
-                    if "tools" in data and isinstance(data["tools"], dict):
-                        tools_cfg = data["tools"]
-                        if "disabled" in tools_cfg and isinstance(tools_cfg["disabled"], list):
-                            config.disabled_tools = [str(t) for t in tools_cfg["disabled"]]
-                    # Resolve instructions (local files, globs, URLs)
-                    if "instructions" in data and isinstance(data["instructions"], list):
-                        entries = [str(e) for e in data["instructions"] if isinstance(e, str)]
-                        config.rules_instructions = _resolve_instructions(entries, root)
-                    # Agent-level permission overrides from aru.json
-                    if "agent" in data and isinstance(data["agent"], dict):
-                        for agent_name, agent_data in data["agent"].items():
-                            if agent_name in config.custom_agents and isinstance(agent_data, dict):
-                                if "permission" in agent_data:
-                                    config.custom_agents[agent_name].permission = agent_data["permission"]
-                break
-            except (OSError, UnicodeDecodeError, json.JSONDecodeError):
-                pass
+    # Load config: global (~/.aru/config.json) first, then project-level on top.
+    # Project values override global values via deep merge.
+    home = Path.home()
+    global_config_paths = [home / ".aru" / "config.json"]
+    project_config_paths = [root / "aru.json", root / ".aru" / "config.json"]
+
+    merged_data: dict = {}
+    for config_path in global_config_paths:
+        data = _load_json_file(config_path)
+        if data is not None:
+            merged_data = data
+            break
+
+    for config_path in project_config_paths:
+        data = _load_json_file(config_path)
+        if data is not None:
+            merged_data = _deep_merge(merged_data, data)
+            break
+
+    if merged_data:
+        _apply_config_data(config, merged_data, root)
 
     return config
 

{aru_code-0.20.0 → aru_code-0.22.0}/aru/runner.py

@@ -195,6 +195,7 @@ async def run_agent_capture(agent, message: str, session=None, lightweight: bool
                     )
                     pending_tool_uses[tool_id] = assistant_blocks[-1]
                     if accumulated[display._flushed_len:]:
+                        display.content = None
                         live.stop()
                         display.flush()
                         live.start()
@@ -280,6 +281,10 @@ async def run_agent_capture(agent, message: str, session=None, lightweight: bool
                         )
                         break
 
+            # Clear live content before the Live context exits so its final
+            # render doesn't duplicate text that we print explicitly below.
+            display.content = None
+
         ctx.live = None
         ctx.display = None