aria-code 0.167.0__py3-none-win_amd64.whl

aria_code/brokers/registry.py

@@ -0,0 +1,213 @@
+"""
+brokers/registry.py — 券商注册表 & 连接管理器
+================================================
+统一管理所有已连接的券商实例。
+支持多账户并发持有（如同时连接 IBKR + 富途）。
+
+用法::
+
+    from brokers.registry import BrokerRegistry
+
+    reg = BrokerRegistry()
+    broker = reg.connect("xt_main")         # 从 brokers.json 读取并连接
+    acct   = broker.account_info()
+    pos    = broker.positions()
+
+    # 切换默认账户
+    reg.set_active("ibkr_us")
+    broker = reg.active()
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Any, Dict, List, Optional, Type
+
+from .base   import BrokerBase
+from .config import (
+    get_broker_config, get_default_broker_config,
+    list_broker_configs, set_default_broker,
+)
+
+logger = logging.getLogger(__name__)
+
+# ── 适配器注册表 ───────────────────────────────────────────────────────────────
+
+_BROKER_CLASSES: Dict[str, Type[BrokerBase]] = {}
+
+
+def _register_all() -> None:
+    """延迟注册所有内置适配器（避免 import 循环）。"""
+    # No `global` needed: _BROKER_CLASSES is only read and mutated in place.
+    if _BROKER_CLASSES:
+        return
+    _map: Dict[str, tuple] = {
+        "paper":      ("brokers.paper_broker",        "PaperBroker"),
+        "xtquant":    ("brokers.cn.xtquant_broker",    "XTQuantBroker"),
+        "easytrader": ("brokers.cn.easytrader_broker", "EasyTraderBroker"),
+        "futu":       ("brokers.cn.futu_broker",       "FutuBroker"),
+        "tiger":      ("brokers.cn.tiger_broker",      "TigerBroker"),
+        "longbridge": ("brokers.cn.longbridge_broker", "LongbridgeBroker"),
+        "ibkr":       ("brokers.intl.ibkr_broker",     "IBKRBroker"),
+        "alpaca":     ("brokers.intl.alpaca_broker",   "AlpacaBroker"),
+        "webull":     ("brokers.intl.webull_broker",   "WebullBroker"),
+        "trading212": ("brokers.intl.trading212_broker", "Trading212Broker"),
+    }
+    for btype, (module_path, class_name) in _map.items():
+        try:
+            import importlib
+            mod = importlib.import_module(module_path)
+            _BROKER_CLASSES[btype] = getattr(mod, class_name)
+        except Exception as e:
+            logger.debug("Broker class load failed for %s: %s", btype, e)
+
+
+def get_broker_class(broker_type: str) -> Optional[Type[BrokerBase]]:
+    _register_all()
+    return _BROKER_CLASSES.get(broker_type)
+
+
+# ── 连接管理器 ────────────────────────────────────────────────────────────────
+
+class BrokerRegistry:
+    """全局券商连接池，单例使用。"""
+
+    def __init__(self):
+        self._instances: Dict[str, BrokerBase] = {}  # broker_id → instance
+        self._active_id: Optional[str] = None
+
+    # ── 连接 ──────────────────────────────────────────────────────────────────
+
+    def connect(self, broker_id: str) -> BrokerBase:
+        """连接指定 id 的券商（如已连接则直接返回）。"""
+        if broker_id in self._instances and self._instances[broker_id].is_connected:
+            return self._instances[broker_id]
+
+        cfg = get_broker_config(broker_id)
+        if not cfg:
+            raise ValueError(f"未找到券商配置: {broker_id!r}  (请在 ~/.arthera/brokers.json 添加)")
+
+        broker_type = cfg.get("type", "")
+        cls = get_broker_class(broker_type)
+        if not cls:
+            raise ValueError(
+                f"不支持的券商类型: {broker_type!r}\n"
+                f"支持的类型: {', '.join(_BROKER_CLASSES)}"
+            )
+
+        instance = cls(broker_id=broker_id, config=cfg)
+        instance.connect()
+        self._instances[broker_id] = instance
+
+        if self._active_id is None:
+            self._active_id = broker_id
+
+        logger.info("✓ 已连接券商: %s (%s)", instance.label, broker_type)
+        return instance
+
+    def connect_default(self) -> Optional[BrokerBase]:
+        """连接 brokers.json 中标记为 default 的券商。"""
+        cfg = get_default_broker_config()
+        if not cfg:
+            return None
+        return self.connect(cfg["id"])
+
+    def connect_all(self) -> List[BrokerBase]:
+        """尝试连接所有已配置的券商，跳过连接失败的。"""
+        connected = []
+        for cfg in list_broker_configs():
+            try:
+                b = self.connect(cfg["id"])
+                connected.append(b)
+            except Exception as e:
+                logger.warning("连接券商 %s 失败: %s", cfg.get("id"), e)
+        return connected
+
+    # ── 查询 ──────────────────────────────────────────────────────────────────
+
+    def active(self) -> Optional[BrokerBase]:
+        """返回当前活跃的券商实例。"""
+        if not self._active_id:
+            return None
+        return self._instances.get(self._active_id)
+
+    def get(self, broker_id: str) -> Optional[BrokerBase]:
+        """按 id 获取已连接的实例。"""
+        return self._instances.get(broker_id)
+
+    def ensure(self, broker_id: str) -> BrokerBase:
+        """返回可用实例，链路掉线则透明重连。长驻调用方应优先用此方法而非 get()/connect()。"""
+        inst = self._instances.get(broker_id)
+        if inst is not None:
+            try:
+                if inst.ensure_connected():
+                    return inst
+            except Exception:
+                pass
+            # 实例级重连失败 → 丢弃后整体重建
+            self._instances.pop(broker_id, None)
+        return self.connect(broker_id)
+
+    def health(self) -> List[Dict[str, Any]]:
+        """连接健康快照（供 /broker 状态展示）。"""
+        out: List[Dict[str, Any]] = []
+        for bid, inst in self._instances.items():
+            try:
+                healthy = bool(inst.is_connected and inst.ping())
+            except Exception:
+                healthy = False
+            out.append({
+                "broker_id": bid,
+                "label": getattr(inst, "label", bid),
+                "type": getattr(inst, "broker_type", ""),
+                "connected": bool(inst.is_connected),
+                "healthy": healthy,
+                "active": bid == self._active_id,
+            })
+        return out
+
+    def list_connected(self) -> List[BrokerBase]:
+        """返回所有已连接的券商。"""
+        return [b for b in self._instances.values() if b.is_connected]
+
+    def set_active(self, broker_id: str) -> bool:
+        """设置当前活跃账户。"""
+        if broker_id not in self._instances:
+            return False
+        self._active_id = broker_id
+        set_default_broker(broker_id)
+        return True
+
+    # ── 断开 ──────────────────────────────────────────────────────────────────
+
+    def disconnect(self, broker_id: str) -> None:
+        b = self._instances.pop(broker_id, None)
+        if b:
+            b.disconnect()
+        if self._active_id == broker_id:
+            remaining = list(self._instances)
+            self._active_id = remaining[0] if remaining else None
+
+    def disconnect_all(self) -> None:
+        for b in list(self._instances.values()):
+            try:
+                b.disconnect()
+            except Exception:
+                pass
+        self._instances.clear()
+        self._active_id = None
+
+    def __repr__(self) -> str:
+        ids = list(self._instances)
+        return f"<BrokerRegistry active={self._active_id!r} connected={ids}>"
+
+
+# 全局单例（在 aria_cli.py 中 import 后使用）
+_global_registry: Optional[BrokerRegistry] = None
+
+
+def get_registry() -> BrokerRegistry:
+    global _global_registry
+    if _global_registry is None:
+        _global_registry = BrokerRegistry()
+    return _global_registry

aria_code/brokers/trading.py

@@ -0,0 +1,267 @@
+"""Trading service layer for paper/live execution.
+
+All order execution flows through a preview id. Live trading is denied unless
+the broker config explicitly enables ``allow_live_trade``.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import time
+import uuid
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+from .config import BROKERS_CONFIG_PATH
+from .planning import RiskRuleSet, StrategyIntent, plan_order, snapshot_from_broker
+
+
+TRADE_PREVIEWS_PATH = BROKERS_CONFIG_PATH.parent / "trade_previews.json"
+TRADE_AUDIT_PATH = BROKERS_CONFIG_PATH.parent / "trade_audit.jsonl"
+
+_DRY_RUN_VALUES = {"1", "true", "yes", "on"}
+
+
+def global_dry_run() -> bool:
+    """Global trading kill-switch.
+
+    When ``ARIA_DRY_RUN`` is truthy, ALL brokers are forced read-only regardless
+    of their per-broker config — order previews are never executable. A single
+    operational switch for demos, testing, or a risk-off freeze:
+        export ARIA_DRY_RUN=1
+    """
+    return str(os.getenv("ARIA_DRY_RUN", "")).strip().lower() in _DRY_RUN_VALUES
+
+
+@dataclass(frozen=True)
+class TradingPolicy:
+    mode: str = "read_only"  # read_only | paper | live
+    allow_live_trade: bool = False
+    require_confirm: bool = True
+    max_single_position_weight: float = 0.20
+    min_cash_reserve_weight: float = 0.02
+    max_order_value_weight: float = 0.10
+    allow_short: bool = False
+    allow_fractional: bool = False
+
+    def rules(self) -> RiskRuleSet:
+        return RiskRuleSet(
+            max_single_position_weight=self.max_single_position_weight,
+            min_cash_reserve_weight=self.min_cash_reserve_weight,
+            max_order_value_weight=self.max_order_value_weight,
+            allow_short=self.allow_short,
+            allow_fractional=self.allow_fractional,
+        )
+
+
+@dataclass(frozen=True)
+class OrderIntent:
+    symbol: str
+    side: str
+    quantity: Optional[float] = None
+    order_type: str = "limit"
+    price: Optional[float] = None
+    source: str = "manual"
+    target_weight: Optional[float] = None
+    user_message: str = ""
+    metadata: Dict[str, Any] = field(default_factory=dict)
+
+
+def resolve_trading_mode(config: Dict[str, Any], broker_type: str = "") -> str:
+    if global_dry_run():
+        return "read_only"
+    explicit = str(config.get("mode", "") or "").lower()
+    if explicit in {"read_only", "paper", "live"}:
+        return explicit
+    if broker_type == "paper" or config.get("paper") is True:
+        return "paper"
+    return "read_only"
+
+
+def policy_from_config(config: Dict[str, Any], broker_type: str = "") -> TradingPolicy:
+    mode = resolve_trading_mode(config, broker_type=broker_type)
+    return TradingPolicy(
+        mode=mode,
+        allow_live_trade=bool(config.get("allow_live_trade", False)),
+        require_confirm=bool(config.get("require_confirm", True)),
+        max_single_position_weight=float(config.get("max_single_position_weight", 0.20) or 0.20),
+        min_cash_reserve_weight=float(config.get("min_cash_reserve_weight", 0.02) or 0.02),
+        max_order_value_weight=float(config.get("max_order_value_weight", 0.10) or 0.10),
+        allow_short=bool(config.get("allow_short", False)),
+        allow_fractional=bool(config.get("allow_fractional", False)),
+    )
+
+
+def _load_previews() -> Dict[str, Any]:
+    if not TRADE_PREVIEWS_PATH.exists():
+        return {"previews": {}}
+    try:
+        data = json.loads(TRADE_PREVIEWS_PATH.read_text(encoding="utf-8"))
+        if isinstance(data, dict):
+            data.setdefault("previews", {})
+            return data
+    except Exception:
+        pass
+    return {"previews": {}}
+
+
+def _save_previews(data: Dict[str, Any]) -> None:
+    TRADE_PREVIEWS_PATH.parent.mkdir(parents=True, exist_ok=True)
+    TRADE_PREVIEWS_PATH.write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")
+
+
+def _audit(event: Dict[str, Any]) -> None:
+    TRADE_AUDIT_PATH.parent.mkdir(parents=True, exist_ok=True)
+    row = {"ts": int(time.time()), **event}
+    with TRADE_AUDIT_PATH.open("a", encoding="utf-8") as handle:
+        handle.write(json.dumps(row, ensure_ascii=False) + "\n")
+
+
+def _execution_blockers(policy: TradingPolicy, plan: Dict[str, Any]) -> list[str]:
+    blockers: list[str] = []
+    if global_dry_run():
+        blockers.append("全局 dry-run 模式已启用 (ARIA_DRY_RUN)，所有下单被冻结")
+    risk = plan.get("risk") or {}
+    blockers.extend(str(item) for item in risk.get("violations") or [])
+    if plan.get("action") in {"buy", "sell", "rebalance"} and not plan.get("estimated_order"):
+        blockers.append("订单计划没有可执行订单，通常是缺少价格、数量或持仓")
+    if policy.mode == "read_only":
+        blockers.append("账户处于 read_only 模式，不能执行订单")
+    if policy.mode == "live" and not policy.allow_live_trade:
+        blockers.append("实盘账户未设置 allow_live_trade=true")
+    return blockers
+
+
+def build_order_preview(broker: Any, intent: OrderIntent) -> Dict[str, Any]:
+    policy = policy_from_config(getattr(broker, "config", {}) or {}, getattr(broker, "broker_type", ""))
+    snapshot = snapshot_from_broker(broker)
+    strategy_intent = StrategyIntent(
+        symbol=intent.symbol,
+        action=intent.side,
+        target_weight=intent.target_weight,
+        reason=intent.user_message,
+        source=intent.source,
+        metadata=dict(intent.metadata),
+    )
+    planned = plan_order(
+        snapshot,
+        strategy_intent,
+        price=float(intent.price) if intent.price is not None else None,
+        quantity=float(intent.quantity) if intent.quantity is not None else None,
+        order_type=intent.order_type,
+        rules=policy.rules(),
+    )
+    plan_dict = planned.to_dict()
+    preview_id = "tp_" + uuid.uuid4().hex[:12]
+    blockers = _execution_blockers(policy, plan_dict)
+    preview = {
+        "preview_id": preview_id,
+        "created_at": int(time.time()),
+        "status": "pending",
+        "broker_id": getattr(broker, "broker_id", ""),
+        "broker_label": getattr(broker, "label", ""),
+        "broker_type": getattr(broker, "broker_type", ""),
+        "mode": policy.mode,
+        "allow_live_trade": policy.allow_live_trade,
+        "require_confirm": policy.require_confirm,
+        "intent": {
+            "symbol": intent.symbol.upper(),
+            "side": intent.side.lower(),
+            "quantity": float(intent.quantity) if intent.quantity is not None else None,
+            "order_type": intent.order_type.lower(),
+            "price": intent.price,
+            "source": intent.source,
+        },
+        "order_plan": plan_dict,
+        "execution_blockers": blockers,
+        "can_execute": not blockers,
+        "audit_path": str(TRADE_AUDIT_PATH),
+    }
+    store = _load_previews()
+    store.setdefault("previews", {})[preview_id] = preview
+    _save_previews(store)
+    _audit({"event": "trade_preview", "preview": preview})
+    return preview
+
+
+def load_order_preview(preview_id: str) -> Dict[str, Any] | None:
+    return (_load_previews().get("previews") or {}).get(preview_id)
+
+
+def list_order_previews(limit: int = 10) -> list[Dict[str, Any]]:
+    rows = list((_load_previews().get("previews") or {}).values())
+    rows.sort(key=lambda row: int(row.get("created_at", 0)), reverse=True)
+    return rows[: max(0, int(limit or 10))]
+
+
+def mark_preview_status(preview_id: str, status: str, extra: Optional[Dict[str, Any]] = None) -> None:
+    store = _load_previews()
+    preview = (store.get("previews") or {}).get(preview_id)
+    if not preview:
+        return
+    preview["status"] = status
+    preview["updated_at"] = int(time.time())
+    if extra:
+        preview.update(extra)
+    _save_previews(store)
+
+
+def execute_order_preview(
+    broker: Any,
+    preview_id: str,
+    *,
+    confirmed: bool = False,
+    source: str = "terminal",
+) -> Dict[str, Any]:
+    """`source` is audit-trail metadata only, never a trust signal — it does
+    not change what this function will or won't execute. It exists so the
+    audit log can distinguish a human typing /trade confirm at the terminal
+    keyboard ("terminal", the default) from the separate, explicitly-gated
+    chat-confirm MCP path ("chat_mcp") — see packages/aria_mcp/server.py's
+    _call_broker_confirm_order for that gate."""
+    preview = load_order_preview(preview_id)
+    if not preview:
+        return {"success": False, "error": f"preview not found: {preview_id}"}
+    if not confirmed:
+        return {"success": False, "confirmation_required": True, "preview": preview}
+    if preview.get("broker_id") != getattr(broker, "broker_id", ""):
+        return {"success": False, "error": "preview broker does not match active broker", "preview": preview}
+
+    policy = policy_from_config(getattr(broker, "config", {}) or {}, getattr(broker, "broker_type", ""))
+    blockers = _execution_blockers(policy, preview.get("order_plan") or {})
+    if blockers:
+        mark_preview_status(preview_id, "rejected", {"execution_blockers": blockers})
+        _audit({"event": "trade_rejected", "preview_id": preview_id, "blockers": blockers})
+        return {"success": False, "risk_rejected": True, "execution_blockers": blockers, "preview": preview}
+
+    intent = preview.get("intent") or {}
+    planned_order = ((preview.get("order_plan") or {}).get("estimated_order") or {})
+    if not planned_order:
+        return {"success": False, "error": "preview has no executable order", "preview": preview}
+    result = broker.place_order(
+        symbol=str(planned_order.get("symbol") or intent.get("symbol", "")),
+        side=str(planned_order.get("side") or intent.get("side", "")),
+        quantity=float(planned_order.get("quantity", intent.get("quantity", 0.0)) or 0.0),
+        order_type=str(planned_order.get("order_type") or intent.get("order_type", "limit")),
+        price=float(planned_order.get("price", intent.get("price", 0.0)) or 0.0),
+    )
+    payload = {
+        "success": bool(getattr(result, "success", False)),
+        "order_id": getattr(result, "order_id", ""),
+        "message": getattr(result, "message", ""),
+        "broker": getattr(broker, "label", ""),
+        "broker_id": getattr(broker, "broker_id", ""),
+        "mode": policy.mode,
+        "preview_id": preview_id,
+        "symbol": str(planned_order.get("symbol") or intent.get("symbol", "")),
+        "side": str(planned_order.get("side") or intent.get("side", "")),
+        "qty": float(planned_order.get("quantity", intent.get("quantity", 0.0)) or 0.0),
+        "order_plan": preview.get("order_plan"),
+    }
+    mark_preview_status(preview_id, "executed" if payload["success"] else "failed", {
+        "result": payload,
+    })
+    _audit({"event": "trade_execute", "preview_id": preview_id, "result": payload, "source": source})
+    return payload

