aru-code 0.7.0__tar.gz → 0.8.0__tar.gz

{aru_code-0.7.0/aru_code.egg-info → aru_code-0.8.0}/PKG-INFO

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

aru_code-0.8.0/aru/__init__.py

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

{aru_code-0.7.0 → aru_code-0.8.0}/aru/agent_factory.py

@@ -13,7 +13,8 @@ def create_general_agent(session: Session, config: AgentConfig | None = None):
     from agno.agent import Agent
     from agno.compression.manager import CompressionManager
 
-    from aru.tools.codebase import GENERAL_TOOLS, _get_small_model_ref
+    from aru.tools.codebase import GENERAL_TOOLS
+    from aru.runtime import get_ctx
 
     extra = config.get_extra_instructions() if config else ""
 
@@ -25,7 +26,7 @@ def create_general_agent(session: Session, config: AgentConfig | None = None):
         markdown=True,
         compress_tool_results=True,
         compression_manager=CompressionManager(
-            model=create_model(_get_small_model_ref(), max_tokens=1024),
+            model=create_model(get_ctx().small_model_ref, max_tokens=1024),
             compress_tool_results=True,
             compress_tool_results_limit=15,
         ),
@@ -39,7 +40,8 @@ def create_custom_agent_instance(agent_def: CustomAgent, session: Session,
     from agno.agent import Agent
     from agno.compression.manager import CompressionManager
     from aru.agents.base import BASE_INSTRUCTIONS
-    from aru.tools.codebase import resolve_tools, _get_small_model_ref
+    from aru.tools.codebase import resolve_tools
+    from aru.runtime import get_ctx
 
     model_ref = agent_def.model or session.model_ref
     tools = resolve_tools(agent_def.tools)
@@ -58,7 +60,7 @@ def create_custom_agent_instance(agent_def: CustomAgent, session: Session,
         markdown=True,
         compress_tool_results=True,
         compression_manager=CompressionManager(
-            model=create_model(_get_small_model_ref(), max_tokens=1024),
+            model=create_model(get_ctx().small_model_ref, max_tokens=1024),
             compress_tool_results=True,
             compress_tool_results_limit=15,
         ),

{aru_code-0.7.0 → aru_code-0.8.0}/aru/agents/executor.py

@@ -6,7 +6,8 @@ from agno.utils.log import log_warning
 
 from aru.agents.base import build_instructions
 from aru.providers import create_model
-from aru.tools.codebase import EXECUTOR_TOOLS, _get_small_model_ref
+from aru.tools.codebase import EXECUTOR_TOOLS
+from aru.runtime import get_ctx
 
 # Max chars for truncation fallback when compression fails
 _TRUNCATE_FALLBACK = 3000
@@ -50,7 +51,7 @@ def create_executor(model_ref: str = "anthropic/claude-sonnet-4-5", extra_instru
         # Compress tool results after 5 uncompressed tool calls to save tokens
         compress_tool_results=True,
         compression_manager=_SafeCompressionManager(
-            model=create_model(_get_small_model_ref(), max_tokens=2048),
+            model=create_model(get_ctx().small_model_ref, max_tokens=2048),
             compress_tool_results=True,
             compress_tool_results_limit=15,
         ),

{aru_code-0.7.0 → aru_code-0.8.0}/aru/agents/planner.py

@@ -6,9 +6,9 @@ from agno.compression.manager import CompressionManager
 from aru.agents.base import build_instructions
 from aru.providers import create_model
 from aru.tools.codebase import (
-    _get_small_model_ref,
     glob_search, grep_search, list_directory, read_file, read_file_smart,
 )
+from aru.runtime import get_ctx
 
 REVIEWER_INSTRUCTIONS = """\
 You are a plan scope reviewer. You receive a user request and a generated implementation plan.
@@ -47,7 +47,7 @@ async def review_plan(request: str, plan: str) -> str:
     """
     reviewer = Agent(
         name="Reviewer",
-        model=create_model(_get_small_model_ref(), max_tokens=2048),
+        model=create_model(get_ctx().small_model_ref, max_tokens=2048),
         instructions=REVIEWER_INSTRUCTIONS,
         markdown=True,
     )
@@ -77,7 +77,7 @@ def create_planner(model_ref: str = "anthropic/claude-sonnet-4-5", extra_instruc
         # Compress tool results after 6 uncompressed tool calls to save tokens
         compress_tool_results=True,
         compression_manager=CompressionManager(
-            model=create_model(_get_small_model_ref(), max_tokens=1024),
+            model=create_model(get_ctx().small_model_ref, max_tokens=1024),
             compress_tool_results=True,
             compress_tool_results_limit=15,
         ),

{aru_code-0.7.0 → aru_code-0.8.0}/aru/cli.py

@@ -104,24 +104,18 @@ from aru.providers import (
 
 async def run_cli(skip_permissions: bool = False, resume_id: str | None = None):
     """Main REPL loop."""
-    from aru.tools.codebase import set_model_id, set_small_model_ref, set_on_file_mutation
-    from aru.permissions import (
-        set_config as set_perm_config,
-        set_skip_permissions,
-        set_console as perm_set_console,
-        reset_session as perm_reset_session,
-        parse_permission_config,
-    )
-    from aru.tools.codebase import set_console
-    set_console(console)
-    perm_set_console(console)
-    set_skip_permissions(skip_permissions)
+    import atexit
+    from aru.runtime import init_ctx, get_ctx
+    from aru.permissions import parse_permission_config, reset_session as perm_reset_session
+    from aru.tools.codebase import cleanup_processes
+
+    ctx = init_ctx(console=console, skip_permissions=skip_permissions)
 
     store = SessionStore()
 
     def _sync_model(sess: Session):
-        """Sync the model IDs to the tools module from the session's model_ref."""
-        set_model_id(sess.model_id)
+        """Sync the model IDs to the RuntimeContext from the session's model_ref."""
+        ctx.model_id = sess.model_id
         small_ref = config.model_aliases.get("small") if config else None
         if not small_ref:
             provider_key, _ = resolve_model_ref(sess.model_ref)
@@ -133,7 +127,7 @@ async def run_cli(skip_permissions: bool = False, resume_id: str | None = None):
                 "ollama": "ollama/llama3.1",
             }
             small_ref = _small_defaults.get(provider_key, sess.model_ref)
-        set_small_model_ref(small_ref)
+        ctx.small_model_ref = small_ref
 
     # Load project configuration
     config = load_config()
@@ -155,8 +149,7 @@ async def run_cli(skip_permissions: bool = False, resume_id: str | None = None):
         from aru.tools.codebase import set_custom_agents
         set_custom_agents(config.custom_agents)
     if config.permissions:
-        perm_config = parse_permission_config(config.permissions)
-        set_perm_config(perm_config)
+        ctx.perm_config = parse_permission_config(config.permissions)
         console.print("[dim]Loaded permission config[/dim]")
 
     extra_instructions = config.get_extra_instructions()
@@ -188,8 +181,9 @@ async def run_cli(skip_permissions: bool = False, resume_id: str | None = None):
         _sync_model(session)
         _render_home(session, skip_permissions)
 
-    # Wire file-mutation callback
-    set_on_file_mutation(session.invalidate_context_cache)
+    # Wire file-mutation callback and atexit cleanup
+    ctx.on_file_mutation = session.invalidate_context_cache
+    atexit.register(lambda: cleanup_processes(ctx.tracked_processes))
 
     planner = None
     executor = None

{aru_code-0.7.0 → aru_code-0.8.0}/aru/context.py

@@ -204,7 +204,7 @@ async def compact_conversation(
     Uses a small/fast model for the summarization to minimize cost.
     Falls back to simple truncation if the agent call fails.
     """
-    from aru.tools.codebase import _get_small_model_ref
+    from aru.runtime import get_ctx
     from aru.providers import create_model
 
     prompt = build_compaction_prompt(history, plan_task)
@@ -212,7 +212,7 @@ async def compact_conversation(
     try:
         from agno.agent import Agent
 
-        small_ref = _get_small_model_ref()
+        small_ref = get_ctx().small_model_ref
         compactor = Agent(
             name="Compactor",
             model=create_model(small_ref, max_tokens=2048),

{aru_code-0.7.0 → aru_code-0.8.0}/aru/permissions.py

@@ -19,15 +19,16 @@ from __future__ import annotations
 
 import fnmatch
 import os
-import threading
 from contextlib import contextmanager
 from dataclasses import dataclass, field
 from typing import Any, Generator, Literal
 
-from rich.console import Console, Group
+from rich.console import Group
 from rich.panel import Panel
 from rich.text import Text
 
+from aru.runtime import get_ctx
+
 PermissionAction = Literal["allow", "ask", "deny"]
 
 VALID_ACTIONS: set[str] = {"allow", "ask", "deny"}
@@ -96,62 +97,24 @@ for _prefix in SAFE_COMMAND_PREFIXES:
 
 
 # ---------------------------------------------------------------------------
-# Module-level state
+# Thin wrappers over RuntimeContext (preserve public API for callers)
 # ---------------------------------------------------------------------------
 
-_config: PermissionConfig = PermissionConfig()
-_session_allowed: set[tuple[str, str]] = set()  # (category, pattern) approved via "always"
-_skip_permissions: bool = False
-_permission_lock = threading.Lock()
-_live = None
-_display = None
-_console = Console()
-
-
-# ---------------------------------------------------------------------------
-# Setters
-# ---------------------------------------------------------------------------
+def set_config(config: PermissionConfig) -> None:
+    get_ctx().perm_config = config
 
-def set_config(config: PermissionConfig):
-    global _config
-    _config = config
 
-
-def set_skip_permissions(value: bool):
-    global _skip_permissions
-    _skip_permissions = value
+def set_skip_permissions(value: bool) -> None:
+    get_ctx().skip_permissions = value
 
 
 def get_skip_permissions() -> bool:
-    return _skip_permissions
-
-
-def set_live(live):
-    global _live
-    _live = live
-
+    return get_ctx().skip_permissions
 
-def set_display(display):
-    global _display
-    _display = display
 
-
-def set_console(console: Console):
-    global _console
-    _console = console
-
-
-def reset_session():
+def reset_session() -> None:
     """Reset session-level permission state (call between conversations)."""
-    _session_allowed.clear()
-
-
-# ---------------------------------------------------------------------------
-# Agent-level permission scoping
-# ---------------------------------------------------------------------------
-
-_config_stack: list[PermissionConfig] = []
-_session_stack: list[set[tuple[str, str]]] = []
+    get_ctx().session_allowed.clear()
 
 
 def merge_configs(base: PermissionConfig, overlay: PermissionConfig) -> PermissionConfig:
@@ -175,22 +138,22 @@ def permission_scope(overlay_raw: dict[str, Any] | None) -> Generator[None, None
     Each scope gets its own fresh "always" session memory, so agent approvals
     don't leak to the global scope or other agents.
     """
-    global _config, _session_allowed
     if not overlay_raw:
         yield
         return
 
-    _config_stack.append(_config)
-    _session_stack.append(_session_allowed)
-    _session_allowed = set()
+    ctx = get_ctx()
+    ctx.config_stack.append(ctx.perm_config)
+    ctx.session_stack.append(ctx.session_allowed)
+    ctx.session_allowed = set()
 
     overlay = parse_permission_config(overlay_raw)
-    _config = merge_configs(_config, overlay)
+    ctx.perm_config = merge_configs(ctx.perm_config, overlay)
     try:
         yield
     finally:
-        _config = _config_stack.pop()
-        _session_allowed = _session_stack.pop()
+        ctx.perm_config = ctx.config_stack.pop()
+        ctx.session_allowed = ctx.session_stack.pop()
 
 
 # ---------------------------------------------------------------------------
@@ -304,8 +267,9 @@ def _build_rules(category: str) -> list[PermissionRule]:
         rules.extend(_SENSITIVE_FILE_RULES)
 
     # Add user-configured rules
-    if category in _config.categories:
-        rules.extend(_config.categories[category])
+    ctx = get_ctx()
+    if category in ctx.perm_config.categories:
+        rules.extend(ctx.perm_config.categories[category])
 
     return rules
 
@@ -382,7 +346,7 @@ def _resolve_bash_compound(command: str) -> tuple[PermissionAction, str]:
 def _resolve_bash_single(command: str) -> tuple[PermissionAction, str]:
     """Resolve permission for a single (non-compound) bash command."""
     rules = _build_rules("bash")
-    result: PermissionAction = CATEGORY_DEFAULTS.get("bash", _config.default)
+    result: PermissionAction = CATEGORY_DEFAULTS.get("bash", get_ctx().perm_config.default)
     matched_pattern = "*"
 
     for rule in rules:
@@ -419,11 +383,12 @@ def resolve_permission(
     4. For others: walk rules (defaults + user config), last-match-wins
     5. Fallback: category default, then global default
     """
-    if _skip_permissions:
+    ctx = get_ctx()
+    if ctx.skip_permissions:
         return ("allow", "*")
 
     # Check session memory
-    for cat, pattern in _session_allowed:
+    for cat, pattern in ctx.session_allowed:
         if cat == category and _match_rule(pattern, subject):
             return ("allow", pattern)
 
@@ -433,7 +398,7 @@ def resolve_permission(
 
     # All other categories
     rules = _build_rules(category)
-    result: PermissionAction = CATEGORY_DEFAULTS.get(category, _config.default)
+    result: PermissionAction = CATEGORY_DEFAULTS.get(category, ctx.perm_config.default)
     matched_pattern = "*"
 
     for rule in rules:
@@ -465,7 +430,8 @@ def check_permission(
         return False
 
     # action == "ask" -> prompt user
-    with _permission_lock:
+    ctx = get_ctx()
+    with ctx.permission_lock:
         # Re-check after acquiring lock (another thread may have resolved it)
         action2, pattern2 = resolve_permission(category, subject)
         if action2 == "allow":
@@ -474,25 +440,25 @@ def check_permission(
             return False
 
         # Pause Live and flush already-streamed content
-        if _live:
-            _live.stop()
-        if _display:
-            _display.flush()
+        if ctx.live:
+            ctx.live.stop()
+        if ctx.display:
+            ctx.display.flush()
 
         title = f"{category}: {subject}" if subject else category
-        _console.print()
-        _console.print(Panel(
+        ctx.console.print()
+        ctx.console.print(Panel(
             display_details,
             title=f"[bold yellow]{title}[/bold yellow]",
             border_style="yellow",
             expand=False,
         ))
         try:
-            answer = _console.input(
+            answer = ctx.console.input(
                 "[bold yellow]Allow? (y)es once / (a)lways / (n)o:[/bold yellow] "
             ).strip().lower()
             if answer in ("a", "always", "all"):
-                _session_allowed.add((category, matched_pattern))
+                ctx.session_allowed.add((category, matched_pattern))
                 allowed = True
             else:
                 allowed = answer in ("y", "yes", "s", "sim")
@@ -500,8 +466,8 @@ def check_permission(
             allowed = False
 
         # Resume Live display
-        if _live:
-            _live.start()
-            _live._live_render._shape = None
+        if ctx.live:
+            ctx.live.start()
+            ctx.live._live_render._shape = None
 
         return allowed

{aru_code-0.7.0 → aru_code-0.8.0}/aru/runner.py

@@ -69,9 +69,7 @@ async def run_agent_capture(agent, message: str, session=None, lightweight: bool
     _stalled = False
 
     try:
-        from aru.tools.codebase import set_display, set_live
-        from aru.permissions import set_live as perm_set_live, set_display as perm_set_display
-        from aru.tools.tasklist import set_live as tasklist_set_live, set_display as tasklist_set_display
+        from aru.runtime import get_ctx
 
         status = StatusBar(interval=3.0)
         display = StreamingDisplay(status)
@@ -125,12 +123,9 @@ async def run_agent_capture(agent, message: str, session=None, lightweight: bool
 
         run_output = None
         with Live(display, console=console, refresh_per_second=10) as live:
-            set_live(live)
-            set_display(display)
-            perm_set_live(live)
-            perm_set_display(display)
-            tasklist_set_live(live)
-            tasklist_set_display(display)
+            ctx = get_ctx()
+            ctx.live = live
+            ctx.display = display
             accumulated = ""
             _stall_counter = 0
             _stalled = False
@@ -215,10 +210,8 @@ async def run_agent_capture(agent, message: str, session=None, lightweight: bool
                         )
                         break
 
-        set_live(None)
-        set_display(None)
-        perm_set_live(None)
-        perm_set_display(None)
+        ctx.live = None
+        ctx.display = None
 
         if run_output and session and hasattr(run_output, "metrics"):
             session.track_tokens(run_output.metrics)
@@ -239,16 +232,14 @@ async def run_agent_capture(agent, message: str, session=None, lightweight: bool
             console.print(Markdown(remaining))
 
     except (KeyboardInterrupt, asyncio.CancelledError):
-        set_live(None)
-        set_display(None)
-        perm_set_live(None)
-        perm_set_display(None)
+        ctx = get_ctx()
+        ctx.live = None
+        ctx.display = None
         console.print("\n[yellow]Interrupted.[/yellow]")
     except Exception as e:
-        set_live(None)
-        set_display(None)
-        perm_set_live(None)
-        perm_set_display(None)
+        ctx = get_ctx()
+        ctx.live = None
+        ctx.display = None
         from rich.markup import escape
         console.print(f"[red]Error: {escape(str(e))}[/red]")
 

aru_code-0.8.0/aru/runtime.py

@@ -0,0 +1,158 @@
+"""Centralised runtime context for Aru.
+
+Replaces scattered module-level globals with a single RuntimeContext
+accessible via ``contextvars.ContextVar``.  This gives each asyncio task
+(and each ``asyncio.to_thread`` call) its own isolated snapshot, which
+means parallel agent runs and tests never share mutable state.
+
+Usage::
+
+    from aru.runtime import get_ctx, init_ctx
+
+    # At startup (cli.py):
+    ctx = init_ctx(console=console)
+
+    # In any tool / helper:
+    ctx = get_ctx()
+    ctx.live  # Rich Live instance (or None)
+"""
+
+from __future__ import annotations
+
+import contextvars
+import copy
+import threading
+from dataclasses import dataclass, field
+from typing import Any, Callable
+
+from rich.console import Console
+
+
+# ── TaskStore (moved from tools/tasklist.py) ─────────────────────────
+
+class TaskStore:
+    """Thread-safe store for the current step's subtask list."""
+
+    def __init__(self) -> None:
+        self._lock = threading.Lock()
+        self._tasks: list[dict] = []
+        self._created = False
+
+    def create(self, tasks: list[str]) -> list[dict]:
+        with self._lock:
+            self._tasks = [
+                {"index": i + 1, "description": desc, "status": "pending"}
+                for i, desc in enumerate(tasks)
+            ]
+            self._created = True
+            return list(self._tasks)
+
+    def update(self, index: int, status: str) -> dict | None:
+        with self._lock:
+            for task in self._tasks:
+                if task["index"] == index:
+                    task["status"] = status
+                    return dict(task)
+            return None
+
+    def get_all(self) -> list[dict]:
+        with self._lock:
+            return list(self._tasks)
+
+    @property
+    def is_created(self) -> bool:
+        with self._lock:
+            return self._created
+
+    def reset(self) -> None:
+        with self._lock:
+            self._tasks = []
+            self._created = False
+
+
+# ── PermissionConfig (imported lazily to avoid circular deps) ────────
+
+def _default_perm_config():
+    from aru.permissions import PermissionConfig
+    return PermissionConfig()
+
+
+# ── RuntimeContext ───────────────────────────────────────────────────
+
+@dataclass
+class RuntimeContext:
+    """All mutable runtime state, grouped by domain."""
+
+    # -- Display --
+    console: Console = field(default_factory=Console)
+    live: Any = None
+    display: Any = None
+
+    # -- Model --
+    model_id: str = "claude-sonnet-4-5-20250929"
+    small_model_ref: str = "anthropic/claude-haiku-4-5"
+
+    # -- File operations --
+    on_file_mutation: Callable[[], None] | None = None
+    read_cache: dict[tuple, str] = field(default_factory=dict)
+
+    # -- Process tracking --
+    tracked_processes: list = field(default_factory=list)
+    subagent_counter: int = 0
+    subagent_counter_lock: threading.Lock = field(default_factory=threading.Lock)
+
+    # -- Custom agents --
+    custom_agent_defs: dict = field(default_factory=dict)
+
+    # -- Permissions --
+    perm_config: Any = field(default_factory=_default_perm_config)
+    session_allowed: set[tuple[str, str]] = field(default_factory=set)
+    skip_permissions: bool = False
+    permission_lock: threading.Lock = field(default_factory=threading.Lock)
+    config_stack: list = field(default_factory=list)
+    session_stack: list[set[tuple[str, str]]] = field(default_factory=list)
+
+    # -- Tasklist --
+    task_store: TaskStore = field(default_factory=TaskStore)
+
+
+# ── ContextVar plumbing ──────────────────────────────────────────────
+
+_runtime_ctx: contextvars.ContextVar[RuntimeContext] = contextvars.ContextVar("aru_runtime")
+
+
+def get_ctx() -> RuntimeContext:
+    """Return the current RuntimeContext.  Raises LookupError if not initialised."""
+    return _runtime_ctx.get()
+
+
+def set_ctx(ctx: RuntimeContext) -> contextvars.Token[RuntimeContext]:
+    """Set *ctx* as the current RuntimeContext; return a reset token."""
+    return _runtime_ctx.set(ctx)
+
+
+def init_ctx(console: Console | None = None, **kwargs: Any) -> RuntimeContext:
+    """Create a new RuntimeContext, install it, and return it."""
+    ctx = RuntimeContext(console=console or Console(), **kwargs)
+    _runtime_ctx.set(ctx)
+    return ctx
+
+
+def fork_ctx() -> RuntimeContext:
+    """Create an isolated copy of the current RuntimeContext for sub-agent use.
+
+    Permission state is deep-copied to prevent interleaving when multiple
+    sub-agents run concurrently via ``asyncio.gather``.  Shared resources
+    (console, locks, tracked_processes) are kept by reference.
+    """
+    original = get_ctx()
+    forked = copy.copy(original)
+    # Deep-copy mutable permission state for isolation
+    forked.config_stack = list(original.config_stack)
+    forked.session_stack = [s.copy() for s in original.session_stack]
+    forked.session_allowed = original.session_allowed.copy()
+    # Fresh read cache per sub-agent
+    forked.read_cache = {}
+    # Fresh task store per sub-agent
+    forked.task_store = TaskStore()
+    return forked