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

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

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

aru_code-0.23.0/aru/__init__.py

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

aru_code-0.23.0/aru/agent_factory.py

@@ -0,0 +1,131 @@
+"""Agent creation: general-purpose and custom agent instantiation."""
+
+from __future__ import annotations
+
+import functools
+import inspect
+import logging
+
+from aru.agents.base import build_instructions as _build_instructions
+from aru.config import AgentConfig, CustomAgent
+from aru.providers import create_model
+from aru.session import Session
+
+logger = logging.getLogger("aru.agent_factory")
+
+
+def _wrap_tools_with_hooks(tools: list) -> list:
+    """Wrap tool functions to fire tool.execute.before/after plugin hooks.
+
+    Before hook can mutate args; after hook can mutate the result.
+    If a before hook raises, the tool is not executed and the error is returned.
+    """
+    from aru.runtime import get_ctx
+
+    async def _fire(event_name: str, data: dict) -> dict:
+        try:
+            ctx = get_ctx()
+            mgr = ctx.plugin_manager
+            if mgr is not None and mgr.loaded:
+                event = await mgr.fire(event_name, data)
+                return event.data
+        except (LookupError, AttributeError):
+            pass
+        return data
+
+    def _wrap_one(fn):
+        if not callable(fn) or getattr(fn, "_hook_wrapped", False):
+            return fn
+
+        @functools.wraps(fn)
+        async def wrapper(**kwargs):
+            tool_name = fn.__name__
+            # Before hook — plugins can mutate args or raise PermissionError to block
+            try:
+                before_data = await _fire("tool.execute.before", {
+                    "tool_name": tool_name,
+                    "args": kwargs,
+                })
+                kwargs = before_data.get("args", kwargs)
+            except PermissionError as e:
+                return f"BLOCKED by plugin: {e}. Do NOT retry this operation."
+
+            # Execute the tool
+            if inspect.iscoroutinefunction(fn):
+                result = await fn(**kwargs)
+            else:
+                result = fn(**kwargs)
+
+            # After hook — plugins can mutate the result
+            after_data = await _fire("tool.execute.after", {
+                "tool_name": tool_name,
+                "args": kwargs,
+                "result": result,
+            })
+            return after_data.get("result", result)
+
+        wrapper._hook_wrapped = True
+        return wrapper
+
+    return [_wrap_one(t) for t in tools]
+
+
+def create_general_agent(
+    session: Session,
+    config: AgentConfig | None = None,
+    model_override: str | None = None,
+    env_context: str = "",
+):
+    """Create the general-purpose agent.
+
+    Args:
+        env_context: Environment context (cwd, tree, git status) to include
+            in the system prompt. Placed in instructions so it's cacheable.
+    """
+    from agno.agent import Agent
+
+    from aru.tools.codebase import GENERAL_TOOLS
+    tools = _wrap_tools_with_hooks(GENERAL_TOOLS)
+
+    extra = config.get_extra_instructions() if config else ""
+    if env_context:
+        extra = f"{extra}\n\n{env_context}" if extra else env_context
+    model_ref = model_override or session.model_ref
+
+    return Agent(
+        name="Aru",
+        model=create_model(model_ref, max_tokens=8192),
+        tools=tools,
+        instructions=_build_instructions("general", extra),
+        markdown=True,
+        tool_call_limit=20,
+    )
+
+
+def create_custom_agent_instance(agent_def: CustomAgent, session: Session,
+                                  config: AgentConfig | None = None,
+                                  env_context: str = ""):
+    """Create an Agno Agent from a CustomAgent definition."""
+    from agno.agent import Agent
+    from aru.agents.base import BASE_INSTRUCTIONS
+    from aru.tools.codebase import resolve_tools
+
+    model_ref = agent_def.model or session.model_ref
+    tools = _wrap_tools_with_hooks(resolve_tools(agent_def.tools))
+
+    extra = config.get_extra_instructions() if config else ""
+    if env_context:
+        extra = f"{extra}\n\n{env_context}" if extra else env_context
+    parts = [agent_def.system_prompt, BASE_INSTRUCTIONS]
+    if extra:
+        parts.append(extra)
+    instructions = "\n\n".join(parts)
+
+    return Agent(
+        name=agent_def.name,
+        model=create_model(model_ref, max_tokens=8192),
+        tools=tools,
+        instructions=instructions,
+        markdown=True,
+        tool_call_limit=agent_def.max_turns or 20,
+    )

{aru_code-0.22.0 → aru_code-0.23.0}/aru/checkpoints.py

