aria-code 4.1.3__py3-none-any.whl

notification_tools.py

@@ -0,0 +1,248 @@
+"""
+notification_tools.py — Aria Code push notification dispatcher.
+
+Channels (tried in order when configured):
+  1. macOS native notification  — always available on macOS, zero-config
+  2. Webhook                    — 企业微信/飞书/Slack/custom HTTP POST
+  3. Email (SMTP)               — opt-in, requires SMTP config
+
+Configuration (in ~/.arthera/config.json):
+    "notify_macos":  true                        # default true on macOS
+    "notify_webhook": "https://..."              # webhook URL
+    "notify_email":  {                           # optional SMTP
+        "smtp_host": "smtp.gmail.com",
+        "smtp_port": 587,
+        "username":  "you@gmail.com",
+        "password":  "...",                      # prefer SMTP_PASSWORD env var
+        "to":        "you@gmail.com"
+    }
+
+Usage:
+    from notification_tools import send_notification
+    send_notification("HSBC 触发预警", "现价 USD 79.5 已跌破目标 80.0")
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import os
+import platform
+import smtplib
+import subprocess
+from email.mime.text import MIMEText
+from pathlib import Path
+from typing import Optional
+from urllib import request as _urllib_request
+
+logger = logging.getLogger(__name__)
+
+_CONFIG_PATH = Path.home() / ".arthera" / "config.json"
+
+
+def _load_config() -> dict:
+    try:
+        if _CONFIG_PATH.exists():
+            return json.loads(_CONFIG_PATH.read_text(encoding="utf-8"))
+    except Exception:
+        pass
+    return {}
+
+
+# ── Channel implementations ──────────────────────────────────────────────────
+
+def _notify_macos(title: str, body: str) -> bool:
+    """Send a macOS Notification Center alert via osascript."""
+    if platform.system() != "Darwin":
+        return False
+    try:
+        script = (
+            f'display notification {json.dumps(body)} '
+            f'with title {json.dumps(title)} '
+            f'subtitle "Aria Code"'
+        )
+        result = subprocess.run(
+            ["osascript", "-e", script],
+            capture_output=True, timeout=5,
+        )
+        return result.returncode == 0
+    except Exception as e:
+        logger.debug("macOS notification failed: %s", e)
+        return False
+
+
+def _notify_webhook(url: str, title: str, body: str) -> bool:
+    """
+    POST to a webhook URL.  Auto-detects format:
+      - 企业微信机器人  (qyapi.weixin.qq.com)   → { msgtype: text, text: { content } }
+      - 飞书机器人      (open.feishu.cn)         → { msg_type: text, content: { text } }
+      - Slack           (hooks.slack.com)         → { text }
+      - 钉钉            (oapi.dingtalk.com)       → { msgtype: text, text: { content } }
+      - 其他                                      → { title, body }
+    """
+    try:
+        message = f"【{title}】\n{body}"
+        if "qyapi.weixin.qq.com" in url:
+            payload = {"msgtype": "text", "text": {"content": message}}
+        elif "open.feishu.cn" in url or "feishu" in url or "larksuite.com" in url:
+            # 飞书交互卡片：带颜色标题 + Markdown 正文
+            color = "red" if any(w in title.lower() for w in ("预警", "alert", "错误", "error", "熔断")) else \
+                    "green" if any(w in title.lower() for w in ("晨报", "brief", "完成", "done")) else "blue"
+            payload = {
+                "msg_type": "interactive",
+                "card": {
+                    "header": {
+                        "title": {"tag": "plain_text", "content": title},
+                        "template": color,
+                    },
+                    "elements": [
+                        {"tag": "div", "text": {"tag": "lark_md", "content": body[:2000]}},
+                        {"tag": "hr"},
+                        {"tag": "note", "elements": [
+                            {"tag": "plain_text", "content": "Aria Code · " + __import__("datetime").datetime.now().strftime("%Y-%m-%d %H:%M")}
+                        ]},
+                    ],
+                },
+            }
+        elif "hooks.slack.com" in url:
+            payload = {"text": message}
+        elif "oapi.dingtalk.com" in url:
+            payload = {"msgtype": "text", "text": {"content": message}}
+        else:
+            payload = {"title": title, "body": body, "text": message}
+
+        data = json.dumps(payload).encode("utf-8")
+        req = _urllib_request.Request(
+            url, data=data,
+            headers={"Content-Type": "application/json"},
+            method="POST",
+        )
+        with _urllib_request.urlopen(req, timeout=8) as resp:
+            return resp.status < 400
+    except Exception as e:
+        logger.debug("Webhook notification failed (%s): %s", url[:40], e)
+        return False
+
+
+def _notify_telegram(token: str, chat_ids: str, title: str, body: str) -> bool:
+    """Send a Telegram message to all allowed chat IDs via Bot API."""
+    import urllib.request as _req
+    import urllib.parse as _parse
+
+    ids = [cid.strip() for cid in chat_ids.replace(";", ",").split(",") if cid.strip()]
+    if not ids:
+        return False
+
+    text = f"*{title}*\n{body}"
+    url = f"https://api.telegram.org/bot{token}/sendMessage"
+    success = False
+    for chat_id in ids:
+        data = _parse.urlencode({
+            "chat_id":    chat_id,
+            "text":       text,
+            "parse_mode": "Markdown",
+        }).encode()
+        req = _req.Request(url, data=data, method="POST")
+        try:
+            with _req.urlopen(req, timeout=8) as resp:
+                if resp.status < 400:
+                    success = True
+        except Exception as e:
+            logger.debug("Telegram notification failed for chat_id %s: %s", chat_id, e)
+    return success
+
+
+def _notify_email(cfg: dict, title: str, body: str) -> bool:
+    """Send a plain-text email via SMTP."""
+    try:
+        host     = cfg.get("smtp_host", "smtp.gmail.com")
+        port     = int(cfg.get("smtp_port", 587))
+        username = cfg.get("username", "")
+        password = os.getenv("SMTP_PASSWORD") or cfg.get("password", "")
+        to_addr  = cfg.get("to", username)
+        if not (username and password and to_addr):
+            return False
+        msg = MIMEText(body, "plain", "utf-8")
+        msg["Subject"] = f"[Aria] {title}"
+        msg["From"]    = username
+        msg["To"]      = to_addr
+        with smtplib.SMTP(host, port, timeout=10) as smtp:
+            smtp.starttls()
+            smtp.login(username, password)
+            smtp.sendmail(username, [to_addr], msg.as_string())
+        return True
+    except Exception as e:
+        logger.debug("Email notification failed: %s", e)
+        return False
+
+
+# ── Public API ────────────────────────────────────────────────────────────────
+
+def send_notification(
+    title: str,
+    body: str,
+    *,
+    config: Optional[dict] = None,
+) -> dict:
+    """
+    Dispatch a notification to all configured channels.
+
+    Returns a dict with which channels succeeded.
+    """
+    cfg = config or _load_config()
+    results: dict[str, bool] = {}
+
+    # 1. macOS native (default on when running on macOS)
+    if cfg.get("notify_macos", platform.system() == "Darwin"):
+        results["macos"] = _notify_macos(title, body)
+
+    # 2. Telegram Bot
+    tg_token    = os.getenv("TELEGRAM_BOT_TOKEN") or cfg.get("telegram_bot_token", "")
+    tg_chat_ids = os.getenv("TELEGRAM_ALLOWED_IDS") or cfg.get("telegram_chat_ids", "")
+    if tg_token and tg_chat_ids and tg_token != "your_bot_token_here":
+        results["telegram"] = _notify_telegram(tg_token, tg_chat_ids, title, body)
+
+    # 3. Webhook (企业微信 / 飞书 / Slack / custom)
+    webhook_url = cfg.get("notify_webhook") or os.getenv("ARIA_NOTIFY_WEBHOOK")
+    if webhook_url:
+        results["webhook"] = _notify_webhook(webhook_url, title, body)
+
+    # 4. Email
+    email_cfg = cfg.get("notify_email")
+    if email_cfg and isinstance(email_cfg, dict):
+        results["email"] = _notify_email(email_cfg, title, body)
+
+    if not results:
+        logger.debug(
+            "No notification channels configured. "
+            "Set TELEGRAM_BOT_TOKEN + TELEGRAM_ALLOWED_IDS, "
+            "notify_webhook in ~/.arthera/config.json, or ARIA_NOTIFY_WEBHOOK env var."
+        )
+
+    return {
+        "sent":     any(results.values()),
+        "channels": results,
+        "title":    title,
+        "body":     body,
+    }
+
+
+def send_alert_notification(alert: dict) -> dict:
+    """Convenience wrapper for price alert triggers."""
+    sym   = alert.get("symbol", "")
+    cond  = alert.get("condition", "")
+    tgt   = alert.get("price", "")
+    cur   = alert.get("triggered_price", "N/A")
+    label = alert.get("label") or f"{sym} 价格预警"
+
+    cond_cn = {
+        "gt":         f"突破 {tgt}（现价 {cur}）",
+        "lt":         f"跌破 {tgt}（现价 {cur}）",
+        "cross_up":   f"上穿 {tgt}（现价 {cur}）",
+        "cross_down": f"下穿 {tgt}（现价 {cur}）",
+    }.get(cond, f"触发条件 {cond} ≈ {tgt}，现价 {cur}")
+
+    return send_notification(
+        title=label,
+        body=f"{sym}  {cond_cn}\n触发时间：{alert.get('triggered_at', '')}",
+    )

packages/__init__.py

@@ -0,0 +1,23 @@
+"""Aria Code package facade layer.
+
+This namespace is intentionally thin. It exposes stable package boundaries
+without forcing the existing single-file CLI to move all implementation code at
+once.
+"""
+
+import pathlib as _pathlib
+
+# Extend __path__ to include Arthera/packages/ so that
+# `from packages.quant_engine.*` resolves transparently.
+_arthera_pkgs = _pathlib.Path(__file__).parents[2] / "Arthera" / "packages"
+if _arthera_pkgs.exists() and str(_arthera_pkgs) not in __path__:
+    __path__.append(str(_arthera_pkgs))
+
+__all__ = [
+    "aria_agents",
+    "aria_core",
+    "aria_infra",
+    "aria_mcp",
+    "aria_skills",
+    "aria_tools",
+]

packages/aria_agents/__init__.py

@@ -0,0 +1,5 @@
+"""Agent package facade."""
+
+from .manifest import AgentManifest, list_agent_manifests, manifest_from_agent_class
+
+__all__ = ["AgentManifest", "list_agent_manifests", "manifest_from_agent_class"]

packages/aria_agents/manifest.py

@@ -0,0 +1,69 @@
+"""Agent manifests built from the existing AgentRegistry."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any, Dict, List, Type
+
+from agents.base import BaseAgent
+from agents.registry import get_registry
+from packages.aria_core import CapabilityManifest, PermissionLevel, ServiceKind
+
+
+_CAPABILITIES_BY_AGENT = {
+    "technical": ["market.history", "market.technical"],
+    "fundamental": ["market.fundamentals", "filings"],
+    "macro": ["macro.data", "news"],
+    "risk": ["market.history", "portfolio.risk"],
+    "news": ["news"],
+    "catalyst": ["news", "events"],
+    "sector": ["market.sector"],
+    "earnings": ["filings", "events"],
+    "portfolio": ["portfolio"],
+    "synthesis": ["reasoning.synthesis"],
+    "debate": ["reasoning.debate"],
+}
+
+
+@dataclass(frozen=True)
+class AgentManifest:
+    name: str
+    description: str
+    builtin: bool
+    capabilities: List[str] = field(default_factory=list)
+    permissions: List[PermissionLevel] = field(default_factory=lambda: [PermissionLevel.NETWORK])
+    output_schema: Dict[str, Any] = field(default_factory=lambda: {
+        "type": "object",
+        "required": ["agent", "symbol", "analysis", "confidence", "signal"],
+    })
+
+    def manifest(self) -> CapabilityManifest:
+        return CapabilityManifest(
+            name=self.name,
+            kind=ServiceKind.AGENT,
+            description=self.description,
+            capabilities=self.capabilities,
+            permissions=self.permissions,
+            output_schema=self.output_schema,
+            tags=["agent"],
+        )
+
+
+def manifest_from_agent_class(cls: Type[BaseAgent], *, builtin: bool = True) -> AgentManifest:
+    name = getattr(cls, "name", cls.__name__).lower()
+    return AgentManifest(
+        name=name,
+        description=getattr(cls, "description", ""),
+        builtin=builtin,
+        capabilities=_CAPABILITIES_BY_AGENT.get(name, ["agent"]),
+    )
+
+
+def list_agent_manifests() -> List[AgentManifest]:
+    registry = get_registry()
+    out: List[AgentManifest] = []
+    for item in registry.list():
+        cls = registry.get(item["name"])
+        if cls:
+            out.append(manifest_from_agent_class(cls, builtin=bool(item.get("builtin"))))
+    return sorted(out, key=lambda item: item.name)

