aria-code 0.52.0__py3-none-any.whl

aria_code/runtime/task_orchestrator.py

@@ -0,0 +1,90 @@
+"""Deterministic task graphs for visible, verifiable Agent execution.
+
+This is deliberately a planner rather than another LLM.  The primary model
+still reasons about the work, while the runtime supplies a stable contract:
+what can run in parallel, what must be verified, and when a result is too weak
+to be presented as complete.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Iterable
+
+from aria_code.apps.cli.finance_service_catalog import classify_finance_market
+from aria_code.apps.cli.intent_router import build_intent_route
+
+
+@dataclass(frozen=True)
+class TaskStage:
+    key: str
+    title: str
+    objective: str
+    mode: str = "read-only"
+    depends_on: tuple[str, ...] = ()
+    verification: str = ""
+
+
+@dataclass(frozen=True)
+class TaskGraph:
+    request: str
+    kind: str
+    stages: tuple[TaskStage, ...]
+
+    def ready(self, completed: Iterable[str]) -> tuple[TaskStage, ...]:
+        done = set(completed)
+        return tuple(stage for stage in self.stages if stage.key not in done and set(stage.depends_on) <= done)
+
+
+def build_task_graph(request: str) -> TaskGraph:
+    """Build an auditable graph from the user's request without network I/O."""
+    text = str(request or "").strip()
+    route = build_intent_route(text)
+    market = classify_finance_market(text)
+    financial_intents = {
+        "market_snapshot", "market_analysis", "market_research", "report", "chart",
+        "backtest", "strategy", "ashare", "hk_market", "us_market", "crypto",
+        "forex", "commodity",
+    }
+
+    if route.allows_code_autorun or route.primary == "code":
+        return TaskGraph(text, "engineering", (
+            TaskStage("inspect", "范围与现状", "读取相关文件、约束和现有测试，确认最小改动范围。", verification="列出将修改的文件和不触碰的用户改动。"),
+            TaskStage("implement", "实现", "在隔离工作区完成最小可验证实现。", mode="workspace-write", depends_on=("inspect",)),
+            TaskStage("verify", "验证", "运行相关测试、静态检查和必要的手动冒烟检查。", depends_on=("implement",), verification="失败必须保留错误和未验证项。"),
+            TaskStage("review", "审查与交付", "审查 diff、风险和验证证据，再总结交付结果。", depends_on=("verify",), verification="未经验证的改动不得标记为完成。"),
+        ))
+
+    if market is not None or any(intent in financial_intents for intent in route.intents):
+        market_label = market.label if market else "目标市场"
+        stages = [
+            TaskStage(
+                "evidence", "数据与事实", f"取得 {market_label} 的行情、时间戳、来源和可用覆盖范围。",
+                verification="缺失、过期或来源失败必须显式标记，不能补造数值。",
+            ),
+            TaskStage(
+                "research", "新闻与基本面", "核验与任务相关的公告、财报、新闻或宏观事件；区分事实和推断。",
+                depends_on=("evidence",), verification="每个关键结论需要来源、日期和影响路径。",
+            ),
+            TaskStage(
+                "analysis", "分析与情景", "基于证据输出趋势、风险、正反情景和失效条件。",
+                depends_on=("evidence", "research"), verification="不得把技术指标、新闻情绪或预测概率表述为确定事实。",
+            ),
+        ]
+        if market and market.key == "CN" and any(word in text.lower() for word in ("预测", "明天", "明日", "次日", "涨", "跌")):
+            stages.append(TaskStage(
+                "prediction", "量化预测校验", "调用 A 股次交易日引擎，并记录标的覆盖率与样本外评估口径。",
+                depends_on=("evidence",), verification="必须展示数据日期、覆盖率、回测/评估质量和非覆盖标的。",
+            ))
+        stages.append(TaskStage(
+            "quality_gate", "交付前验证", "检查事实、数据日期、矛盾结论和风险披露。",
+            depends_on=tuple(stage.key for stage in stages if stage.key != "quality_gate"),
+            verification="任何关键数据不合格时降级为资料不足，不输出投资指令。",
+        ))
+        return TaskGraph(text, "financial_research", tuple(stages))
+
+    return TaskGraph(text, "general", (
+        TaskStage("clarify", "目标与约束", "提取目标、已知信息、边界和缺失前提。"),
+        TaskStage("execute", "执行", "按目标完成研究、分析或操作。", depends_on=("clarify",)),
+        TaskStage("verify", "结果核验", "核对结果是否直接回答目标，并披露不确定性。", depends_on=("execute",)),
+    ))

