aria-code 4.1.3__py3-none-any.whl

packages/aria_core/export.py

@@ -0,0 +1,124 @@
+"""Manifest export helpers for Aria package facades."""
+
+from __future__ import annotations
+
+import json
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Dict, Iterable, List, Optional
+
+
+def _manifest_dicts(items: Iterable[Any]) -> List[Dict[str, Any]]:
+    out: List[Dict[str, Any]] = []
+    for item in items:
+        if hasattr(item, "manifest"):
+            item = item.manifest()
+        if hasattr(item, "to_dict"):
+            out.append(item.to_dict())
+        elif isinstance(item, dict):
+            out.append(dict(item))
+    return out
+
+
+def build_package_manifest(
+    *,
+    identity: Any,
+    tools: Iterable[Any],
+    agents: Iterable[Any],
+    skills: Iterable[Any],
+    mcp_exposures: Iterable[Any],
+    services: Iterable[Any] = (),
+    arthera_packages: Any = None,
+    arthera_mcp_tools: Iterable[Any] = (),
+) -> Dict[str, Any]:
+    """Build one JSON-serializable package manifest."""
+
+    return {
+        "schema_version": "aria.package-manifest.v1",
+        "generated_at": datetime.now(timezone.utc).isoformat(timespec="seconds").replace("+00:00", "Z"),
+        "product": identity.to_dict() if hasattr(identity, "to_dict") else identity,
+        "capabilities": {
+            "services": _manifest_dicts(services),
+            "tools": _manifest_dicts(tools),
+            "agents": _manifest_dicts(agents),
+            "skills": _manifest_dicts(skills),
+            "mcp_exposures": [
+                item.to_tool_descriptor() if hasattr(item, "to_tool_descriptor") else dict(item)
+                for item in mcp_exposures
+            ],
+            "arthera_mcp_tools": _manifest_dicts(arthera_mcp_tools),
+        },
+        "arthera_packages": (
+            arthera_packages.to_dict()
+            if hasattr(arthera_packages, "to_dict")
+            else arthera_packages
+        ),
+    }
+
+
+def build_session_diagnostic_bundle(
+    *,
+    session_id: str,
+    conversation: list,
+    config: Optional[dict] = None,
+    paths: Optional[dict] = None,
+    trace: Any = None,
+    provider_health: Optional[list] = None,
+    artifact_summary: Optional[dict] = None,
+) -> Dict[str, Any]:
+    """Build a stable export bundle for debugging and replay."""
+    config = dict(config or {})
+    redacted_config: Dict[str, Any] = {}
+    for key, value in config.items():
+        if any(token in key.lower() for token in ("key", "token", "secret", "password")):
+            if value:
+                redacted_config[key] = "***"
+        else:
+            redacted_config[key] = value
+
+    bundle: Dict[str, Any] = {
+        "schema": "aria.session_diagnostic_bundle.v1",
+        "generated_at": datetime.now(timezone.utc).isoformat(timespec="seconds").replace("+00:00", "Z"),
+        "session_id": session_id,
+        "conversation": list(conversation),
+        "conversation_count": len(conversation),
+        "config": redacted_config,
+    }
+    if paths:
+        bundle["paths"] = dict(paths)
+    if trace is not None:
+        try:
+            bundle["runtime_trace"] = trace.to_dict()
+        except Exception:
+            bundle["runtime_trace"] = {}
+    if provider_health is not None:
+        provider_rows = list(provider_health)
+        bundle["provider_health"] = provider_rows
+        try:
+            from packages.aria_services.provider_health import summarize_provider_health
+
+            bundle["provider_health_summary"] = summarize_provider_health(provider_rows).to_dict()
+        except Exception:
+            pass
+    if artifact_summary is not None:
+        bundle["artifact_summary"] = dict(artifact_summary)
+    else:
+        try:
+            from artifacts import artifact_summary as _artifact_summary
+
+            bundle["artifact_summary"] = _artifact_summary()
+        except Exception:
+            pass
+    try:
+        from packages.aria_core.architecture import architecture_contract
+
+        bundle["architecture"] = architecture_contract()
+    except Exception:
+        pass
+    return bundle
+
+
+def write_package_manifest(path: Path, manifest: Dict[str, Any]) -> Path:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(manifest, ensure_ascii=False, indent=2, default=str), encoding="utf-8")
+    return path

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

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",
+]

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,
+    )

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 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)

packages/aria_infra/product.py

@@ -0,0 +1,37 @@
+"""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 coding and quantitative research agent by Arthera.",
+        product_family=[
+            "Aria Code",
+            "Aria Gateway",
+            "Arthera Quant Engine",
+            "Arthera Broker Bridge",
+            "Arthera ML/LLM",
+            "Arthera Reporting",
+        ],
+    )

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",
+]

packages/aria_mcp/bridge.py

@@ -0,0 +1,38 @@
+"""Describe how Aria packages should be exposed over MCP."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Dict, List
+
+
+@dataclass(frozen=True)
+class MCPExposure:
+    name: str
+    target: str
+    description: str
+    read_only: bool = True
+
+    def to_tool_descriptor(self) -> Dict[str, object]:
+        return {
+            "name": self.name,
+            "description": self.description,
+            "target": self.target,
+            "read_only": self.read_only,
+        }
+
+
+def default_exposures() -> List[MCPExposure]:
+    """Initial MCP server surface for Aria Code.
+
+    These names are stable contracts. The server implementation can bind them
+    to ToolRegistry/AgentRegistry without changing client-facing tool names.
+    """
+
+    return [
+        MCPExposure("aria.market.quote", "tool:get_market_data", "Fetch quote and technical market snapshot."),
+        MCPExposure("aria.agent.team", "agent:team", "Run multi-agent financial research."),
+        MCPExposure("aria.report.generate", "skill:financial-research", "Generate a local research artifact.", read_only=False),
+        MCPExposure("aria.backtest.run", "skill:strategy-backtest", "Run a historical strategy simulation.", read_only=False),
+        MCPExposure("aria.artifacts.list", "infra:artifacts", "List local generated artifacts."),
+    ]