aria-code 0.52.0__py3-none-any.whl

aria_code/packages/aria_core/manifest.py

@@ -0,0 +1,65 @@
+"""Shared manifest types for agents, tools, skills, and package bridges."""
+
+from __future__ import annotations
+
+from dataclasses import asdict, dataclass, field
+from enum import Enum
+from typing import Any, Dict, List, Optional
+
+
+class PermissionLevel(str, Enum):
+    READ_ONLY = "read_only"
+    WORKSPACE_WRITE = "workspace_write"
+    NETWORK = "network"
+    BROKER_READ = "broker_read"
+    BROKER_TRADE = "broker_trade"
+    FULL_ACCESS = "full_access"
+
+
+class ServiceKind(str, Enum):
+    AGENT = "agent"
+    TOOL = "tool"
+    SKILL = "skill"
+    MCP = "mcp"
+    SERVICE = "service"
+    DATA = "data"
+    INFRA = "infra"
+
+
+@dataclass(frozen=True)
+class PackageLink:
+    """Optional link to an implementation package or external service."""
+
+    package: str
+    module: str = ""
+    object_name: str = ""
+    transport: str = "python"
+    optional: bool = True
+    notes: str = ""
+
+    def to_dict(self) -> Dict[str, Any]:
+        return asdict(self)
+
+
+@dataclass(frozen=True)
+class CapabilityManifest:
+    """Stable capability description used by registries and MCP exposure."""
+
+    name: str
+    kind: ServiceKind
+    description: str
+    capabilities: List[str] = field(default_factory=list)
+    permissions: List[PermissionLevel] = field(default_factory=list)
+    required_services: List[str] = field(default_factory=list)
+    input_schema: Dict[str, Any] = field(default_factory=dict)
+    output_schema: Dict[str, Any] = field(default_factory=dict)
+    package_link: Optional[PackageLink] = None
+    tags: List[str] = field(default_factory=list)
+
+    def to_dict(self) -> Dict[str, Any]:
+        data = asdict(self)
+        data["kind"] = self.kind.value
+        data["permissions"] = [p.value for p in self.permissions]
+        if self.package_link:
+            data["package_link"] = self.package_link.to_dict()
+        return data

aria_code/packages/aria_core/paths.py

@@ -0,0 +1,57 @@
+"""用户状态目录的唯一解析入口。
+
+2026-08-19 起因：本仓库有三个并存的用户状态目录，同一个用户的数据被拆散在
+不同地方：
+
+    ~/.arthera/     169MB —— providers.json(API keys) / brokers.json(券商凭证)
+                              / portfolio.db / sessions / memory / models …
+    ~/.aria/        —— daemon.db / datasources.yaml / providers.yaml / task_ledger
+    ~/.aria-code/   —— resolve_config_dir() 给新用户的默认目录
+
+``apps/cli/config_paths.resolve_config_dir()`` 已经做了正确的事：认
+``ARIA_HOME``，老用户(存在 ~/.arthera)沿用旧目录，新用户落到 ~/.aria-code。
+问题是**只有配置文件走了那一层**——另外 38 个文件直接写死
+``Path.home() / ".arthera"``，绕过了它。后果是一个全新用户的 config.json 会
+落在 ~/.aria-code/，而他的 API key 和券商凭证会被写进 ~/.arthera/：两个目录，
+同一个用户。这不是命名审美问题，是状态管理缺陷。
+
+本模块把那套优先级抽成所有层都能 import 的单一实现：
+
+    ARIA_HOME 环境变量  >  已存在的 ~/.arthera(老用户，不迁移)  >  ~/.aria-code
+
+放在 packages/aria_core 而不是 apps/cli，是因为调用方横跨 runtime/、brokers/、
+packages/、datasources/、tools/ —— 让这些层反向 import apps/cli 是分层倒置。
+本模块只依赖 stdlib，任何层都能安全引入。
+
+⚠️ 对既有用户零影响：只要 ~/.arthera 存在，aria_home() 就返回它，行为与硬编码
+时完全一致，不会移动任何文件。变化只对全新安装生效——所有状态统一落在一个
+目录里。真正的数据迁移(把 ~/.arthera 搬到 ~/.aria-code)是另一件事，需要显式
+的用户确认，不在本模块职责内。
+"""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+__all__ = ["aria_home", "LEGACY_HOME_NAME", "DEFAULT_HOME_NAME"]
+
+LEGACY_HOME_NAME = ".arthera"
+DEFAULT_HOME_NAME = ".aria-code"
+
+
+def aria_home() -> Path:
+    """返回用户状态根目录。不创建目录——由调用方按需 mkdir。
+
+    优先级与 apps/cli/config_paths.resolve_config_dir() 保持一致；那个函数现在
+    委托到这里，避免两处各自演化。
+    """
+    override = os.environ.get("ARIA_HOME")
+    if override:
+        return Path(override).expanduser()
+
+    legacy = Path.home() / LEGACY_HOME_NAME
+    if legacy.exists():
+        return legacy
+
+    return Path.home() / DEFAULT_HOME_NAME