@@ -1,189 +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
+"""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.22.0 → aru_code-0.23.0}/aru/context.py

@@ -48,21 +48,9 @@ TRUNCATE_MAX_LINE_LENGTH = 1500  # chars per individual line (prevents minified
 TRUNCATE_SAVE_DIR = ".aru/truncated"
 
 # Compaction: chars of recent conversation preserved verbatim post-compact.
-#
-# Separate from the prune protect window (160K) because they measure
-# different things:
-#   - Prune protect: "how much tool_result content stays intact"
-#   - Compact recent: "how much full-message history stays verbatim after
-#     the summary replaces the older portion"
-#
-# Set to 80K chars (~20K tokens) — half the prune window. Rationale:
-# with the compactor now running on the main model (not a small one),
-# summaries are faithful enough that we don't need 40K of recent overlap
-# as a safety net. 20K still covers 3-6 recent turns verbatim, which
-# mirrors the "last few exchanges" a human would re-read to resume work.
-# Going to zero would match opencode exactly but requires the reactive
-# overflow replay flow we haven't implemented yet.
-COMPACT_RECENT_CHARS = 80_000
+# Uses the same budget as prune protect (160K chars ≈ 40K tokens) to match
+# opencode's approach where the split point mirrors the prune window.
+COMPACT_RECENT_CHARS = 160_000
 
 # Compaction: trigger when per-call input tokens approach real overflow.
 # Matches opencode's philosophy: only fire near the model's actual context

{aru_code-0.22.0 → aru_code-0.23.0}/aru/plugins/__init__.py

@@ -8,5 +8,6 @@ Public API for plugin authors:
 
 from aru.plugins.tool_api import tool
 from aru.plugins.hooks import Hooks, HookEvent, PluginInput
+from aru.plugins.manager import PluginManager
 
-__all__ = ["tool", "Hooks", "HookEvent", "PluginInput"]
+__all__ = ["tool", "Hooks", "HookEvent", "PluginInput", "PluginManager"]

{aru_code-0.22.0 → aru_code-0.23.0}/aru/plugins/manager.py

@@ -145,6 +145,8 @@ class PluginManager:
                         await handler(event)
                     else:
                         handler(event)
+                except PermissionError:
+                    raise  # let blocking signals propagate
                 except Exception as e:
                     logger.error("Hook handler error (%s): %s", event_name, e)
 

{aru_code-0.22.0 → aru_code-0.23.0}/aru/tools/codebase.py

@@ -72,15 +72,15 @@ def clear_read_cache():
     get_ctx().read_cache.clear()
 
 
-def read_file(file_path: str, start_line: int = 0, end_line: int = 0, max_size: int = 8_000) -> str:
+def read_file(file_path: str, start_line: int = 0, end_line: int = 0, max_size: int = 12_000) -> str:
     """Read file contents. Returns chunked output for large files.
 
     Args:
         file_path: Path to the file (absolute or relative).
         start_line: First line (1-indexed, inclusive). 0 = beginning.
         end_line: Last line (1-indexed, inclusive). 0 = end.
-        max_size: Max bytes before truncation. Default 8KB.
-            Set to 0 to read the full file in chunks — each chunk up to ~25KB.
+        max_size: Max bytes before truncation. Default 12KB.
+            Set to 0 to read the full file in chunks — each chunk up to ~40KB.
             The first chunk includes a continuation hint so you can call again
             with start_line to get the next chunk.
     """
@@ -519,15 +519,15 @@ def glob_search(pattern: str, directory: str = ".") -> str:
     return "\n".join(matches)
 
 
-def grep_search(pattern: str, directory: str = ".", file_glob: str = "", context_lines: int = 5) -> str:
+def grep_search(pattern: str, directory: str = ".", file_glob: str = "", context_lines: int = 10) -> str:
     """Search for a regex pattern in file contents.
 
     Args:
         pattern: Regular expression pattern to search for.
         directory: Directory to search in. Defaults to current directory.
         file_glob: Optional glob to filter which files to search (e.g. '*.py').
-        context_lines: Lines of context before and after each match (like grep -C). Default 5.
-            Use 0 for file-level matches only. Use 20+ for full function bodies.
+        context_lines: Lines of context before and after each match (like grep -C). Default 10.
+            Use 0 for file-level matches only. Use 30+ for full function bodies.
     """
     import re
 
@@ -918,9 +918,13 @@ async def bash(command: str, timeout: int = 60, working_directory: str = "") ->
     if not check_permission("bash", command, cmd_display):
         return f"PERMISSION DENIED by user: {command}. Do NOT retry this operation. Stop and ask the user for new instructions."
 
-    # Fire shell.env hook — plugins can inject environment variables
-    extra_env = await _fire_plugin_hook("shell.env", {"cwd": cwd, "command": command, "env": {}})
-    shell_env = extra_env.get("env") if isinstance(extra_env, dict) else None
+    # Fire shell.env hook — plugins can inject env vars or rewrite/block the command
+    hook_data = await _fire_plugin_hook("shell.env", {"cwd": cwd, "command": command, "env": {}})
+    if isinstance(hook_data, dict):
+        command = hook_data.get("command", command)
+        shell_env = hook_data.get("env") or None
+    else:
+        shell_env = None
 
     result = await run_command(command, timeout=timeout, working_directory=working_directory, extra_env=shell_env)
     # Bash can modify files, so always invalidate cache

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

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

{aru_code-0.22.0 → aru_code-0.23.0}/aru_code.egg-info/SOURCES.txt

@@ -55,6 +55,7 @@ tests/test_config.py
 tests/test_context.py
 tests/test_executor.py
 tests/test_gitignore.py
+tests/test_guardrails_scenarios.py
 tests/test_main.py
 tests/test_mcp_client.py
 tests/test_permissions.py

{aru_code-0.22.0 → aru_code-0.23.0}/pyproject.toml

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