packages/aria_core/__init__.py

@@ -0,0 +1,34 @@
+"""Core contracts shared by Aria packages."""
+
+from .architecture import (
+    ARCHITECTURE_SCHEMA_VERSION,
+    ArchitectureLayer,
+    LayerStatus,
+    architecture_contract,
+    architecture_gaps,
+    architecture_layer_map,
+    architecture_status_counts,
+    list_architecture_layers,
+    required_architecture_layer_names,
+)
+from .export import build_package_manifest, build_session_diagnostic_bundle, write_package_manifest
+from .manifest import CapabilityManifest, PackageLink, PermissionLevel, ServiceKind
+
+__all__ = [
+    "ARCHITECTURE_SCHEMA_VERSION",
+    "ArchitectureLayer",
+    "CapabilityManifest",
+    "LayerStatus",
+    "PackageLink",
+    "PermissionLevel",
+    "ServiceKind",
+    "architecture_contract",
+    "architecture_gaps",
+    "architecture_layer_map",
+    "architecture_status_counts",
+    "build_package_manifest",
+    "build_session_diagnostic_bundle",
+    "list_architecture_layers",
+    "required_architecture_layer_names",
+    "write_package_manifest",
+]

packages/aria_core/architecture.py

@@ -0,0 +1,192 @@
+"""Declarative agent architecture contract for Aria Code.
+
+The contract keeps Codex/Claude Code style boundaries explicit while the legacy
+CLI is extracted into smaller packages. It is intentionally pure data so tests,
+doctor checks, docs, and future UI views can share one source of truth.
+"""
+
+from __future__ import annotations
+
+from dataclasses import asdict, dataclass, field
+from enum import Enum
+from typing import Any, Dict, List, Tuple
+
+
+class LayerStatus(str, Enum):
+    DONE = "done"
+    PARTIAL = "partial"
+    PLANNED = "planned"
+    BLOCKED = "blocked"
+
+
+@dataclass(frozen=True)
+class ArchitectureLayer:
+    name: str
+    responsibility: str
+    target_state: str
+    current_state: str
+    status: LayerStatus
+    source_paths: Tuple[str, ...] = field(default_factory=tuple)
+    depends_on: Tuple[str, ...] = field(default_factory=tuple)
+    next_steps: Tuple[str, ...] = field(default_factory=tuple)
+    blockers: Tuple[str, ...] = field(default_factory=tuple)
+
+    @property
+    def is_complete(self) -> bool:
+        return self.status == LayerStatus.DONE
+
+    def to_dict(self) -> Dict[str, Any]:
+        data = asdict(self)
+        data["status"] = self.status.value
+        return data
+
+
+ARCHITECTURE_SCHEMA_VERSION = "aria.agent-architecture.v1"
+
+
+_ARCHITECTURE_LAYERS: Tuple[ArchitectureLayer, ...] = (
+    ArchitectureLayer(
+        name="launcher",
+        responsibility="Stable executable entrypoint, runtime selection, and dependency bootstrap.",
+        target_state="Shell entrypoints resolve the repo, use a controlled virtualenv, and never depend on the caller's random Python.",
+        current_state="aria and aria-code bootstrap local dependencies; existing virtualenvs may still need runtime rebuild support.",
+        status=LayerStatus.PARTIAL,
+        source_paths=("aria-code", "install.sh"),
+        next_steps=("Add a doctor check for Python version drift and a documented venv rebuild command.",),
+    ),
+    ArchitectureLayer(
+        name="settings",
+        responsibility="Configuration, secrets, model profiles, and permission policy resolution.",
+        target_state="A single settings service resolves env, config files, CLI flags, and secrets without leaking credentials.",
+        current_state="Settings are still split across CLI config, env vars, and feature-specific files.",
+        status=LayerStatus.PLANNED,
+        source_paths=("config.py", "settings_manager.py", "cloud_config.py"),
+        next_steps=("Extract SettingsService and make launcher, CLI, daemon, brokers, and MCP use it.",),
+    ),
+    ArchitectureLayer(
+        name="ui",
+        responsibility="Terminal rendering, input UX, progress display, and artifact links.",
+        target_state="A thin UI adapter renders compact, resumable, non-repetitive output with graceful plain-terminal fallback.",
+        current_state="Terminal streaming and approval prompts now have a CLI runtime event consumer; Rich/prompt_toolkit remain optional and generated-file UX still needs hardening.",
+        status=LayerStatus.PARTIAL,
+        source_paths=("ui/", "apps/cli/commands/", "apps/cli/runtime_consumer.py"),
+        next_steps=("Move generated-file open actions and remaining terminal panels behind a UI service.",),
+    ),
+    ArchitectureLayer(
+        name="context",
+        responsibility="Conversation memory, context compaction, task continuity, and artifact-backed summaries.",
+        target_state="Context is automatically compacted before overflow, with recoverable task state and traceable artifacts.",
+        current_state="ContextService owns pressure checks, local compaction, summary prompts, and resume envelopes; durable checkpoints are still pending.",
+        status=LayerStatus.PARTIAL,
+        source_paths=("packages/aria_services/context.py", "apps/cli/message_processing.py", "apps/cli/commands/session_ux_cmds.py"),
+        next_steps=("Persist compaction checkpoints and expose context health through /doctor and support bundles.",),
+        blockers=("Choose artifact schema and retention policy for compact/resume checkpoints.",),
+    ),
+    ArchitectureLayer(
+        name="runtime",
+        responsibility="Agent turn loop, planning, tool execution, retries, streaming, and interruption handling.",
+        target_state="Runtime is separate from UI and business services, with typed tool calls, retries, cancellation, and traces.",
+        current_state="A public packages.aria_sdk facade owns SDK-style query/result events, provider selection, streaming normalization, and the reusable runtime tool-turn loop; CLI rendering/approval is consumed through apps.cli.runtime_consumer. The CLI chat turn can now opt into run_agent via apps.cli.providers.runtime_bridge (config use_runtime_loop), with route-aware provider/fallback decisions in apps.cli.providers.chat_routing; send_message falls back to the inline loop on any error.",
+        status=LayerStatus.PARTIAL,
+        source_paths=("aria_cli.py", "runtime/", "packages/aria_sdk/", "apps/cli/runtime_consumer.py", "apps/cli/deterministic.py", "apps/cli/providers/"),
+        depends_on=("settings", "tools", "safety", "context"),
+        next_steps=("Verify the use_runtime_loop path in a live REPL, default it on, then retire the inline send_message loop so the turn runs entirely through run_agent.",),
+    ),
+    ArchitectureLayer(
+        name="tools",
+        responsibility="Tool registry, schemas, permissions, local commands, and MCP adapters.",
+        target_state="All tools are manifests with input schema, permission level, owner service, and deterministic output shape.",
+        current_state="Legacy tools can be converted to manifests; some direct command paths still bypass the registry.",
+        status=LayerStatus.PARTIAL,
+        source_paths=("packages/aria_tools/", "tools/"),
+        depends_on=("safety",),
+        next_steps=("Route new slash commands through tool/service manifests instead of direct CLI functions.",),
+    ),
+    ArchitectureLayer(
+        name="services",
+        responsibility="Product service boundaries for data, reports, brokers, skills, channels, and gateway.",
+        target_state="Business logic lives behind services; CLI, daemon, MCP, and webhooks are adapters.",
+        current_state="Required service specs now cover gateway, runtime, settings, context, tools, data, reports, brokers, skills, MCP, safety, and observability; several implementations still sit in legacy modules.",
+        status=LayerStatus.PARTIAL,
+        source_paths=(
+            "packages/aria_services/",
+            "docs/architecture/service_boundaries.md",
+            "docs/architecture/claude_code_parity_gap_analysis.md",
+        ),
+        depends_on=("settings", "runtime", "tools"),
+        next_steps=("Extract concrete SettingsService, SafetyService, ReportService, GatewayService, and ObservabilityService implementations behind the registered service manifests.",),
+    ),
+    ArchitectureLayer(
+        name="mcp",
+        responsibility="External package/tool integration through MCP and explicit adapters.",
+        target_state="MCP servers expose typed tools, health, permissions, and connection status independent of CLI state.",
+        current_state="Arthera Quant Engine bridge has manifests and doctor checks; lifecycle management still needs tightening.",
+        status=LayerStatus.PARTIAL,
+        source_paths=("packages/aria_mcp/",),
+        depends_on=("tools", "services"),
+        next_steps=("Add MCP reload/reconnect policy, tool provenance, and per-server failure isolation.",),
+    ),
+    ArchitectureLayer(
+        name="safety",
+        responsibility="Filesystem, shell, network, broker, and privacy guardrails.",
+        target_state="Every risky action is classified, previewed when needed, audited, and blocked by default for live trading.",
+        current_state="Broker preview/confirm exists, but shell/network/file policies are not yet one unified service.",
+        status=LayerStatus.PARTIAL,
+        source_paths=("safety/", "brokers/", "apps/cli/commands/broker_cmds.py"),
+        depends_on=("settings", "tools"),
+        next_steps=("Unify command policy, broker risk policy, and privacy controls under SafetyService.",),
+    ),
+    ArchitectureLayer(
+        name="channels",
+        responsibility="Daemon, webhook, TradingView alerts, Feishu, Telegram, and future external entrypoints.",
+        target_state="Channels submit structured tasks to gateway/runtime and never call CLI internals directly.",
+        current_state="TradingView URL/Pine generation exists; webhook-to-daemon routing is still incomplete.",
+        status=LayerStatus.PLANNED,
+        source_paths=("aria_daemon.py", "apps/channels/"),
+        depends_on=("settings", "runtime", "services", "safety"),
+        next_steps=("Implement channel registry and TradingView alert webhook flow through gateway.",),
+    ),
+    ArchitectureLayer(
+        name="observability",
+        responsibility="Doctor checks, traces, provider health, audit logs, and user-visible diagnostics.",
+        target_state="Health checks explain missing services, degraded providers, unsafe configs, and incomplete architecture layers.",
+        current_state="Provider and package doctor checks exist; this contract represents architecture coverage. The /architecture command renders it (layers, status, gaps, per-layer next steps; --gaps for outstanding work) and /doctor prints a one-line coverage summary.",
+        status=LayerStatus.PARTIAL,
+        source_paths=("packages/aria_infra/doctor.py", "packages/aria_services/provider_health.py", "apps/cli/commands/diagnostic_ops_cmds.py", "aria_cli.py"),
+        depends_on=("services", "mcp", "safety"),
+        next_steps=("Fold the architecture summary into generated support bundles too.",),
+    ),
+)
+
+
+def list_architecture_layers() -> List[ArchitectureLayer]:
+    """Return the product architecture layers in dependency order."""
+
+    return list(_ARCHITECTURE_LAYERS)
+
+
+def architecture_layer_map() -> Dict[str, ArchitectureLayer]:
+    return {layer.name: layer for layer in _ARCHITECTURE_LAYERS}
+
+
+def required_architecture_layer_names() -> List[str]:
+    return [layer.name for layer in _ARCHITECTURE_LAYERS]
+
+
+def architecture_gaps() -> List[ArchitectureLayer]:
+    return [layer for layer in _ARCHITECTURE_LAYERS if not layer.is_complete]
+
+
+def architecture_status_counts() -> Dict[str, int]:
+    counts = {status.value: 0 for status in LayerStatus}
+    for layer in _ARCHITECTURE_LAYERS:
+        counts[layer.status.value] += 1
+    return counts
+
+
+def architecture_contract() -> Dict[str, Any]:
+    return {
+        "schema_version": ARCHITECTURE_SCHEMA_VERSION,
+        "layers": [layer.to_dict() for layer in _ARCHITECTURE_LAYERS],
+        "status_counts": architecture_status_counts(),
+    }