aria-code 4.1.3__py3-none-any.whl

runtime/subagent.py

@@ -0,0 +1,258 @@
+"""Background subagent task system.
+
+Allows the main agent to spawn independent sub-tasks that run concurrently.
+Tasks are tracked in memory and optionally persisted to ~/.arthera/tasks/.
+
+Tool functions exposed to the LLM:
+    spawn_task(prompt, context?)  → {"task_id": "abc123", "status": "pending"}
+    task_status(task_id)          → {"status": "running|done|failed", ...}
+    task_result(task_id)          → {"result": "...", "success": bool}
+    task_list()                   → [{"task_id": ..., "status": ...}, ...]
+    task_cancel(task_id)          → {"cancelled": bool}
+
+Background execution is wired up in aria_cli.py via _subagent_runner().
+If no runner is registered, spawn_task stores the task for manual execution.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import time
+import uuid
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Callable, Dict, Optional
+
+_TASKS: Dict[str, "SubagentTask"] = {}
+_RUNNER: Optional[Callable] = None  # set by aria_cli.py
+
+
+@dataclass
+class SubagentTask:
+    task_id: str
+    prompt: str
+    context: str = ""
+    status: str = "pending"   # pending | running | done | failed | cancelled
+    result: str = ""
+    error: str = ""
+    created_at: float = field(default_factory=time.time)
+    completed_at: float = 0.0
+
+    def age_str(self) -> str:
+        elapsed = time.time() - self.created_at
+        if elapsed < 60:
+            return f"{int(elapsed)}s"
+        if elapsed < 3600:
+            return f"{elapsed/60:.1f}m"
+        return f"{elapsed/3600:.1f}h"
+
+    def to_dict(self) -> dict:
+        return {
+            "task_id": self.task_id,
+            "status": self.status,
+            "prompt": self.prompt[:200] + ("…" if len(self.prompt) > 200 else ""),
+            "age": self.age_str(),
+        }
+
+
+def register_runner(runner: Callable) -> None:
+    """Register the async runner function from aria_cli.py."""
+    global _RUNNER
+    _RUNNER = runner
+
+
+# ── Tool functions ─────────────────────────────────────────────────────────────
+
+def tool_spawn_task(params: dict) -> dict:
+    """Spawn an independent background agent task."""
+    prompt = params.get("prompt", "")
+    context = params.get("context", "")
+    if not prompt:
+        return {"success": False, "error": "Missing 'prompt'"}
+
+    task_id = uuid.uuid4().hex[:8]
+    task = SubagentTask(task_id=task_id, prompt=prompt, context=context)
+    _TASKS[task_id] = task
+
+    if _RUNNER is not None:
+        try:
+            loop = asyncio.get_event_loop()
+            if loop.is_running():
+                asyncio.ensure_future(_run_background(task))
+            else:
+                loop.run_until_complete(_run_background(task))
+        except Exception as exc:
+            task.status = "failed"
+            task.error = str(exc)
+    else:
+        # No runner — task stays in "pending" for manual execution
+        task.status = "pending"
+
+    return {
+        "success": True,
+        "task_id": task_id,
+        "status": task.status,
+        "message": (
+            f"Task {task_id} spawned. Use task_status('{task_id}') to check progress."
+            if task.status == "running" else
+            f"Task {task_id} queued (no runner registered). Check /tasks."
+        ),
+    }
+
+
+async def _run_background(task: SubagentTask) -> None:
+    task.status = "running"
+    try:
+        full_prompt = task.prompt
+        if task.context:
+            full_prompt = f"{task.context}\n\n{task.prompt}"
+        result_text = await _RUNNER(full_prompt)
+        task.result = result_text or ""
+        task.status = "done"
+    except asyncio.CancelledError:
+        task.status = "cancelled"
+    except Exception as exc:
+        task.error = str(exc)
+        task.status = "failed"
+    finally:
+        task.completed_at = time.time()
+
+
+def tool_task_status(params: dict) -> dict:
+    """Check the status of a background task."""
+    task_id = params.get("task_id", "")
+    if not task_id:
+        return {"success": False, "error": "Missing 'task_id'"}
+    task = _TASKS.get(task_id)
+    if not task:
+        return {"success": False, "error": f"Task '{task_id}' not found"}
+    return {
+        "success": True,
+        "task_id": task_id,
+        "status": task.status,
+        "age": task.age_str(),
+        "prompt_preview": task.prompt[:100],
+        "error": task.error or None,
+    }
+
+
+def tool_task_result(params: dict) -> dict:
+    """Retrieve the result of a completed background task."""
+    task_id = params.get("task_id", "")
+    if not task_id:
+        return {"success": False, "error": "Missing 'task_id'"}
+    task = _TASKS.get(task_id)
+    if not task:
+        return {"success": False, "error": f"Task '{task_id}' not found"}
+    if task.status == "running":
+        return {"success": False, "error": "Task is still running", "status": "running"}
+    if task.status == "failed":
+        return {"success": False, "error": task.error, "status": "failed"}
+    if task.status in ("pending", "cancelled"):
+        return {"success": False, "error": f"Task status is '{task.status}'", "status": task.status}
+    return {
+        "success": True,
+        "task_id": task_id,
+        "status": task.status,
+        "result": task.result,
+        "age": task.age_str(),
+    }
+
+
+def tool_task_list(params: dict) -> dict:
+    """List all tracked background tasks."""
+    tasks = [t.to_dict() for t in _TASKS.values()]
+    if not tasks:
+        return {"success": True, "tasks": [], "message": "No active tasks."}
+    by_status: dict = {}
+    for t in tasks:
+        s = t["status"]
+        by_status.setdefault(s, []).append(t)
+    return {
+        "success": True,
+        "total": len(tasks),
+        "tasks": tasks,
+        "summary": {s: len(v) for s, v in by_status.items()},
+    }
+
+
+def tool_task_cancel(params: dict) -> dict:
+    """Cancel a pending or running background task."""
+    task_id = params.get("task_id", "")
+    if not task_id:
+        return {"success": False, "error": "Missing 'task_id'"}
+    task = _TASKS.get(task_id)
+    if not task:
+        return {"success": False, "error": f"Task '{task_id}' not found"}
+    if task.status in ("done", "failed", "cancelled"):
+        return {"success": False, "error": f"Task already in terminal state: {task.status}"}
+    task.status = "cancelled"
+    task.completed_at = time.time()
+    return {"success": True, "task_id": task_id, "cancelled": True}
+
+
+# ── Tool registry (added to LOCAL_TOOLS in aria_cli.py) ───────────────────────
+
+SUBAGENT_TOOLS = {
+    "spawn_task":    (tool_spawn_task,   "Spawn a background sub-task; returns task_id"),
+    "task_status":   (tool_task_status,  "Check status of a background task by task_id"),
+    "task_result":   (tool_task_result,  "Retrieve result of a completed background task"),
+    "task_list":     (tool_task_list,    "List all active background tasks"),
+    "task_cancel":   (tool_task_cancel,  "Cancel a pending or running background task"),
+}
+
+SUBAGENT_SCHEMAS = [
+    {
+        "name": "spawn_task",
+        "description": "Spawn an independent background agent task. Useful for parallelising slow operations: research, data fetching, long analysis. Returns a task_id you can poll with task_status.",
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "prompt":  {"type": "string", "description": "The task for the sub-agent to perform"},
+                "context": {"type": "string", "description": "Optional background context to inject into the sub-agent's system prompt"},
+            },
+            "required": ["prompt"],
+        },
+    },
+    {
+        "name": "task_status",
+        "description": "Check the status of a background task spawned with spawn_task.",
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "task_id": {"type": "string", "description": "The task_id returned by spawn_task"},
+            },
+            "required": ["task_id"],
+        },
+    },
+    {
+        "name": "task_result",
+        "description": "Retrieve the full result text of a completed background task.",
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "task_id": {"type": "string", "description": "The task_id returned by spawn_task"},
+            },
+            "required": ["task_id"],
+        },
+    },
+    {
+        "name": "task_list",
+        "description": "List all active and completed background tasks with their statuses.",
+        "parameters": {
+            "type": "object",
+            "properties": {},
+        },
+    },
+    {
+        "name": "task_cancel",
+        "description": "Cancel a pending or running background task.",
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "task_id": {"type": "string", "description": "The task_id to cancel"},
+            },
+            "required": ["task_id"],
+        },
+    },
+]

runtime/tool_executor.py

@@ -0,0 +1,104 @@
+"""Tool execution layer for Aria Code runtimes."""
+
+from __future__ import annotations
+
+import asyncio
+import time
+from typing import Any, Awaitable, Callable, Dict, Mapping, Optional
+
+from .events import RuntimeTrace, ToolCallRecord
+
+ToolHandler = Callable[[dict], dict]
+RemoteExecutor = Callable[[str, dict], Awaitable[dict]]
+Hook = Callable[[str, str, dict, Optional[dict]], None]
+
+
+class ToolExecutor:
+    """Execute local/remote tools with hooks, policy injection, and trace records."""
+
+    def __init__(
+        self,
+        local_tools: Mapping[str, tuple],
+        *,
+        remote_executor: RemoteExecutor | None = None,
+        hook: Hook | None = None,
+        trace: RuntimeTrace | None = None,
+        config: Dict[str, Any] | None = None,
+    ) -> None:
+        self.local_tools = local_tools
+        self.remote_executor = remote_executor
+        self.hook = hook
+        self.trace = trace or RuntimeTrace()
+        self.config = config or {}
+
+    def execute_local(self, tool_name: str, params: dict) -> dict:
+        """Execute a local tool synchronously."""
+        if tool_name not in self.local_tools:
+            return {"success": False, "error": f"Unknown local tool: {tool_name}"}
+        handler = self.local_tools[tool_name][0]
+        params = self._prepare_params(tool_name, params)
+        return self._call_with_trace(tool_name, params, lambda: handler(params))
+
+    async def execute(self, tool_name: str, params: dict) -> dict:
+        """Execute a tool asynchronously, using remote executor when needed."""
+        if tool_name in self.local_tools:
+            params = self._prepare_params(tool_name, params)
+            loop = asyncio.get_event_loop()
+            return await loop.run_in_executor(None, self.execute_local, tool_name, params)
+        if self.remote_executor is None:
+            return {"success": False, "error": f"Unknown tool: {tool_name}"}
+        params = self._prepare_params(tool_name, params)
+        start = time.time()
+        self._run_hook("pre_tool", tool_name, params)
+        self.trace.emit("tool_call", {"tool": tool_name, "params": params})
+        try:
+            result = await self.remote_executor(tool_name, params)
+        except Exception as exc:
+            result = {"success": False, "error": str(exc)}
+        self._run_hook("post_tool", tool_name, params, result)
+        end = time.time()
+        self.trace.add_tool_call(ToolCallRecord(
+            tool=tool_name,
+            params=params,
+            result=result,
+            elapsed_ms=(end - start) * 1000,
+            started_at=start,
+            ended_at=end,
+        ))
+        return result
+
+    def _call_with_trace(self, tool_name: str, params: dict, fn: Callable[[], dict]) -> dict:
+        start = time.time()
+        self._run_hook("pre_tool", tool_name, params)
+        self.trace.emit("tool_call", {"tool": tool_name, "params": params})
+        try:
+            result = fn()
+        except Exception as exc:
+            result = {"success": False, "error": str(exc)}
+        self._run_hook("post_tool", tool_name, params, result)
+        end = time.time()
+        self.trace.add_tool_call(ToolCallRecord(
+            tool=tool_name,
+            params=params,
+            result=result,
+            elapsed_ms=(end - start) * 1000,
+            started_at=start,
+            ended_at=end,
+        ))
+        return result
+
+    def _prepare_params(self, tool_name: str, params: dict) -> dict:
+        prepared = dict(params or {})
+        if tool_name == "run_command":
+            prepared.setdefault("policy", self.config.get("command_policy", "safe"))
+            prepared.setdefault("permission_mode", self.config.get("permission_mode", "workspace-write"))
+            prepared.setdefault("network_enabled", bool(self.config.get("network_enabled", True)))
+        return prepared
+
+    def _run_hook(self, hook_type: str, tool_name: str, params: dict, result: dict | None = None) -> None:
+        if self.hook is None:
+            return
+        try:
+            self.hook(hook_type, tool_name, params, result)
+        except Exception:
+            pass

runtime/tool_policy.py

@@ -0,0 +1,106 @@
+"""Persistent per-tool execution policy: allowlist, denylist, ask-always.
+
+Stores policy in ~/.arthera/tool_policy.json.
+Checked in _confirm_tool_execution_decision() before any user prompt.
+
+Usage:
+    from runtime.tool_policy import check_tool_policy, add_to_policy
+
+    verdict = check_tool_policy("write_file")  # "allow" | "deny" | "ask" | "default"
+    add_to_policy("read_file", "allow")         # permanently auto-approve
+    add_to_policy("run_command", "deny")        # permanently block
+    add_to_policy("edit_file", "ask")           # always prompt
+    remove_from_policy("read_file")             # remove from all lists
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Literal
+
+PolicyVerdict = Literal["allow", "deny", "ask", "default"]
+
+_DEFAULT_POLICY: dict = {
+    "allowed": [],     # auto-approve without prompt
+    "denied": [],      # always block, never execute
+    "ask_always": [],  # always prompt even for non-CONFIRM_TOOLS
+}
+
+
+def _policy_file() -> Path:
+    return Path.home() / ".arthera" / "tool_policy.json"
+
+
+def load_tool_policy() -> dict:
+    """Load policy from disk; returns defaults if missing or corrupt."""
+    f = _policy_file()
+    if f.exists():
+        try:
+            raw = json.loads(f.read_text(encoding="utf-8"))
+            return {
+                "allowed":    list(raw.get("allowed", [])),
+                "denied":     list(raw.get("denied", [])),
+                "ask_always": list(raw.get("ask_always", [])),
+            }
+        except Exception:
+            pass
+    return {k: list(v) for k, v in _DEFAULT_POLICY.items()}
+
+
+def save_tool_policy(policy: dict) -> None:
+    f = _policy_file()
+    f.parent.mkdir(parents=True, exist_ok=True)
+    f.write_text(json.dumps(policy, indent=2, ensure_ascii=False), encoding="utf-8")
+
+
+def check_tool_policy(tool_name: str) -> PolicyVerdict:
+    """Return the persistent verdict for *tool_name*.
+
+    "allow"   → auto-approve, skip confirmation prompt
+    "deny"    → block, never execute
+    "ask"     → always prompt (overrides session auto-allow)
+    "default" → no override, fall through to normal flow
+    """
+    policy = load_tool_policy()
+    if tool_name in policy.get("denied", []):
+        return "deny"
+    if tool_name in policy.get("allowed", []):
+        return "allow"
+    if tool_name in policy.get("ask_always", []):
+        return "ask"
+    return "default"
+
+
+def add_to_policy(tool_name: str, verdict: Literal["allow", "deny", "ask"]) -> None:
+    """Add *tool_name* to the given policy list, removing it from any other list first."""
+    policy = load_tool_policy()
+    for key in ("allowed", "denied", "ask_always"):
+        policy.setdefault(key, [])
+        if tool_name in policy[key]:
+            policy[key].remove(tool_name)
+    if verdict == "allow":
+        policy["allowed"].append(tool_name)
+    elif verdict == "deny":
+        policy["denied"].append(tool_name)
+    elif verdict == "ask":
+        policy["ask_always"].append(tool_name)
+    save_tool_policy(policy)
+
+
+def remove_from_policy(tool_name: str) -> bool:
+    """Remove *tool_name* from all lists. Returns True if it was present."""
+    policy = load_tool_policy()
+    changed = False
+    for key in ("allowed", "denied", "ask_always"):
+        if tool_name in policy.get(key, []):
+            policy[key].remove(tool_name)
+            changed = True
+    if changed:
+        save_tool_policy(policy)
+    return changed
+
+
+def policy_summary() -> dict:
+    """Return current policy as a human-readable dict."""
+    return load_tool_policy()

safety/__init__.py

@@ -0,0 +1,21 @@
+"""Safety and permission primitives for Aria Code."""
+
+from .permissions import (
+    PermissionDecision,
+    PermissionMode,
+    PermissionService,
+    PolicyDecision,
+    classify_command_risk,
+    evaluate_command_policy,
+    normalize_command,
+)
+
+__all__ = [
+    "PermissionDecision",
+    "PermissionMode",
+    "PermissionService",
+    "PolicyDecision",
+    "classify_command_risk",
+    "evaluate_command_policy",
+    "normalize_command",
+]