aria_code/packages/aria_core/secure_file.py

@@ -0,0 +1,68 @@
+"""Write files that hold secrets with owner-only permissions.
+
+Three files in this tree hold credentials and every one of them was written
+with the process umask — typically 0644, i.e. readable by every other account
+on the machine:
+
+  ~/.arthera/brokers.json    brokerage passwords, api_secret, access_token
+  ~/.arthera/providers.json  LLM provider API keys
+  <config_dir>/config.json   auth_token and refresh_token from /login
+
+The repo already knew to do better: model_cmds.py chmods a generated .env to
+0600. The file holding the credentials that can move money was the one without
+it.
+
+chmod after create still leaves a window where the file exists with the default
+mode, so this opens with O_CREAT|O_EXCL at 0600 where it can, and falls back to
+write-then-chmod on an existing file. Permissions are a no-op on Windows, where
+the ACL inherited from the user profile directory governs instead — that is
+why failure to chmod is not fatal here.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import stat
+from pathlib import Path
+from typing import Any
+
+__all__ = ["write_secret_text", "write_secret_json", "harden_existing"]
+
+_OWNER_ONLY = stat.S_IRUSR | stat.S_IWUSR  # 0o600
+
+
+def harden_existing(path: Path) -> None:
+    """Restrict an existing file to the owner. Never raises."""
+    try:
+        os.chmod(path, _OWNER_ONLY)
+    except (OSError, NotImplementedError):  # pragma: no cover - platform dependent
+        pass
+
+
+def write_secret_text(path: Path, text: str, *, encoding: str = "utf-8") -> None:
+    """Write *text* to *path* with 0600, creating the parent directory."""
+    path = Path(path)
+    path.parent.mkdir(parents=True, exist_ok=True)
+
+    # Create at the right mode rather than fixing it afterwards, so the content
+    # is never briefly world-readable.
+    if not path.exists():
+        try:
+            fd = os.open(path, os.O_CREAT | os.O_EXCL | os.O_WRONLY, _OWNER_ONLY)
+        except FileExistsError:
+            pass  # raced with someone else; fall through to the normal path
+        else:
+            with os.fdopen(fd, "w", encoding=encoding) as handle:
+                handle.write(text)
+            return
+
+    path.write_text(text, encoding=encoding)
+    harden_existing(path)
+
+
+def write_secret_json(path: Path, payload: Any, **dumps_kwargs: Any) -> None:
+    """json.dump *payload* to *path* with 0600."""
+    dumps_kwargs.setdefault("indent", 2)
+    dumps_kwargs.setdefault("ensure_ascii", False)
+    write_secret_text(Path(path), json.dumps(payload, **dumps_kwargs))

aria_code/packages/aria_infra/__init__.py

@@ -0,0 +1,15 @@
+"""Infrastructure helpers and external package discovery."""
+
+from .arthera import ArtheraPackageMap, discover_arthera_packages
+from .doctor import CheckResult, PackageDoctorReport, build_package_doctor_report
+from .product import ProductIdentity, aria_code_identity
+
+__all__ = [
+    "ArtheraPackageMap",
+    "CheckResult",
+    "PackageDoctorReport",
+    "ProductIdentity",
+    "aria_code_identity",
+    "build_package_doctor_report",
+    "discover_arthera_packages",
+]

aria_code/packages/aria_infra/arthera.py

@@ -0,0 +1,52 @@
+"""Optional discovery for the sibling Arthera monorepo packages."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Dict, List, Optional
+
+
+@dataclass(frozen=True)
+class ArtheraPackageMap:
+    root: Path
+    available: bool
+    packages: Dict[str, Path] = field(default_factory=dict)
+    mcp_servers: List[Path] = field(default_factory=list)
+    tool_dirs: List[Path] = field(default_factory=list)
+
+    def to_dict(self) -> dict:
+        return {
+            "root": str(self.root),
+            "available": self.available,
+            "packages": {name: str(path) for name, path in self.packages.items()},
+            "mcp_servers": [str(path) for path in self.mcp_servers],
+            "tool_dirs": [str(path) for path in self.tool_dirs],
+        }
+
+
+def discover_arthera_packages(root: Optional[Path] = None) -> ArtheraPackageMap:
+    """Discover useful Arthera package entrypoints without importing them."""
+
+    root = (root or Path.home() / "Desktop" / "Arthera" / "packages").expanduser()
+    if not root.exists():
+        return ArtheraPackageMap(root=root, available=False)
+
+    names = ["contracts", "data", "ml", "monitoring", "quant_engine", "reporting"]
+    packages = {name: root / name for name in names if (root / name).exists()}
+    mcp_servers = sorted(root.glob("**/mcp_server.py"))
+    tool_dirs = [
+        path for path in [
+            root / "quant_engine" / "tools",
+            root / "ml" / "llm" / "tools",
+            root / "ml" / "llm" / "skills",
+        ]
+        if path.exists()
+    ]
+    return ArtheraPackageMap(
+        root=root,
+        available=True,
+        packages=packages,
+        mcp_servers=mcp_servers,
+        tool_dirs=tool_dirs,
+    )

