aria-code 0.167.0__py3-none-win_amd64.whl

aria_code/apps/cli/tool_registry.py

@@ -0,0 +1,34 @@
+"""Owns the tool registries that aria_cli populates at import.
+
+LOCAL_TOOLS, LOCAL_TOOL_SCHEMAS and ARIA_TOOLS were declared in aria_cli.py, so
+five command mixins reached into a 6800-line module to ask what tools exist —
+every one of them read-only: len(), `in`, .items(), one lookup. Registration
+still happens in aria_cli, which is where the tool functions and their optional
+imports live; what moved is *ownership of the containers*.
+
+They are populated in place (update/extend), never rebound. That matters: a
+`LOCAL_TOOLS = {...}` anywhere would leave this module's dict empty while the
+CLI filled a different one, and every reader here would silently see no tools.
+The same failure the response cache and the tool-result cache each had.
+
+This is also the first piece the durable runtime needs. A registry that exists
+only as a global in whichever process imported aria_cli cannot be reconstructed
+by a worker resuming a task somewhere else. Giving it its own module does not
+make it per-session — that decision is still open — but it stops the CLI module
+from being the only place it can live.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Callable
+
+__all__ = ["LOCAL_TOOLS", "LOCAL_TOOL_SCHEMAS", "ARIA_TOOLS"]
+
+# name -> (callable, human description)
+LOCAL_TOOLS: dict[str, tuple[Callable[..., Any], str]] = {}
+
+# OpenAI-style function schemas for the local tools above.
+LOCAL_TOOL_SCHEMAS: list[dict[str, Any]] = []
+
+# (name, description) for tools served by the Arthera backend.
+ARIA_TOOLS: list[tuple[str, str]] = []

aria_code/apps/cli/tool_scope.py

@@ -0,0 +1,113 @@
+"""Which tools a turn is offered — for every provider, not just Ollama.
+
+The gap this closes
+-------------------
+The pack contract has three contributions: handlers, a prompt fragment, and
+*tools*.  Two of them were wired.  ``active_tool_names()`` was written, exported
+and never called by anything, so the third was inert: every turn on every
+provider was offered every registered tool.
+
+Concretely, a request to fix a failing test reached Gemini carrying all 74 tool
+schemas, 34 of them domain tools — market quotes, broker orders, backtests,
+Stripe analysis, freight reconciliation.  That is the same shape as the system
+prompt only reaching Ollama: a decision the architecture already knew how to
+make, not applied on the path that matters most.
+
+Why it matters beyond context size
+----------------------------------
+Wasted context is the smaller cost.  The real one is that a tool in the list is
+a tool the model may call, and the incident the pack contract exists to prevent
+— a question about this repository answered with a MongoDB stock quote — is
+exactly a domain tool firing on a message that named nothing in its domain.
+Leaving all 34 in view on every coding turn keeps that door open.
+
+The rule
+--------
+A domain tool is offered only when its pack has claimed the message.  Anything
+no pack claims is core and always available, which makes the default safe:
+adding a tool nobody assigns to a domain keeps working exactly as before, and
+the burden is on a domain to say "this one is mine".
+"""
+
+from __future__ import annotations
+
+from typing import Iterable, Optional, Sequence
+
+__all__ = ["domain_tool_names", "select_tool_schemas"]
+
+
+def _schema_name(schema: dict) -> str:
+    return str((schema.get("function") or schema).get("name") or "")
+
+
+def domain_tool_names() -> frozenset[str]:
+    """Every tool claimed by some pack, whether or not that pack is active.
+
+    Membership here is what makes a tool *gateable*. A tool absent from this
+    set is core and always offered.
+    """
+    claimed: set[str] = set()
+    try:
+        from aria_code.packs import load_builtin_packs, registered_packs
+
+        load_builtin_packs()
+        for pack in registered_packs():
+            try:
+                claimed.update(str(name) for name in (pack.tool_names() or ()))
+            except Exception:
+                continue
+    except Exception:
+        return frozenset()
+    return frozenset(claimed)
+
+
+def select_tool_schemas(
+    schemas: Sequence[dict],
+    message: str,
+    *,
+    always: Iterable[str] = (),
+    activations: Optional[Sequence] = None,
+    allow_social_tools: bool = False,
+) -> list[dict]:
+    """The schemas to offer for *message*.
+
+    Standalone social messages need no tools. Otherwise core tools always;
+    a domain tool only while its pack has claimed the
+    message. ``always`` forces specific names in regardless — for a caller that
+    knows this turn needs one (a slash command that resolved to a tool, a
+    subagent handed a narrowed brief).
+
+    Degrades to the full list on any failure. Offering too many tools is a
+    tax; offering too few silently removes a capability, and between the two
+    the tax is the safer default.
+    """
+    all_schemas = list(schemas or [])
+    always = tuple(always)
+    if not all_schemas:
+        return all_schemas
+    from aria_code.apps.cli.conversation_policy import is_conversation_only_message
+
+    if is_conversation_only_message(message) and not always and not allow_social_tools:
+        return []
+
+    # One try around the whole decision. domain_tool_names() sat outside it,
+    # so a failure there propagated instead of degrading — the docstring
+    # promised a safe fallback the code did not deliver on that path.
+    try:
+        gateable = domain_tool_names()
+        if not gateable:
+            return all_schemas
+
+        from aria_code.packs import activate_packs, active_tool_names
+
+        active = activations if activations is not None else activate_packs(message or "")
+        permitted = set(active_tool_names(active))
+    except Exception:
+        return all_schemas
+
+    permitted.update(str(name) for name in always if name)
+
+    return [
+        schema for schema in all_schemas
+        if (name := _schema_name(schema)) not in gateable or name in permitted
+    ]

aria_code/apps/cli/tools/__init__.py

@@ -0,0 +1,40 @@
+"""apps/cli/tools — stateless tool implementations extracted from aria_cli.py."""
+from .file_tools import tool_read_file, tool_list_files, tool_search_code, tool_glob
+from .context import ToolContext
+from .system_tools import tool_run_command, tool_web_fetch, tool_github
+from .notebook_tools import (
+    tool_glob as tool_glob_nb,
+    tool_notebook_read,
+    tool_notebook_edit,
+)
+from .market_tools import (
+    tool_get_market_data,
+    tool_get_market_history,
+    tool_broker_query,
+    tool_broker_order,
+)
+from .write_tools import tool_write_file, tool_edit_file
+
+__all__ = [
+    "ToolContext",
+    # file tools (stateless)
+    "tool_read_file",
+    "tool_list_files",
+    "tool_search_code",
+    "tool_glob",
+    # write / edit tools (use lazy imports to avoid circular dep)
+    "tool_write_file",
+    "tool_edit_file",
+    # system tools
+    "tool_run_command",
+    "tool_web_fetch",
+    "tool_github",
+    # notebook tools
+    "tool_notebook_read",
+    "tool_notebook_edit",
+    # market / broker tools
+    "tool_get_market_data",
+    "tool_get_market_history",
+    "tool_broker_query",
+    "tool_broker_order",
+]

aria_code/apps/cli/tools/context.py

@@ -0,0 +1,46 @@
+"""ToolContext — dependency bundle for tools that need write/display state."""
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import TYPE_CHECKING, Any
+
+from aria_code.apps.cli.config_paths import resolve_config_dir
+
+if TYPE_CHECKING:
+    from rich.console import Console
+
+
+@dataclass
+class ToolContext:
+    """Passed to write-capable tools so they don't need aria_cli.py globals.
+
+    Instantiate once in ``ArtheraTerminal.__init__`` and share via reference:
+
+        self._tool_ctx = ToolContext(
+            console=console,
+            has_rich=HAS_RICH,
+            write_policy=_ACTIVE_WRITE_POLICY,
+            change_store=GLOBAL_CHANGE_STORE,
+            config_dir=CONFIG_DIR,
+            sessions_dir=SESSIONS_DIR,
+        )
+    """
+    console: "Console | None" = None
+    has_rich: bool = True
+    write_policy: list[str] = field(default_factory=lambda: ["desktop_only"])
+    change_store: Any = None   # GLOBAL_CHANGE_STORE
+    config_dir: Path = field(default_factory=resolve_config_dir)
+    sessions_dir: Path = field(default_factory=lambda: resolve_config_dir() / "sessions")
+
+    # ── helpers ──────────────────────────────────────────────────────
+    def print(self, *args, **kwargs) -> None:
+        if self.has_rich and self.console is not None:
+            self.console.print(*args, **kwargs)
+        else:
+            import builtins
+            builtins.print(*args)
+
+    @property
+    def policy(self) -> str:
+        return self.write_policy[0] if self.write_policy else "desktop_only"

aria_code/apps/cli/tools/file_tools.py

@@ -0,0 +1,181 @@
+"""Stateless file / code search tools — thin wrappers around WorkspaceFiles.
+
+These functions are pure: they take a params dict, call _get_workspace_files(), and
+return a result dict. No console/HAS_RICH/write-policy state involved.
+
+They are registered in aria_cli.py's execute_aria_tool dispatch table via:
+
+    from aria_code.apps.cli.tools.file_tools import tool_read_file, tool_list_files, ...
+
+    "read_file":   tool_read_file,
+    "list_files":  tool_list_files,
+    "search_code": tool_search_code,
+    "glob":        tool_glob,
+"""
+
+from __future__ import annotations
+
+import pathlib
+import sys
+import os
+
+# WorkspaceFiles lives at the aria-code root; insert it when running tests
+_ROOT = pathlib.Path(__file__).parent.parent.parent.parent  # aria-code/
+if str(_ROOT) not in sys.path:
+    sys.path.insert(0, str(_ROOT))
+
+from aria_code.workspace import WorkspaceFiles  # noqa: E402
+from aria_code.workspace.files import WorkspaceSecurity
+import os
+
+def _get_workspace_files(params=None):
+    """Reads for the local CLI: cwd, home, and the temp dirs.
+
+    ``allow_home=False`` used to be hardcoded here to "force restrict to the
+    current directory". It does not do that. WorkspaceSecurity only appends the
+    temp roots on the allow_home branch, so the flag additionally removed /tmp
+    and /var/folders — and since Python's tempfile lives under /var/folders on
+    macOS, the CLI could write a file into its own scratch directory and then
+    be denied reading it back.
+
+    Confinement for remote workers is the same documented mechanism used
+    everywhere else: ARIA_RUNTIME_SCOPE=remote, which Dockerfile.review sets.
+    Leaving the flag unset here honours it without disabling the local paths.
+    """
+    security = WorkspaceSecurity.from_tool_params(params or {})
+    return WorkspaceFiles(security=security)
+
+
+
+def tool_read_file(params: dict) -> dict:
+    """Read file contents with optional line range."""
+    path = params.get("path", "")
+    if not path:
+        return {"success": False, "error": "Missing 'path' parameter"}
+    try:
+        offset = int(params.get("offset", 0) or 0)
+        limit  = int(params.get("limit",  0) or 0)
+        if not offset and not limit:
+            limit = 160
+        result = _get_workspace_files(params).read_file(path, offset=offset, limit=limit)
+        content = result.content
+        if limit and result.lines >= limit and "use offset/limit to read more" not in content:
+            content += "\n... [default read limit applied — use offset/limit to read more]"
+        return {"success": True, "data": {
+            "path":    result.path,
+            "lines":   result.lines,
+            "content": content,
+        }}
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+def tool_list_files(params: dict) -> dict:
+    """List files in a directory, optionally matching a glob pattern."""
+    path    = params.get("path", ".")
+    pattern = params.get("pattern", "*")
+    try:
+        data = _get_workspace_files(params).list_files(path, pattern)
+        return {"success": True, "data": {
+            "path":    data["path"],
+            "pattern": data["pattern"],
+            "count":   data["count"],
+            "items":   data["items"],
+        }}
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+def tool_search_code(params: dict) -> dict:
+    """Search for a pattern in files (like grep)."""
+    pattern   = params.get("pattern", "")
+    path      = params.get("path", ".")
+    file_glob = params.get("glob", "**/*.py")
+    if not pattern:
+        return {"success": False, "error": "Missing 'pattern' parameter"}
+    try:
+        data = _get_workspace_files(params).search_code(pattern, path, file_glob)
+        return {"success": True, "data": {
+            "pattern": data["pattern"],
+            "path":    data["path"],
+            "count":   data["count"],
+            "matches": data["matches"],
+        }}
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+def tool_glob(params: dict) -> dict:
+    """Fast file-pattern search (supports ** recursive globs).
+
+    Returns a flat sorted list of matching file paths up to *limit* entries.
+    """
+    pattern = params.get("pattern", "**/*")
+    root    = (params.get("path", ".") or ".").strip()
+    limit   = min(int(params.get("limit", 200)), 1000)
+    try:
+        security = WorkspaceSecurity.from_tool_params(params)
+        p = security.require_safe(root)
+        if not p.is_dir():
+            return {"success": False, "error": f"Directory not found: {p}"}
+        results = sorted(
+            str(fp.relative_to(p) if fp.is_relative_to(p) else fp)
+            for fp in p.glob(pattern)
+            if fp.is_file() and security.is_safe_path(fp)
+        )[:limit]
+        return {"success": True, "data": {
+            "pattern": pattern,
+            "root":    str(p),
+            "count":   len(results),
+            "files":   results,
+        }}
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+def tool_lsp_hover(params: dict) -> dict:
+    """Get hover documentation (LSP) for a symbol at a specific line and column."""
+    path = params.get("path", "")
+    line = params.get("line", 1)
+    col = params.get("col", 1)
+    if not path:
+        return {"success": False, "error": "Missing 'path' parameter"}
+    try:
+        from aria_code.runtime.lsp import get_hover
+        res = get_hover(path, int(line), int(col))
+        if not res:
+            return {"success": False, "error": f"No hover info available at {path}:{line}:{col} (Is the language server installed?)"}
+        return {"success": True, "data": {"hover": res}}
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+def tool_lsp_definition(params: dict) -> dict:
+    """Get definition locations (LSP) for a symbol at a specific line and column."""
+    path = params.get("path", "")
+    line = params.get("line", 1)
+    col = params.get("col", 1)
+    if not path:
+        return {"success": False, "error": "Missing 'path' parameter"}
+    try:
+        from aria_code.runtime.lsp import get_definition
+        res = get_definition(path, int(line), int(col))
+        if not res:
+            return {"success": False, "error": f"No definitions found at {path}:{line}:{col} (Is the language server installed?)"}
+        return {"success": True, "data": {"definitions": res}}
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+def tool_lsp_references(params: dict) -> dict:
+    """Get all references (LSP) for a symbol at a specific line and column."""
+    path = params.get("path", "")
+    line = params.get("line", 1)
+    col = params.get("col", 1)
+    if not path:
+        return {"success": False, "error": "Missing 'path' parameter"}
+    try:
+        from aria_code.runtime.lsp import get_references
+        res = get_references(path, int(line), int(col))
+        if not res:
+            return {"success": False, "error": f"No references found at {path}:{line}:{col} (Is the language server installed?)"}
+        return {"success": True, "data": {"references": res}}
+    except Exception as e:
+        return {"success": False, "error": str(e)}