aria_code/runtime/tool_executor.py

@@ -0,0 +1,217 @@
+"""Tool execution layer for Aria Code runtimes."""
+
+from __future__ import annotations
+
+import asyncio
+import time
+from pathlib import Path
+from typing import Any, Awaitable, Callable, Dict, Mapping, Optional
+
+from .approval import ApprovalDecision, apply_approval_decision
+from .events import RuntimeTrace, ToolCallRecord
+
+ToolHandler = Callable[[dict], dict]
+RemoteExecutor = Callable[[str, dict], Awaitable[dict]]
+Hook = Callable[[str, str, dict, Optional[dict]], None]
+ExecutionContextProvider = Callable[[], Mapping[str, Any]]
+
+
+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,
+        execution_context: ExecutionContextProvider | 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 {}
+        self.execution_context = execution_context
+
+    def execute_local(
+        self, tool_name: str, params: dict, *, approval: ApprovalDecision | None = None
+    ) -> 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,
+            include_execution_context=True,
+            bind_research_context=True,
+            approval=approval,
+        )
+        context_error = params.pop("_execution_context_error", None)
+        if context_error:
+            result = {"success": False, "error": context_error}
+            self.trace.emit("tool_denied", {"tool": tool_name, "reason": context_error})
+            return result
+        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:
+            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, bind_research_context=True)
+        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,
+        *,
+        include_execution_context: bool = False,
+        bind_research_context: bool = False,
+        approval: ApprovalDecision | None = None,
+    ) -> dict:
+        prepared = dict(params or {})
+        if tool_name == "run_command":
+            # Tool arguments come from the model. Only the host configuration and
+            # a typed approval decision may set execution controls.
+            for key in (
+                "policy", "permission_mode", "network_enabled",
+                "user_approved", "_upgrade_policy", "sandbox",
+            ):
+                prepared.pop(key, None)
+        if self.execution_context is not None and (
+            include_execution_context or bind_research_context
+        ):
+            try:
+                context = dict(self.execution_context() or {})
+                if include_execution_context:
+                    for key, value in context.items():
+                        if str(key).startswith("_") and value is not None:
+                            prepared[str(key)] = value
+                    self._bind_workspace(tool_name, prepared, context)
+                if bind_research_context:
+                    self._bind_research_run(tool_name, prepared, context)
+            except Exception as exc:
+                if include_execution_context:
+                    prepared["_execution_context_error"] = (
+                        f"Execution context unavailable: {exc}"
+                    )
+        if tool_name == "run_command":
+            prepared["policy"] = self.config.get("command_policy", "safe")
+            prepared["permission_mode"] = self.config.get("permission_mode", "workspace-write")
+            prepared["network_enabled"] = bool(self.config.get("network_enabled", True))
+            prepared["sandbox"] = bool(self.config.get("command_sandbox", False))
+            if approval is not None and approval.approved:
+                apply_approval_decision(prepared, approval)
+        return prepared
+
+    @staticmethod
+    def _bind_research_run(
+        tool_name: str,
+        prepared: dict,
+        context: Mapping[str, Any],
+    ) -> None:
+        """Correlate an institutional research run with its upstream Aria run."""
+        canonical_name = str(tool_name).rsplit("__", 1)[-1]
+        if canonical_name != "research_run_create":
+            return
+        control_run_id = context.get("_run_id")
+        trace_id = context.get("_trace_id") or control_run_id
+        if control_run_id:
+            prepared.setdefault("control_run_id", str(control_run_id))
+        if trace_id:
+            prepared.setdefault("trace_id", str(trace_id))
+
+    @staticmethod
+    def _bind_workspace(tool_name: str, prepared: dict, context: Mapping[str, Any]) -> None:
+        workspace_value = context.get("_workspace")
+        if not workspace_value:
+            return
+        workspace = Path(str(workspace_value)).expanduser().resolve()
+        restricted = bool(context.get("_workspace_restricted", False))
+        path_tools = {
+            "read_file",
+            "write_file",
+            "edit_file",
+            "multi_edit",
+            "list_files",
+            "search_code",
+            "analyze_file",
+            "notebook_read",
+            "notebook_edit",
+        }
+        if tool_name in path_tools:
+            raw_path = str(prepared.get("path") or ".")
+            target = Path(raw_path).expanduser()
+            if not target.is_absolute():
+                target = workspace / target
+            target = target.resolve()
+            if restricted and not target.is_relative_to(workspace):
+                prepared["_execution_context_error"] = (
+                    f"Tool path is outside the isolated workspace: {target}"
+                )
+                return
+            prepared["path"] = str(target)
+        if tool_name in {"run_command", "github"}:
+            raw_cwd = str(prepared.get("cwd") or workspace)
+            cwd = Path(raw_cwd).expanduser()
+            if not cwd.is_absolute():
+                cwd = workspace / cwd
+            cwd = cwd.resolve()
+            if restricted and not cwd.is_relative_to(workspace):
+                prepared["_execution_context_error"] = (
+                    f"Command cwd is outside the isolated workspace: {cwd}"
+                )
+                return
+            prepared["cwd"] = str(cwd)
+
+    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