aria_code/packages/aria_infra/doctor.py

@@ -0,0 +1,246 @@
+"""Health checks for Aria Code package bridges."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any, Dict, Iterable, List
+
+from aria_code.packages.aria_infra.arthera import ArtheraPackageMap
+
+
+@dataclass(frozen=True)
+class CheckResult:
+    name: str
+    status: str
+    detail: str = ""
+    remediation: str = ""
+
+    def to_dict(self) -> Dict[str, str]:
+        return {
+            "name": self.name,
+            "status": self.status,
+            "detail": self.detail,
+            "remediation": self.remediation,
+        }
+
+
+@dataclass(frozen=True)
+class PackageDoctorReport:
+    status: str
+    checks: List[CheckResult] = field(default_factory=list)
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "status": self.status,
+            "checks": [check.to_dict() for check in self.checks],
+        }
+
+
+def _overall_status(checks: List[CheckResult]) -> str:
+    if any(check.status == "fail" for check in checks):
+        return "fail"
+    if any(check.status == "warn" for check in checks):
+        return "warn"
+    return "ok"
+
+
+def _status_value(value: Any) -> str:
+    if hasattr(value, "value"):
+        return str(value.value)
+    return str(value)
+
+
+def build_package_doctor_report(
+    *,
+    arthera: ArtheraPackageMap,
+    mcp_status: Dict[str, Any],
+    tool_count: int,
+    manifest_can_export: bool,
+    manifest_path: Path,
+    services: Iterable[Any] = (),
+    required_services: Iterable[str] = (),
+    architecture_layers: Iterable[Any] = (),
+    required_architecture_layers: Iterable[str] = (),
+    provider_health: Iterable[Dict[str, Any]] = (),
+) -> PackageDoctorReport:
+    """Build package bridge health checks without doing I/O."""
+
+    checks: List[CheckResult] = []
+    checks.append(CheckResult(
+        "product_identity",
+        "ok",
+        "Aria Code is registered as an Arthera product.",
+    ))
+
+    service_names = {
+        getattr(service, "name", "")
+        for service in services
+        if getattr(service, "name", "")
+    }
+    missing_required = sorted(set(required_services) - service_names)
+    if service_names and not missing_required:
+        checks.append(CheckResult(
+            "service_boundaries",
+            "ok",
+            f"{len(service_names)} service manifests registered.",
+        ))
+    elif missing_required:
+        checks.append(CheckResult(
+            "service_boundaries",
+            "fail",
+            f"Missing required services: {', '.join(missing_required)}.",
+            "Register service specs in packages.aria_services.",
+        ))
+    else:
+        checks.append(CheckResult(
+            "service_boundaries",
+            "warn",
+            "No service manifests registered yet.",
+            "Add Gateway/Data/Reports/Brokers service specs.",
+        ))
+
+    architecture_rows = list(architecture_layers or [])
+    required_layer_names = set(required_architecture_layers or [])
+    if architecture_rows or required_layer_names:
+        layer_names = {
+            getattr(layer, "name", "")
+            for layer in architecture_rows
+            if getattr(layer, "name", "")
+        }
+        missing_layers = sorted(required_layer_names - layer_names)
+        if missing_layers:
+            checks.append(CheckResult(
+                "architecture_layers",
+                "fail",
+                f"Missing architecture layers: {', '.join(missing_layers)}.",
+                "Update packages.aria_core.architecture.",
+            ))
+        else:
+            incomplete = [
+                getattr(layer, "name", "")
+                for layer in architecture_rows
+                if _status_value(getattr(layer, "status", "")).lower() != "done"
+            ]
+            if incomplete:
+                checks.append(CheckResult(
+                    "architecture_layers",
+                    "warn",
+                    f"{len(layer_names)} layers registered; incomplete: {', '.join(incomplete[:6])}.",
+                    "Prioritize context, settings, runtime, safety, and channel extraction.",
+                ))
+            else:
+                checks.append(CheckResult(
+                    "architecture_layers",
+                    "ok",
+                    f"{len(layer_names)} architecture layers complete.",
+                ))
+
+    provider_rows = list(provider_health or [])
+    if not provider_rows:
+        checks.append(CheckResult(
+            "data_provider_health",
+            "warn",
+            "No provider calls recorded in this session.",
+            "Run /quote, /ta, /analyze, or /report first.",
+        ))
+    else:
+        unhealthy = [
+            row for row in provider_rows
+            if row.get("status") not in ("ok", "", None)
+        ]
+        if unhealthy:
+            checks.append(CheckResult(
+                "data_provider_health",
+                "warn",
+                "; ".join(
+                    f"{row.get('provider')}={row.get('status')}"
+                    for row in unhealthy[:5]
+                ),
+                "Wait for cooldown, retry later, or switch provider/API key.",
+            ))
+        else:
+            checks.append(CheckResult(
+                "data_provider_health",
+                "ok",
+                f"{len(provider_rows)} providers healthy.",
+            ))
+
+    if arthera.available:
+        checks.append(CheckResult(
+            "arthera_packages",
+            "ok",
+            f"Found {len(arthera.packages)} package groups at {arthera.root}.",
+        ))
+    else:
+        checks.append(CheckResult(
+            "arthera_packages",
+            "warn",
+            f"Not found at {arthera.root}.",
+            "Place Arthera at ~/Desktop/Arthera or configure the MCP server manually.",
+        ))
+
+    if mcp_status.get("configured"):
+        checks.append(CheckResult(
+            "mcp_config",
+            "ok",
+            f"Configured in {mcp_status.get('config_path')}.",
+        ))
+    else:
+        checks.append(CheckResult(
+            "mcp_config",
+            "warn",
+            f"No arthera_quant_engine server in {mcp_status.get('config_path')}.",
+            "Run /packages connect arthera.",
+        ))
+
+    if mcp_status.get("server_file_exists"):
+        checks.append(CheckResult(
+            "mcp_server_file",
+            "ok",
+            str(mcp_status.get("server_path") or ""),
+        ))
+    else:
+        checks.append(CheckResult(
+            "mcp_server_file",
+            "warn",
+            str(mcp_status.get("server_path") or "server path unavailable"),
+            "Verify <ARTHERA_ROOT>/packages/quant_engine/mcp_server.py exists (set ARTHERA_ROOT env var).",
+        ))
+
+    if mcp_status.get("running"):
+        checks.append(CheckResult(
+            "mcp_runtime",
+            "ok",
+            f"Running with {mcp_status.get('tool_count', 0)} tools.",
+        ))
+    else:
+        checks.append(CheckResult(
+            "mcp_runtime",
+            "warn",
+            "Arthera MCP server is not running.",
+            "Run /mcp reload or /packages connect arthera --reload.",
+        ))
+
+    if tool_count > 0:
+        checks.append(CheckResult(
+            "mcp_tool_manifests",
+            "ok",
+            f"{tool_count} Arthera MCP tools mapped to Aria manifests.",
+        ))
+    else:
+        checks.append(CheckResult(
+            "mcp_tool_manifests",
+            "warn",
+            "No Arthera MCP tools mapped yet.",
+            "Start the MCP server, then run /packages tools arthera.",
+        ))
+
+    checks.append(CheckResult(
+        "manifest_export",
+        "ok" if manifest_can_export else "fail",
+        str(manifest_path),
+        "" if manifest_can_export else "Check artifact directory permissions.",
+    ))
+
+    return PackageDoctorReport(status=_overall_status(checks), checks=checks)

aria_code/packages/aria_infra/product.py

@@ -0,0 +1,40 @@
+"""Product identity for Aria Code inside the Arthera product line."""
+
+from __future__ import annotations
+
+from dataclasses import asdict, dataclass
+from typing import Dict, List
+
+
+@dataclass(frozen=True)
+class ProductIdentity:
+    company: str
+    product: str
+    package_name: str
+    version: str
+    description: str
+    product_family: List[str]
+
+    def to_dict(self) -> Dict[str, object]:
+        return asdict(self)
+
+
+def aria_code_identity(version: str = "3.0.0") -> ProductIdentity:
+    return ProductIdentity(
+        company="Arthera",
+        product="Aria Code",
+        package_name="aria-code",
+        version=version,
+        description=(
+            "Local-first product review and coding agent by Arthera, "
+            "with optional quantitative research capabilities."
+        ),
+        product_family=[
+            "Aria Code",
+            "Aria Gateway",
+            "Arthera Quant Engine",
+            "Arthera Broker Bridge",
+            "Arthera ML/LLM",
+            "Arthera Reporting",
+        ],
+    )

aria_code/packages/aria_mcp/__init__.py

@@ -0,0 +1,25 @@
+"""MCP bridge facade."""
+
+from .bridge import MCPExposure, default_exposures
+from .config import (
+    arthera_quant_engine_server_config,
+    find_server_config,
+    load_mcp_config,
+    merge_server_config,
+    mcp_server_status,
+    write_mcp_config,
+)
+from .tools import mcp_tool_to_spec, mcp_tools_to_specs
+
+__all__ = [
+    "MCPExposure",
+    "arthera_quant_engine_server_config",
+    "default_exposures",
+    "find_server_config",
+    "load_mcp_config",
+    "merge_server_config",
+    "mcp_server_status",
+    "mcp_tool_to_spec",
+    "mcp_tools_to_specs",
+    "write_mcp_config",
+]