aria_code/canva_client.py

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

aria_code/change_store.py

@@ -0,0 +1,127 @@
+"""Staged file-change store for Aria Code.
+
+The CLI still supports direct writes for existing workflows, but every write can
+now be represented as a hash-checked change first. This gives us Codex/Claude
+Code style review/apply/reject primitives without coupling the logic to the REPL.
+"""
+
+from __future__ import annotations
+
+import difflib
+import hashlib
+import os
+import pathlib
+import time
+import uuid
+from dataclasses import asdict, dataclass
+from typing import Dict, List, Optional
+
+
+class ChangeConflictError(RuntimeError):
+    """Raised when the file changed after a staged change was created."""
+
+
+def sha256_text(text: str) -> str:
+    return hashlib.sha256(text.encode("utf-8", errors="replace")).hexdigest()
+
+
+@dataclass(frozen=True)
+class StagedChange:
+    change_id: str
+    path: str
+    before_content: str
+    after_content: str
+    before_hash: str
+    after_hash: str
+    diff: str
+    created_at: float
+    source: str = "aria-code"
+    applied: bool = False
+    rejected: bool = False
+
+    def to_dict(self) -> dict:
+        return asdict(self)
+
+
+class ChangeStore:
+    """In-memory staged change store with conflict-aware apply."""
+
+    def __init__(self) -> None:
+        self._changes: Dict[str, StagedChange] = {}
+
+    def stage(self, path: str | pathlib.Path, after_content: str, source: str = "aria-code") -> StagedChange:
+        target = pathlib.Path(path).expanduser().resolve()
+        before = target.read_text(encoding="utf-8", errors="replace") if target.is_file() else ""
+        rel = str(target)
+        diff = "".join(difflib.unified_diff(
+            before.splitlines(keepends=True),
+            after_content.splitlines(keepends=True),
+            fromfile=f"a/{rel}",
+            tofile=f"b/{rel}",
+        ))
+        change = StagedChange(
+            change_id=uuid.uuid4().hex[:12],
+            path=rel,
+            before_content=before,
+            after_content=after_content,
+            before_hash=sha256_text(before),
+            after_hash=sha256_text(after_content),
+            diff=diff,
+            created_at=time.time(),
+            source=source,
+        )
+        self._changes[change.change_id] = change
+        return change
+
+    def list(self, include_closed: bool = False) -> List[StagedChange]:
+        changes = list(self._changes.values())
+        if not include_closed:
+            changes = [c for c in changes if not c.applied and not c.rejected]
+        return sorted(changes, key=lambda c: c.created_at)
+
+    def get(self, change_id: str) -> Optional[StagedChange]:
+        return self._changes.get(change_id)
+
+    def apply(self, change_id: str) -> StagedChange:
+        change = self._require_open(change_id)
+        target = pathlib.Path(change.path)
+        current = target.read_text(encoding="utf-8", errors="replace") if target.is_file() else ""
+        if sha256_text(current) != change.before_hash:
+            raise ChangeConflictError(f"File changed since staging: {change.path}")
+        target.parent.mkdir(parents=True, exist_ok=True)
+        tmp = target.with_name(f".{target.name}.aria-tmp-{uuid.uuid4().hex[:8]}")
+        tmp.write_text(change.after_content, encoding="utf-8")
+        os.replace(tmp, target)
+        applied = StagedChange(**{**change.to_dict(), "applied": True})
+        self._changes[change.change_id] = applied
+        return applied
+
+    def reject(self, change_id: str) -> StagedChange:
+        change = self._require_open(change_id)
+        rejected = StagedChange(**{**change.to_dict(), "rejected": True})
+        self._changes[change.change_id] = rejected
+        return rejected
+
+    def clear_closed(self) -> int:
+        closed = [cid for cid, c in self._changes.items() if c.applied or c.rejected]
+        for cid in closed:
+            del self._changes[cid]
+        return len(closed)
+
+    def _require_open(self, change_id: str) -> StagedChange:
+        key = (change_id or "").strip()
+        change = self._changes.get(key)
+        if change is None:
+            matches = [c for cid, c in self._changes.items() if cid.startswith(key)]
+            if len(matches) == 1:
+                change = matches[0]
+        if change is None:
+            raise KeyError(f"Unknown change id: {change_id}")
+        if change.applied:
+            raise ValueError(f"Change already applied: {change.change_id}")
+        if change.rejected:
+            raise ValueError(f"Change already rejected: {change.change_id}")
+        return change
+
+
+GLOBAL_CHANGE_STORE = ChangeStore()