aria_code/runtime/tool_policy.py

@@ -0,0 +1,107 @@
+"""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
+from aria_code.packages.aria_core.paths import aria_home
+
+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 aria_home() / "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()

aria_code/runtime/worktrees.py

@@ -0,0 +1,215 @@
+"""Git worktree isolation for write-capable background agents."""
+
+from __future__ import annotations
+
+import shutil
+import subprocess
+from dataclasses import dataclass
+from pathlib import Path
+
+
+class WorktreeError(RuntimeError):
+    """Raised when an isolated worktree cannot be created safely."""
+
+
+@dataclass(frozen=True)
+class WorktreeSpec:
+    task_id: str
+    repository: str
+    path: str
+    branch: str
+    base_revision: str
+
+
+@dataclass(frozen=True)
+class WorktreeApplyResult:
+    paths: tuple[str, ...]
+    tracked_paths: tuple[str, ...]
+    untracked_paths: tuple[str, ...]
+
+
+class WorktreeManager:
+    """Create task-specific worktrees without changing the caller's cwd."""
+
+    def __init__(self, root: Path | str) -> None:
+        self.root = Path(root).expanduser().resolve()
+        self.root.mkdir(parents=True, exist_ok=True)
+
+    @staticmethod
+    def _git(*args: str, cwd: Path) -> str:
+        try:
+            completed = subprocess.run(
+                ["git", *args],
+                cwd=str(cwd),
+                text=True,
+                capture_output=True,
+                timeout=30,
+                check=False,
+            )
+        except (OSError, subprocess.SubprocessError) as exc:
+            raise WorktreeError(f"Unable to run git: {exc}") from exc
+        if completed.returncode != 0:
+            detail = (completed.stderr or completed.stdout).strip()
+            raise WorktreeError(detail or f"git {' '.join(args)} failed")
+        return completed.stdout.strip()
+
+    @classmethod
+    def repository_root(cls, workspace: Path | str) -> Path:
+        path = Path(workspace).expanduser().resolve()
+        output = cls._git("rev-parse", "--show-toplevel", cwd=path)
+        return Path(output).resolve()
+
+    @classmethod
+    def is_clean(cls, repository: Path | str) -> bool:
+        repo = Path(repository).expanduser().resolve()
+        return not cls._git("status", "--porcelain", "--untracked-files=all", cwd=repo)
+
+    def create(
+        self,
+        *,
+        task_id: str,
+        workspace: Path | str,
+        require_clean: bool = True,
+    ) -> WorktreeSpec:
+        repository = self.repository_root(workspace)
+        if require_clean and not self.is_clean(repository):
+            raise WorktreeError(
+                "The repository has uncommitted changes. Commit or stash them before "
+                "starting a write-capable isolated subagent."
+            )
+        base_revision = self._git("rev-parse", "HEAD", cwd=repository)
+        branch = f"aria/task-{task_id}"
+        destination = (self.root / repository.name / task_id).resolve()
+        if destination.exists():
+            raise WorktreeError(f"Worktree path already exists: {destination}")
+        destination.parent.mkdir(parents=True, exist_ok=True)
+        try:
+            self._git(
+                "worktree",
+                "add",
+                "-b",
+                branch,
+                str(destination),
+                base_revision,
+                cwd=repository,
+            )
+        except Exception:
+            if destination.exists():
+                shutil.rmtree(destination, ignore_errors=True)
+            raise
+        return WorktreeSpec(
+            task_id=task_id,
+            repository=str(repository),
+            path=str(destination),
+            branch=branch,
+            base_revision=base_revision,
+        )
+
+    def remove(self, spec: WorktreeSpec, *, force: bool = False) -> None:
+        repository = Path(spec.repository)
+        path = Path(spec.path)
+        args = ["worktree", "remove"]
+        if force:
+            args.append("--force")
+        args.append(str(path))
+        self._git(*args, cwd=repository)
+
+    def delete_branch(self, spec: WorktreeSpec, *, force: bool = False) -> None:
+        flag = "-D" if force else "-d"
+        self._git("branch", flag, spec.branch, cwd=Path(spec.repository))
+
+    @classmethod
+    def diff(cls, spec: WorktreeSpec) -> str:
+        worktree = Path(spec.path)
+        diff_stat = cls._git("diff", "--stat", spec.base_revision, cwd=worktree)
+        untracked = cls._git("ls-files", "--others", "--exclude-standard", cwd=worktree)
+        parts = [part for part in (diff_stat, untracked) if part]
+        return "\n".join(parts)
+
+    @staticmethod
+    def _git_binary(*args: str, cwd: Path, input_data: bytes | None = None) -> bytes:
+        try:
+            completed = subprocess.run(
+                ["git", *args],
+                cwd=str(cwd),
+                input=input_data,
+                capture_output=True,
+                timeout=30,
+                check=False,
+            )
+        except (OSError, subprocess.SubprocessError) as exc:
+            raise WorktreeError(f"Unable to run git: {exc}") from exc
+        if completed.returncode != 0:
+            detail = (completed.stderr or completed.stdout).decode("utf-8", errors="replace").strip()
+            raise WorktreeError(detail or f"git {' '.join(args)} failed")
+        return completed.stdout
+
+    def apply(self, spec: WorktreeSpec) -> WorktreeApplyResult:
+        """Apply an isolated worktree's unstaged result to a clean main worktree."""
+        repository = Path(spec.repository)
+        worktree = Path(spec.path)
+        if not self.is_clean(repository):
+            raise WorktreeError(
+                "The target workspace changed after the subagent started. "
+                "Commit or stash those changes before applying the task result."
+            )
+        target_revision = self._git("rev-parse", "HEAD", cwd=repository)
+        if target_revision != spec.base_revision:
+            raise WorktreeError(
+                "The target branch advanced after the subagent started. "
+                "Review or rebase the task worktree before applying it."
+            )
+
+        tracked, untracked = self.changed_paths(spec)
+        if not tracked and not untracked:
+            raise WorktreeError("The subagent worktree contains no changes to apply.")
+
+        for relative in untracked:
+            destination = repository / relative
+            if destination.exists():
+                raise WorktreeError(
+                    f"Refusing to overwrite an existing untracked path: {destination}"
+                )
+
+        patch = self._git_binary(
+            "diff", "--binary", spec.base_revision, cwd=worktree
+        )
+        if patch:
+            self._git_binary("apply", "--check", "-", cwd=repository, input_data=patch)
+
+        copied: list[Path] = []
+        patch_applied = False
+        try:
+            if patch:
+                self._git_binary("apply", "-", cwd=repository, input_data=patch)
+                patch_applied = True
+            for relative in untracked:
+                source = worktree / relative
+                destination = repository / relative
+                if source.is_symlink():
+                    raise WorktreeError(f"Refusing to copy an untracked symlink: {source}")
+                destination.parent.mkdir(parents=True, exist_ok=True)
+                shutil.copy2(source, destination)
+                copied.append(destination)
+        except Exception:
+            for destination in reversed(copied):
+                if destination.exists():
+                    destination.unlink()
+            if patch_applied:
+                self._git_binary("apply", "--reverse", "-", cwd=repository, input_data=patch)
+            raise
+
+        paths = tuple(dict.fromkeys([*tracked, *untracked]))
+        return WorktreeApplyResult(paths, tracked, untracked)
+
+    def changed_paths(self, spec: WorktreeSpec) -> tuple[tuple[str, ...], tuple[str, ...]]:
+        worktree = Path(spec.path)
+        tracked_text = self._git(
+            "diff", "--name-only", spec.base_revision, cwd=worktree
+        )
+        tracked = tuple(path for path in tracked_text.splitlines() if path)
+        untracked_text = self._git(
+            "ls-files", "--others", "--exclude-standard", cwd=worktree
+        )
+        untracked = tuple(path for path in untracked_text.splitlines() if path)
+        return tracked, untracked

aria_code/runway_video_client.py

@@ -0,0 +1,4 @@
+"""Compatibility import for :mod:`clients.runway_video_client`."""
+from importlib import import_module as _import_module
+import sys as _sys
+_sys.modules[__name__] = _import_module("clients.runway_video_client")

aria_code/safety/__init__.py

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